Adding getActiveClients()

packages/firestore/src/local/indexeddb_persistence.ts

@@ -308,6 +308,19 @@ export class IndexedDbPersistence implements Persistence {
     });
   }
 
+  getActiveClients(): Promise<ClientKey[]> {
+    const clientKeys: ClientKey[] = [];
+    return this.simpleDb
+      .runTransaction('readonly', [DbClientMetadata.store], txn => {
+        return clientMetadataStore(txn).iterate((key, value) => {
+          if (this.isWithinMaxAge(value.updateTimeMs)) {
+            clientKeys.push(value.clientKey);
+          }
+        });
+      })
+      .then(() => clientKeys);
+  }
+
   getMutationQueue(user: User): MutationQueue {
     return IndexedDbMutationQueue.forUser(user, this.serializer);
   }

packages/firestore/src/local/memory_persistence.ts

@@ -30,7 +30,9 @@ import {
 import { PersistencePromise } from './persistence_promise';
 import { QueryCache } from './query_cache';
 import { RemoteDocumentCache } from './remote_document_cache';
+import { ClientKey } from './shared_client_state';
 import { AsyncQueue } from '../util/async_queue';
+import { AutoId } from '../util/misc';
 
 const LOG_TAG = 'MemoryPersistence';
 
@@ -49,6 +51,7 @@ export class MemoryPersistence implements Persistence {
   private mutationQueues: { [user: string]: MutationQueue } = {};
   private remoteDocumentCache = new MemoryRemoteDocumentCache();
   private queryCache = new MemoryQueryCache();
+  private readonly clientId: ClientKey = AutoId.newId();
 
   private started = false;
 
@@ -66,6 +69,10 @@ export class MemoryPersistence implements Persistence {
     this.started = false;
   }
 
+  async getActiveClients(): Promise<ClientKey[]> {
+    return [this.clientId];
+  }
+
   setPrimaryStateListener(primaryStateListener: PrimaryStateListener) {
     // All clients using memory persistence act as primary.
     this.queue.enqueue(() => primaryStateListener(true));

packages/firestore/src/local/persistence.ts

@@ -21,6 +21,7 @@ import { PersistenceTransaction } from './persistence';
 import { PersistencePromise } from './persistence_promise';
 import { QueryCache } from './query_cache';
 import { RemoteDocumentCache } from './remote_document_cache';
+import { ClientKey } from './shared_client_state';
 
 /**
  * Opaque interface representing a persistence transaction.
@@ -94,9 +95,20 @@ export interface Persistence {
    * Registers a listener that gets called when the primary state of the
    * instance changes. Upon registering, this listener is invoked immediately
    * with the current primary state.
+   *
+   * PORTING NOTE: This is only used for Web multi-tab.
    */
   setPrimaryStateListener(primaryStateListener: PrimaryStateListener);
 
+  /**
+   * Returns the IDs of the clients that are currently active. If multi-tab
+   * is not supported, returns an array that only contains the local client's
+   * ID.
+   *
+   * PORTING NOTE: This is only used for Web multi-tab.
+   */
+  getActiveClients(): Promise<ClientKey[]>;
+
   /**
    * Returns a MutationQueue representing the persisted mutations for the
    * given user.

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

@@ -184,6 +184,20 @@ describeSpec('Persistence:', [], () => {
     );
   });
 
+  specTest('Detects all active clients', ['multi-client'], () => {
+    return (
+      client(0)
+        // While we don't verify the client's visibility in this test, the spec
+        // test framework requires an explicit action before setting an
+        // expectation.
+        .becomeHidden()
+        .expectNumActiveClients(1)
+        .client(1)
+        .becomeVisible()
+        .expectNumActiveClients(2)
+    );
+  });
+
   specTest('Single tab acquires primary lease', ['multi-client'], () => {
     // This test simulates primary state handoff between two background tabs.
     // With all instances in the background, the first active tab acquires

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

@@ -621,6 +621,14 @@ export class SpecBuilder {
     return this;
   }
 
+  expectNumActiveClients(num: number): SpecBuilder {
+    this.assertStep('Expectations require previous step');
+    const currentStep = this.currentStep!;
+    currentStep.stateExpect = currentStep.stateExpect || {};
+    currentStep.stateExpect.numActiveClients = num;
+    return this;
+  }
+
   expectPrimaryState(isPrimary: boolean): SpecBuilder {
     this.assertStep('Expectations requires previous step');
     const currentStep = this.currentStep!;
@@ -928,6 +936,11 @@ export class MultiClientSpecBuilder extends SpecBuilder {
     return this;
   }
 
+  expectNumActiveClients(num: number): MultiClientSpecBuilder {
+    super.expectNumActiveClients(num);
+    return this;
+  }
+
   expectPrimaryState(isPrimary: boolean): MultiClientSpecBuilder {
     super.expectPrimaryState(isPrimary);
     return this;

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

@@ -320,6 +320,8 @@ interface OutstandingWrite {
 abstract class TestRunner {
   protected queue: AsyncQueue;
 
+  private started = false;
+
   private connection: MockConnection;
   private eventManager: EventManager;
   private syncEngine: SyncEngine;
@@ -419,15 +421,19 @@ abstract class TestRunner {
     serializer: JsonProtoSerializer
   ): Persistence;
 
-  async start(): Promise<void> {
-    this.connection.reset();
-    await this.persistence.start();
-    await this.localStore.start();
-    await this.remoteStore.start();
+  async startIfNeeded(): Promise<void> {
+    if (!this.started) {
+      this.connection.reset();
+      await this.persistence.start();
+      await this.localStore.start();
+      await this.remoteStore.start();
 
-    this.persistence.setPrimaryStateListener(isPrimary =>
-      this.syncEngine.applyPrimaryState(isPrimary)
-    );
+      this.persistence.setPrimaryStateListener(isPrimary =>
+        this.syncEngine.applyPrimaryState(isPrimary)
+      );
+
+      this.started = true;
+    }
   }
 
   async shutdown(): Promise<void> {
@@ -440,7 +446,7 @@ abstract class TestRunner {
     await this.doStep(step);
     await this.queue.drain();
     this.validateStepExpectations(step.expect!);
-    this.validateStateExpectations(step.stateExpect!);
+    await this.validateStateExpectations(step.stateExpect!);
     this.eventList = [];
   }
 
@@ -847,13 +853,19 @@ abstract class TestRunner {
     }
   }
 
-  private validateStateExpectations(expectation: StateExpectation): void {
+  private async validateStateExpectations(
+    expectation: StateExpectation
+  ): Promise<void> {
     if (expectation) {
       if ('numOutstandingWrites' in expectation) {
         expect(this.remoteStore.outstandingWrites()).to.equal(
           expectation.numOutstandingWrites
         );
       }
+      if ('numActiveClients' in expectation) {
+        const activeClients = await this.persistence.getActiveClients();
+        expect(activeClients.length).to.equal(expectation.numActiveClients);
+      }
       if ('writeStreamRequestCount' in expectation) {
         expect(this.connection.writeStreamRequestCount).to.equal(
           expectation.writeStreamRequestCount
@@ -1154,15 +1166,16 @@ export async function runSpec(
     } else {
       runners.push(new MemoryTestRunner(name, platform, config));
     }
-    await runners[i].start();
   }
   let lastStep = null;
   let count = 0;
   try {
     await sequence(steps, async step => {
       ++count;
       lastStep = step;
-      return runners[step.clientIndex || 0].run(step);
+      const clientIndex = step.clientIndex || 0;
+      await runners[clientIndex].startIfNeeded();
+      return runners[clientIndex].run(step);
     });
   } catch (err) {
     console.warn(
@@ -1396,6 +1409,8 @@ export interface SpecExpectation {
 export interface StateExpectation {
   /** Number of outstanding writes in the datastore queue. */
   numOutstandingWrites?: number;
+  /** Number of clients currently marked active. Used in multi-client tests. */
+  numActiveClients?: number;
   /** Number of requests sent to the write stream. */
   writeStreamRequestCount?: number;
   /** Number of requests sent to the watch stream. */