Add test.

ehsannas · ehsannas · commit 9b223570c506 · 2022-04-14T23:34:04.000-05:00
diff --git a/packages/firestore/src/local/indexeddb_schema.ts b/packages/firestore/src/local/indexeddb_schema.ts
@@ -31,7 +31,7 @@ import { DbTimestampKey } from './indexeddb_sentinels';
 // TODO(indexing): Remove this constant
 const INDEXING_ENABLED = false;
 
-export const INDEXING_SCHEMA_VERSION = 14;
+export const INDEXING_SCHEMA_VERSION = 15;
 
 /**
  * Schema Version for the Web client:
@@ -57,7 +57,7 @@ export const INDEXING_SCHEMA_VERSION = 14;
  * 14. Add indexing support.
  */
 
-export const SCHEMA_VERSION = INDEXING_ENABLED ? INDEXING_SCHEMA_VERSION : 13;
+export const SCHEMA_VERSION = INDEXING_ENABLED ? INDEXING_SCHEMA_VERSION : 14;
 
 /**
  * Wrapper class to store timestamps (seconds and nanos) in IndexedDb objects.
diff --git a/packages/firestore/src/local/indexeddb_schema_converter.ts b/packages/firestore/src/local/indexeddb_schema_converter.ts
@@ -249,9 +249,11 @@ export class SchemaConverter implements SimpleDbSchemaConverter {
     }
 
     if (fromVersion < 14 && toVersion >= 14) {
-      p = p
-        .next(() => createFieldIndex(db))
-        .next(() => this.runOverlayMigration(db, simpleDbTransaction));
+      p = p.next(() => this.runOverlayMigration(db, simpleDbTransaction));
+    }
+
+    if (fromVersion < 15 && toVersion >= 15) {
+      p = p.next(() => createFieldIndex(db));
     }
 
     return p;
@@ -477,6 +479,10 @@ export class SchemaConverter implements SimpleDbSchemaConverter {
       DbMutationBatch
     >(DbMutationBatchStore);
 
+    const remoteDocumentCache = newIndexedDbRemoteDocumentCache(
+      this.serializer
+    );
+
     const promises: Array<PersistencePromise<void>> = [];
     let userIds = new Set<string>();
 
@@ -491,9 +497,6 @@ export class SchemaConverter implements SimpleDbSchemaConverter {
           }
           userIds = userIds.add(userId);
           const user = new User(userId);
-          const remoteDocumentCache = newIndexedDbRemoteDocumentCache(
-            this.serializer
-          );
           const documentOverlayCache = IndexedDbDocumentOverlayCache.forUser(
             this.serializer,
             user
diff --git a/packages/firestore/src/local/indexeddb_sentinels.ts b/packages/firestore/src/local/indexeddb_sentinels.ts
@@ -407,8 +407,9 @@ export const V13_STORES = [
   DbNamedQueryStore,
   DbDocumentOverlayStore
 ];
-export const V14_STORES = [
-  ...V13_STORES,
+export const V14_STORES = V13_STORES;
+export const V15_STORES = [
+  ...V14_STORES,
   DbIndexConfigurationStore,
   DbIndexStateStore,
   DbIndexEntryStore
@@ -423,7 +424,9 @@ export const ALL_STORES = V12_STORES;
 
 /** Returns the object stores for the provided schema. */
 export function getObjectStores(schemaVersion: number): string[] {
-  if (schemaVersion === 14) {
+  if (schemaVersion === 15) {
+    return V15_STORES;
+  } else if (schemaVersion === 14) {
     return V14_STORES;
   } else if (schemaVersion === 13) {
     return V13_STORES;
diff --git a/packages/firestore/test/unit/local/indexeddb_persistence.test.ts b/packages/firestore/test/unit/local/indexeddb_persistence.test.ts
@@ -30,6 +30,7 @@ import { IndexedDbPersistence } from '../../../src/local/indexeddb_persistence';
 import {
   DbCollectionParent,
   DbDocumentMutation,
+  DbDocumentOverlay,
   DbMutationBatch,
   DbMutationQueue,
   DbPrimaryClient,
@@ -52,6 +53,8 @@ import {
   DbDocumentMutationKey,
   DbDocumentMutationPlaceholder,
   DbDocumentMutationStore,
+  DbDocumentOverlayKey,
+  DbDocumentOverlayStore,
   DbMutationBatchKey,
   DbMutationBatchStore,
   DbMutationQueueKey,
@@ -81,6 +84,7 @@ import {
 import {
   fromDbTarget,
   LocalSerializer,
+  toDbDocumentOverlayKey,
   toDbRemoteDocument,
   toDbTarget,
   toDbTimestamp,
@@ -92,6 +96,7 @@ import { ClientId } from '../../../src/local/shared_client_state';
 import { SimpleDb, SimpleDbTransaction } from '../../../src/local/simple_db';
 import { TargetData, TargetPurpose } from '../../../src/local/target_data';
 import { MutableDocument } from '../../../src/model/document';
+import { DocumentKey } from '../../../src/model/document_key';
 import { getWindow } from '../../../src/platform/dom';
 import { firestoreV1ApiClientInterfaces } from '../../../src/protos/firestore_proto_api';
 import {
@@ -1044,6 +1049,214 @@ describe('IndexedDbSchema: createOrUpgradeDb', () => {
     });
   });
 
+  it('can upgrade from schema version 13 to 14 (overlay migration)', function (this: Context) {
+    // This test creates a database with schema version 13 that has three users,
+    // two of whom have local mutations.
+    const testWriteFoo = {
+      update: {
+        name: 'projects/test-project/databases/(default)/documents/docs/foo',
+        fields: {}
+      }
+    };
+    const testWriteBar = {
+      update: {
+        name: 'projects/test-project/databases/(default)/documents/docs/bar',
+        fields: {}
+      }
+    };
+    const testWriteBaz = {
+      update: {
+        name: 'projects/test-project/databases/(default)/documents/docs/baz',
+        fields: {}
+      }
+    };
+    const testWritePending = {
+      update: {
+        name: 'projects/test-project/databases/(default)/documents/docs/pending',
+        fields: {}
+      }
+    };
+    const testMutations: DbMutationBatch[] = [
+      {
+        userId: 'user1',
+        batchId: 1,
+        localWriteTimeMs: 1337,
+        baseMutations: undefined,
+        mutations: [testWriteFoo]
+      },
+      {
+        userId: 'user1',
+        batchId: 2,
+        localWriteTimeMs: 1337,
+        baseMutations: undefined,
+        mutations: [testWriteFoo]
+      },
+      {
+        userId: 'user2',
+        batchId: 3,
+        localWriteTimeMs: 1337,
+        baseMutations: undefined,
+        mutations: [testWriteBar, testWriteBaz]
+      },
+      {
+        userId: 'user2',
+        batchId: 4,
+        localWriteTimeMs: 1337,
+        baseMutations: undefined,
+        mutations: [testWritePending]
+      },
+      {
+        userId: 'user1',
+        batchId: 5,
+        localWriteTimeMs: 1337,
+        baseMutations: undefined,
+        mutations: [testWritePending]
+      }
+    ];
+
+    return withDb(13, db => {
+      return db.runTransaction(
+        this.test!.fullTitle(),
+        'readwrite',
+        V13_STORES,
+        txn => {
+          const mutationBatchStore = txn.store<
+            DbMutationBatchKey,
+            DbMutationBatch
+          >(DbMutationBatchStore);
+          const documentMutationStore = txn.store<
+            DbDocumentMutationKey,
+            DbDocumentMutation
+          >(DbDocumentMutationStore);
+          const mutationQueuesStore = txn.store<
+            DbMutationQueueKey,
+            DbMutationQueue
+          >(DbMutationQueueStore);
+          // Manually populate the mutation queue and create all indicies.
+          return PersistencePromise.forEach(
+            testMutations,
+            (testMutation: DbMutationBatch) => {
+              return mutationBatchStore.put(testMutation).next(() => {
+                return PersistencePromise.forEach(
+                  testMutation.mutations,
+                  (write: firestoreV1ApiClientInterfaces.Write) => {
+                    const indexKey = newDbDocumentMutationKey(
+                      testMutation.userId,
+                      path(write.update!.name!, 5),
+                      testMutation.batchId
+                    );
+                    return documentMutationStore.put(
+                      indexKey,
+                      DbDocumentMutationPlaceholder
+                    );
+                  }
+                );
+              });
+            }
+          ).next(() =>
+            // Populate the mutation queues' metadata
+            PersistencePromise.waitFor([
+              mutationQueuesStore.put({
+                userId: 'user1',
+                lastAcknowledgedBatchId: -1,
+                lastStreamToken: ''
+              }),
+              mutationQueuesStore.put({
+                userId: 'user2',
+                lastAcknowledgedBatchId: -1,
+                lastStreamToken: ''
+              }),
+              mutationQueuesStore.put({
+                userId: 'user3',
+                lastAcknowledgedBatchId: -1,
+                lastStreamToken: ''
+              })
+            ])
+          );
+        }
+      );
+    }).then(() =>
+      withDb(14, (db, version) => {
+        expect(version).to.be.equal(14);
+
+        return db.runTransaction(
+          this.test!.fullTitle(),
+          'readwrite',
+          V14_STORES,
+          txn => {
+            const documentOverlayStore = txn.store<
+              DbDocumentOverlayKey,
+              DbDocumentOverlay
+            >(DbDocumentOverlayStore);
+
+            // We should have a total of 5 overlays:
+            // For user1: testWriteFoo, and testWritePending
+            // For user2: testWriteBar, testWriteBaz, and testWritePending
+            // For user3: NO OVERLAYS!
+            let p = documentOverlayStore.count().next(count => {
+              expect(count).to.equal(5);
+            });
+            p = p.next(() => {
+              const key = toDbDocumentOverlayKey(
+                'user1',
+                DocumentKey.fromPath('docs/foo')
+              );
+              return documentOverlayStore.get(key).next(overlay => {
+                expect(overlay).to.not.be.null;
+                expect(overlay!.overlayMutation).to.deep.equal(testWriteFoo);
+              });
+            });
+            p = p.next(() => {
+              const key = toDbDocumentOverlayKey(
+                'user1',
+                DocumentKey.fromPath('docs/pending')
+              );
+              return documentOverlayStore.get(key).next(overlay => {
+                expect(overlay).to.not.be.null;
+                expect(overlay!.overlayMutation).to.deep.equal(
+                  testWritePending
+                );
+              });
+            });
+            p = p.next(() => {
+              const key = toDbDocumentOverlayKey(
+                'user2',
+                DocumentKey.fromPath('docs/bar')
+              );
+              return documentOverlayStore.get(key).next(overlay => {
+                expect(overlay).to.not.be.null;
+                expect(overlay!.overlayMutation).to.deep.equal(testWriteBar);
+              });
+            });
+            p = p.next(() => {
+              const key = toDbDocumentOverlayKey(
+                'user2',
+                DocumentKey.fromPath('docs/baz')
+              );
+              return documentOverlayStore.get(key).next(overlay => {
+                expect(overlay).to.not.be.null;
+                expect(overlay!.overlayMutation).to.deep.equal(testWriteBaz);
+              });
+            });
+            p = p.next(() => {
+              const key = toDbDocumentOverlayKey(
+                'user2',
+                DocumentKey.fromPath('docs/pending')
+              );
+              return documentOverlayStore.get(key).next(overlay => {
+                expect(overlay).to.not.be.null;
+                expect(overlay!.overlayMutation).to.deep.equal(
+                  testWritePending
+                );
+              });
+            });
+            return p;
+          }
+        );
+      })
+    );
+  });
+
   it('can upgrade from version 13 to 14', async () => {
     await withDb(13, async () => {});
     await withDb(14, async (db, version, objectStores) => {
