MockIndexedDbPersistence

Author: schmidt-sebastian

packages/firestore/src/core/component_provider.ts

@@ -180,6 +180,8 @@ export class MemoryComponentProvider implements ComponentProvider {
  * Provides all components needed for Firestore with IndexedDB persistence.
  */
 export class IndexedDbComponentProvider extends MemoryComponentProvider {
+  persistence!: IndexedDbPersistence;
+
   // TODO(tree-shaking): Create an IndexedDbComponentProvider and a
   // MultiTabComponentProvider. The IndexedDbComponentProvider should depend
   // on LocalStore and SyncEngine.
@@ -189,11 +191,6 @@ export class IndexedDbComponentProvider extends MemoryComponentProvider {
   async initialize(cfg: ComponentConfiguration): Promise<void> {
     await super.initialize(cfg);
 
-    debugAssert(
-      this.persistence instanceof IndexedDbPersistence,
-      'IndexedDbComponentProvider should provide IndexedDBPersistence'
-    );
-
     // NOTE: This will immediately call the listener, so we make sure to
     // set it after localStore / remoteStore are started.
     await this.persistence.setPrimaryStateListener(async isPrimary => {
@@ -211,10 +208,6 @@ export class IndexedDbComponentProvider extends MemoryComponentProvider {
   }
 
   createLocalStore(cfg: ComponentConfiguration): LocalStore {
-    debugAssert(
-      this.persistence instanceof IndexedDbPersistence,
-      'IndexedDbComponentProvider should provide IndexedDBPersistence'
-    );
     return new MultiTabLocalStore(
       this.persistence,
       new IndexFreeQueryEngine(),
@@ -239,10 +232,6 @@ export class IndexedDbComponentProvider extends MemoryComponentProvider {
   createGarbageCollectionScheduler(
     cfg: ComponentConfiguration
   ): GarbageCollectionScheduler | null {
-    debugAssert(
-      this.persistence instanceof IndexedDbPersistence,
-      'IndexedDbComponentProvider should provide IndexedDBPersistence'
-    );
     const garbageCollector = this.persistence.referenceDelegate
       .garbageCollector;
     return new LruScheduler(garbageCollector, cfg.asyncQueue);
@@ -258,18 +247,16 @@ export class IndexedDbComponentProvider extends MemoryComponentProvider {
       cfg.databaseInfo
     );
     const serializer = cfg.platform.newSerializer(cfg.databaseInfo.databaseId);
-    return IndexedDbPersistence.createIndexedDbPersistence({
-      allowTabSynchronization: cfg.persistenceSettings.synchronizeTabs,
+    return new IndexedDbPersistence(
+      cfg.persistenceSettings.synchronizeTabs,
       persistenceKey,
-      clientId: cfg.clientId,
-      platform: cfg.platform,
-      queue: cfg.asyncQueue,
+      cfg.clientId,
+      cfg.platform,
+      LruParams.withCacheSize(cfg.persistenceSettings.cacheSizeBytes),
+      cfg.asyncQueue,
       serializer,
-      lruParams: LruParams.withCacheSize(
-        cfg.persistenceSettings.cacheSizeBytes
-      ),
-      sequenceNumberSyncer: this.sharedClientState
-    });
+      this.sharedClientState
+    );
   }
 
   createSharedClientState(cfg: ComponentConfiguration): SharedClientState {

packages/firestore/src/local/indexeddb_persistence.ts

@@ -188,36 +188,6 @@ export class IndexedDbPersistence implements Persistence {
    */
   static MAIN_DATABASE = 'main';
 
-  static createIndexedDbPersistence(options: {
-    allowTabSynchronization: boolean;
-    persistenceKey: string;
-    clientId: ClientId;
-    platform: Platform;
-    lruParams: LruParams;
-    queue: AsyncQueue;
-    serializer: JsonProtoSerializer;
-    sequenceNumberSyncer: SequenceNumberSyncer;
-  }): IndexedDbPersistence {
-    if (!IndexedDbPersistence.isAvailable()) {
-      throw new FirestoreError(
-        Code.UNIMPLEMENTED,
-        UNSUPPORTED_PLATFORM_ERROR_MSG
-      );
-    }
-
-    const persistence = new IndexedDbPersistence(
-      options.allowTabSynchronization,
-      options.persistenceKey,
-      options.clientId,
-      options.platform,
-      options.lruParams,
-      options.queue,
-      options.serializer,
-      options.sequenceNumberSyncer
-    );
-    return persistence;
-  }
-
   private readonly document: Document | null;
   private readonly window: Window;
 
@@ -256,7 +226,7 @@ export class IndexedDbPersistence implements Persistence {
   private readonly webStorage: Storage;
   readonly referenceDelegate: IndexedDbLruDelegate;
 
-  private constructor(
+  constructor(
     private readonly allowTabSynchronization: boolean,
     private readonly persistenceKey: string,
     private readonly clientId: ClientId,
@@ -266,6 +236,13 @@ export class IndexedDbPersistence implements Persistence {
     serializer: JsonProtoSerializer,
     private readonly sequenceNumberSyncer: SequenceNumberSyncer
   ) {
+    if (!IndexedDbPersistence.isAvailable()) {
+      throw new FirestoreError(
+        Code.UNIMPLEMENTED,
+        UNSUPPORTED_PLATFORM_ERROR_MSG
+      );
+    }
+
     this.referenceDelegate = new IndexedDbLruDelegate(this, lruParams);
     this.dbName = persistenceKey + IndexedDbPersistence.MAIN_DATABASE;
     this.serializer = new LocalSerializer(serializer);

packages/firestore/test/unit/local/indexeddb_persistence.test.ts

@@ -124,16 +124,16 @@ async function withCustomPersistence(
     PlatformSupport.getPlatform(),
     new SharedFakeWebStorage()
   );
-  const persistence = await IndexedDbPersistence.createIndexedDbPersistence({
-    allowTabSynchronization: multiClient,
-    persistenceKey: TEST_PERSISTENCE_PREFIX,
+  const persistence = new IndexedDbPersistence(
+    /* allowTabSynchronization= */ multiClient,
+    TEST_PERSISTENCE_PREFIX,
     clientId,
     platform,
+    LruParams.DEFAULT,
     queue,
     serializer,
-    lruParams: LruParams.DEFAULT,
-    sequenceNumberSyncer: MOCK_SEQUENCE_NUMBER_SYNCER
-  });
+    MOCK_SEQUENCE_NUMBER_SYNCER
+  );
 
   await persistence.start();
   await fn(persistence, platform, queue);

packages/firestore/test/unit/local/persistence_test_helpers.ts

@@ -113,16 +113,16 @@ export async function testIndexedDbPersistence(
     await SimpleDb.delete(prefix + IndexedDbPersistence.MAIN_DATABASE);
   }
   const platform = PlatformSupport.getPlatform();
-  const persistence = IndexedDbPersistence.createIndexedDbPersistence({
-    allowTabSynchronization: !!options.synchronizeTabs,
-    persistenceKey: TEST_PERSISTENCE_PREFIX,
+  const persistence = new IndexedDbPersistence(
+    !!options.synchronizeTabs,
+    TEST_PERSISTENCE_PREFIX,
     clientId,
     platform,
-    queue,
-    serializer: JSON_SERIALIZER,
     lruParams,
-    sequenceNumberSyncer: MOCK_SEQUENCE_NUMBER_SYNCER
-  });
+    queue,
+    JSON_SERIALIZER,
+    MOCK_SEQUENCE_NUMBER_SYNCER
+  );
   await persistence.start();
   return persistence;
 }

packages/firestore/test/unit/local/test_remote_document_cache.ts

@@ -134,7 +134,7 @@ export class TestRemoteDocumentCache {
       txn => {
         debugAssert(
           this.cache instanceof IndexedDbRemoteDocumentCache,
-          'getNewDocumentChanges is only supported by IndexedDB'
+          'getNewDocumentChanges() requires IndexedDB'
         );
         return this.cache.getNewDocumentChanges(txn, sinceReadTime);
       }

packages/firestore/test/unit/specs/spec_test_components.ts

@@ -24,16 +24,8 @@ import {
   GarbageCollectionScheduler,
   Persistence,
   PersistenceTransaction,
-  PersistenceTransactionMode,
-  PrimaryStateListener,
-  ReferenceDelegate
+  PersistenceTransactionMode
 } from '../../../src/local/persistence';
-import { ClientId } from '../../../src/local/shared_client_state';
-import { User } from '../../../src/auth/user';
-import { MutationQueue } from '../../../src/local/mutation_queue';
-import { TargetCache } from '../../../src/local/target_cache';
-import { RemoteDocumentCache } from '../../../src/local/remote_document_cache';
-import { IndexManager } from '../../../src/local/index_manager';
 import { IndexedDbPersistence } from '../../../src/local/indexeddb_persistence';
 import { PersistencePromise } from '../../../src/local/persistence_promise';
 import { debugAssert } from '../../../src/util/assert';
@@ -45,60 +37,33 @@ import {
 import { LruParams } from '../../../src/local/lru_garbage_collector';
 
 /**
- * A test-only persistence implementation that delegates all calls to the
- * underlying IndexedDB or Memory-based persistence implementations and is able
- * to inject transaction failures.
+ * A test-only MemoryPersistence implementation that is able to inject 
+ * transaction failures.
  */
-export class MockPersistence implements Persistence {
+export class MockMemoryPersistence extends MemoryPersistence {
   injectFailures = false;
 
-  constructor(private readonly delegate: Persistence) {}
-
-  start(): Promise<void> {
-    return this.delegate.start();
-  }
-
-  get started(): boolean {
-    return this.delegate.started;
-  }
-
-  get referenceDelegate(): ReferenceDelegate {
-    return this.delegate.referenceDelegate;
-  }
-
-  shutdown(): Promise<void> {
-    return this.delegate.shutdown();
-  }
-
-  setDatabaseDeletedListener(
-    databaseDeletedListener: () => Promise<void>
-  ): void {
-    this.delegate.setDatabaseDeletedListener(databaseDeletedListener);
-  }
-
-  getActiveClients(): Promise<ClientId[]> {
-    debugAssert(
-      this.delegate instanceof IndexedDbPersistence,
-      `getActiveClients() requires IndexedDbPersistence`
-    );
-    return this.delegate.getActiveClients();
-  }
-
-  getMutationQueue(user: User): MutationQueue {
-    return this.delegate.getMutationQueue(user);
-  }
-
-  getTargetCache(): TargetCache {
-    return this.delegate.getTargetCache();
-  }
-
-  getRemoteDocumentCache(): RemoteDocumentCache {
-    return this.delegate.getRemoteDocumentCache();
+  runTransaction<T>(
+    action: string,
+    mode: PersistenceTransactionMode,
+    transactionOperation: (
+      transaction: PersistenceTransaction
+    ) => PersistencePromise<T>
+  ): Promise<T> {
+    if (this.injectFailures) {
+      return Promise.reject(new Error('Injected Failure'));
+    } else {
+      return super.runTransaction(action, mode, transactionOperation);
+    }
   }
+}
 
-  getIndexManager(): IndexManager {
-    return this.delegate.getIndexManager();
-  }
+/**
+ * A test-only IndexedDbPersistence implementation that is able to inject
+ * transaction failures.
+ */
+export class MockIndexedDbPersistence extends IndexedDbPersistence {
+  injectFailures = false;
 
   runTransaction<T>(
     action: string,
@@ -110,27 +75,46 @@ export class MockPersistence implements Persistence {
     if (this.injectFailures) {
       return Promise.reject(new Error('Injected Failure'));
     } else {
-      return this.delegate.runTransaction(action, mode, transactionOperation);
+      return super.runTransaction(action, mode, transactionOperation);
     }
   }
 }
 
 export class MockIndexedDbComponentProvider extends IndexedDbComponentProvider {
-  persistence!: MockPersistence;
+  persistence!: MockIndexedDbPersistence;
 
   createGarbageCollectionScheduler(
     cfg: ComponentConfiguration
   ): GarbageCollectionScheduler | null {
     return null;
   }
 
-  createPersistence(cfg: ComponentConfiguration): Persistence {
-    return new MockPersistence(super.createPersistence(cfg));
+  createPersistence(cfg: ComponentConfiguration): MockIndexedDbPersistence {
+    debugAssert(
+      cfg.persistenceSettings.durable,
+      'Can only start durable persistence'
+    );
+
+    const persistenceKey = IndexedDbPersistence.buildStoragePrefix(
+      cfg.databaseInfo
+    );
+    const serializer = cfg.platform.newSerializer(cfg.databaseInfo.databaseId);
+
+    return new MockIndexedDbPersistence(
+      /* allowTabSynchronization= */ true,
+      persistenceKey,
+      cfg.clientId,
+      cfg.platform,
+      LruParams.withCacheSize(cfg.persistenceSettings.cacheSizeBytes),
+      cfg.asyncQueue,
+      serializer,
+      this.sharedClientState
+    );
   }
 }
 
 export class MockMemoryComponentProvider extends MemoryComponentProvider {
-  persistence!: MockPersistence;
+  persistence!: MockMemoryPersistence;
 
   constructor(private readonly gcEnabled: boolean) {
     super();
@@ -147,11 +131,10 @@ export class MockMemoryComponentProvider extends MemoryComponentProvider {
       !cfg.persistenceSettings.durable,
       'Can only start memory persistence'
     );
-    const persistence = new MemoryPersistence(
+    return new MockMemoryPersistence(
       this.gcEnabled
         ? MemoryEagerDelegate.factory
         : p => new MemoryLruDelegate(p, LruParams.DEFAULT)
     );
-    return new MockPersistence(persistence);
   }
 }

packages/firestore/test/unit/specs/spec_test_runner.ts

@@ -108,9 +108,11 @@ import { LruParams } from '../../../src/local/lru_garbage_collector';
 import { PersistenceSettings } from '../../../src/core/firestore_client';
 import {
   MockIndexedDbComponentProvider,
+  MockIndexedDbPersistence,
   MockMemoryComponentProvider,
-  MockPersistence
+  MockMemoryPersistence
 } from './spec_test_components';
+import { IndexedDbPersistence } from '../../../src/local/indexeddb_persistence';
 
 const ARBITRARY_SEQUENCE_NUMBER = 2;
 
@@ -415,7 +417,7 @@ abstract class TestRunner {
   private datastore!: Datastore;
   private localStore!: LocalStore;
   private remoteStore!: RemoteStore;
-  private persistence!: MockPersistence;
+  private persistence!: MockMemoryPersistence | MockIndexedDbPersistence;
   protected sharedClientState!: SharedClientState;
 
   private useGarbageCollection: boolean;
@@ -1004,6 +1006,10 @@ abstract class TestRunner {
         );
       }
       if ('numActiveClients' in expectedState) {
+        debugAssert(
+          this.persistence instanceof IndexedDbPersistence,
+          'numActiveClients() requires IndexedDbPersistence'
+        );
         const activeClients = await this.persistence.getActiveClients();
         expect(activeClients.length).to.equal(expectedState.numActiveClients);
       }