Ensure persistence started (#1043)

* Ensure persistence is started when passed to the local store

* [AUTOMATED]: Prettier Code Styling

* Review responses

Author: Greg Soltis

packages/firestore/src/local/indexeddb_persistence.ts

@@ -96,7 +96,7 @@ export class IndexedDbPersistence implements Persistence {
   static MAIN_DATABASE = 'main';
 
   private simpleDb: SimpleDb;
-  private started: boolean;
+  private _started = false;
   private dbName: string;
   private localStoragePrefix: string;
   private ownerId: string = this.generateOwnerId();
@@ -130,7 +130,6 @@ export class IndexedDbPersistence implements Persistence {
     }
 
     assert(!this.started, 'IndexedDbPersistence double-started!');
-    this.started = true;
 
     return SimpleDb.openOrCreate(this.dbName, SCHEMA_VERSION, createOrUpgradeDb)
       .then(db => {
@@ -140,12 +139,15 @@ export class IndexedDbPersistence implements Persistence {
       .then(() => {
         this.scheduleOwnerLeaseRefreshes();
         this.attachWindowUnloadHook();
+      })
+      .then(() => {
+        this._started = true;
       });
   }
 
   shutdown(deleteData?: boolean): Promise<void> {
     assert(this.started, 'IndexedDbPersistence shutdown without start!');
-    this.started = false;
+    this._started = false;
     this.detachWindowUnloadHook();
     this.stopOwnerLeaseRefreshes();
     return this.releaseOwnerLease().then(() => {
@@ -156,6 +158,10 @@ export class IndexedDbPersistence implements Persistence {
     });
   }
 
+  get started(): boolean {
+    return this._started;
+  }
+
   getMutationQueue(user: User): MutationQueue {
     return IndexedDbMutationQueue.forUser(user, this.serializer);
   }

packages/firestore/src/local/local_store.ts

@@ -163,6 +163,10 @@ export class LocalStore {
      */
     private garbageCollector: GarbageCollector
   ) {
+    assert(
+      persistence.started,
+      'LocalStore was passed an unstarted persistence implementation'
+    );
     this.mutationQueue = persistence.getMutationQueue(initialUser);
     this.remoteDocuments = persistence.getRemoteDocumentCache();
     this.queryCache = persistence.getQueryCache();

packages/firestore/src/local/memory_persistence.ts

@@ -45,18 +45,22 @@ export class MemoryPersistence implements Persistence {
   private remoteDocumentCache = new MemoryRemoteDocumentCache();
   private queryCache = new MemoryQueryCache();
 
-  private started = false;
+  private _started = false;
 
   async start(): Promise<void> {
     // No durable state to read on startup.
-    assert(!this.started, 'MemoryPersistence double-started!');
-    this.started = true;
+    assert(!this._started, 'MemoryPersistence double-started!');
+    this._started = true;
   }
 
   async shutdown(deleteData?: boolean): Promise<void> {
     // No durable state to ensure is closed on shutdown.
-    assert(this.started, 'MemoryPersistence shutdown without start!');
-    this.started = false;
+    assert(this._started, 'MemoryPersistence shutdown without start!');
+    this._started = false;
+  }
+
+  get started(): boolean {
+    return this._started;
   }
 
   getMutationQueue(user: User): MutationQueue {

packages/firestore/src/local/persistence.ts

@@ -68,6 +68,11 @@ export interface PersistenceTransaction {}
  * writes.
  */
 export interface Persistence {
+  /**
+   * Whether or not this persistence instance has been started.
+   */
+  readonly started: boolean;
+
   /**
    * Starts persistent storage, opening the database or similar.
    *

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

@@ -356,26 +356,31 @@ abstract class TestRunner {
     this.serializer = new JsonProtoSerializer(this.databaseInfo.databaseId, {
       useProto3Json: true
     });
-    this.persistence = this.getPersistence(this.serializer);
 
     this.useGarbageCollection = config.useGarbageCollection;
 
-    this.init();
+    this.queue = new AsyncQueue();
 
     this.expectedLimboDocs = [];
     this.expectedActiveTargets = {};
   }
 
-  private init(): void {
+  async start(): Promise<void> {
+    this.persistence = this.getPersistence(this.serializer);
+    await this.persistence.start();
+    await this.init();
+  }
+
+  async init(): Promise<void> {
     const garbageCollector = this.getGarbageCollector();
 
     this.localStore = new LocalStore(
       this.persistence,
       this.user,
       garbageCollector
     );
+    await this.localStore.start();
 
-    this.queue = new AsyncQueue();
     this.connection = new MockConnection(this.queue);
     this.datastore = new Datastore(
       this.queue,
@@ -393,6 +398,7 @@ abstract class TestRunner {
       this.queue,
       onlineStateChangedHandler
     );
+    await this.remoteStore.start();
 
     this.syncEngine = new SyncEngine(
       this.localStore,
@@ -417,13 +423,6 @@ abstract class TestRunner {
   ): Persistence;
   protected abstract destroyPersistence(): Promise<void>;
 
-  async start(): Promise<void> {
-    this.connection.reset();
-    await this.persistence.start();
-    await this.localStore.start();
-    await this.remoteStore.start();
-  }
-
   async shutdown(): Promise<void> {
     await this.remoteStore.shutdown();
     await this.persistence.shutdown(/* deleteData= */ true);
@@ -784,13 +783,10 @@ abstract class TestRunner {
     // No local store to shutdown.
     await this.remoteStore.shutdown();
 
-    this.init();
-
     // We have to schedule the starts, otherwise we could end up with
     // interleaved events.
     await this.queue.enqueue(async () => {
-      await this.localStore.start();
-      await this.remoteStore.start();
+      await this.init();
     });
   }