yarn prettier

dconeybe · dconeybe · commit acff0f42a612 · 2023-03-09T20:55:55.000-05:00
diff --git a/packages/firestore/test/integration/api/query.test.ts b/packages/firestore/test/integration/api/query.test.ts
@@ -2064,136 +2064,134 @@ apiDescribe('Queries', (persistence: boolean) => {
     });
   });
 
-  it(
-    'resuming a query should use bloom filter to avoid full requery',
-    async () => {
-      // Create 100 documents in a new collection.
-      const testDocs: { [key: string]: object } = {};
-      for (let i = 1; i <= 100; i++) {
-        testDocs['doc' + i] = { key: i };
-      }
+  it('resuming a query should use bloom filter to avoid full requery', async () => {
+    // Create 100 documents in a new collection.
+    const testDocs: { [key: string]: object } = {};
+    for (let i = 1; i <= 100; i++) {
+      testDocs['doc' + i] = { key: i };
+    }
 
-      // The function that runs a single iteration of the test.
-      // Below this definition, there is a "while" loop that calls this
-      // function potentially multiple times.
-      const runTestIteration = async (
-        coll: CollectionReference,
-        db: Firestore
-      ): Promise<'retry' | 'passed'> => {
-        // Run a query to populate the local cache with the 100 documents
-        // and a resume token.
-        const snapshot1 = await getDocs(coll);
-        expect(snapshot1.size, 'snapshot1.size').to.equal(100);
+    // The function that runs a single iteration of the test.
+    // Below this definition, there is a "while" loop that calls this
+    // function potentially multiple times.
+    const runTestIteration = async (
+      coll: CollectionReference,
+      db: Firestore
+    ): Promise<'retry' | 'passed'> => {
+      // Run a query to populate the local cache with the 100 documents
+      // and a resume token.
+      const snapshot1 = await getDocs(coll);
+      expect(snapshot1.size, 'snapshot1.size').to.equal(100);
+
+      // Delete 50 of the 100 documents. Do this in a transaction, rather
+      // than deleteDoc(), to avoid affecting the local cache.
+      await runTransaction(db, async txn => {
+        for (let i = 1; i <= 50; i++) {
+          txn.delete(doc(coll, 'doc' + i));
+        }
+      });
 
-        // Delete 50 of the 100 documents. Do this in a transaction, rather
-        // than deleteDoc(), to avoid affecting the local cache.
-        await runTransaction(db, async txn => {
-          for (let i = 1; i <= 50; i++) {
-            txn.delete(doc(coll, 'doc' + i));
+      // Wait for 10 seconds, during which Watch will stop tracking the
+      // query and will send an existence filter rather than "delete"
+      // events when the query is resumed.
+      await new Promise(resolve => setTimeout(resolve, 10000));
+
+      // Resume the query and expect to get a snapshot with the 50
+      // remaining documents. Use some internal testing hooks to "capture"
+      // the existence filter mismatches to later verify that Watch sent a
+      // bloom filter, and it was used to avert a full requery.
+      const existenceFilterMismatches = await captureExistenceFilterMismatches(
+        async () => {
+          const snapshot2 = await getDocs(coll);
+          // TODO(b/270731363): Remove the "if" condition below once the
+          // Firestore Emulator is fixed to send an existence filter. At the
+          // time of writing, the Firestore emulator fails to send an
+          // existence filter, resulting in the client including the deleted
+          // documents in the snapshot of the resumed query.
+          if (!(USE_EMULATOR && snapshot2.size === 100)) {
+            expect(snapshot2.size, 'snapshot2.size').to.equal(50);
           }
-        });
-
-        // Wait for 10 seconds, during which Watch will stop tracking the
-        // query and will send an existence filter rather than "delete"
-        // events when the query is resumed.
-        await new Promise(resolve => setTimeout(resolve, 10000));
-
-        // Resume the query and expect to get a snapshot with the 50
-        // remaining documents. Use some internal testing hooks to "capture"
-        // the existence filter mismatches to later verify that Watch sent a
-        // bloom filter, and it was used to avert a full requery.
-        const existenceFilterMismatches =
-          await captureExistenceFilterMismatches(async () => {
-            const snapshot2 = await getDocs(coll);
-            // TODO(b/270731363): Remove the "if" condition below once the
-            // Firestore Emulator is fixed to send an existence filter. At the
-            // time of writing, the Firestore emulator fails to send an
-            // existence filter, resulting in the client including the deleted
-            // documents in the snapshot of the resumed query.
-            if (!(USE_EMULATOR && snapshot2.size === 100)) {
-              expect(snapshot2.size, 'snapshot2.size').to.equal(50);
-            }
-          });
-
-        // Skip the verification of the existence filter mismatch when
-        // persistence is disabled because without persistence there is no
-        // resume token specified in the subsequent call to getDocs(), and,
-        // therefore, Watch will _not_ send an existence filter.
-        if (!persistence) {
-          return 'passed';
         }
+      );
 
-        // Skip the verification of the existence filter mismatch when
-        // testing against the Firestore emulator because the Firestore
-        // emulator does not include the `unchanged_names` bloom filter when
-        // it sends ExistenceFilter messages. Some day the emulator _may_
-        // implement this logic, at which time this short-circuit can be
-        // removed.
-        if (USE_EMULATOR) {
-          return 'passed';
-        }
+      // Skip the verification of the existence filter mismatch when
+      // persistence is disabled because without persistence there is no
+      // resume token specified in the subsequent call to getDocs(), and,
+      // therefore, Watch will _not_ send an existence filter.
+      if (!persistence) {
+        return 'passed';
+      }
 
-        // Verify that upon resuming the query that Watch sent an existence
-        // filter that included a bloom filter, and that the bloom filter
-        // was successfully used to avoid a full requery.
-        // TODO(b/271949433) Remove this check for "nightly" once the bloom
-        // filter logic is deployed to production, circa May 2023.
-        if (TARGET_BACKEND === 'nightly') {
-          expect(
-            existenceFilterMismatches,
-            'existenceFilterMismatches'
-          ).to.have.length(1);
-          const { localCacheCount, existenceFilterCount, bloomFilter } =
-            existenceFilterMismatches[0];
-
-          expect(localCacheCount, 'localCacheCount').to.equal(100);
-          expect(existenceFilterCount, 'existenceFilterCount').to.equal(50);
-          if (!bloomFilter) {
-            expect.fail(
-              'The existence filter should have specified ' +
-                'a bloom filter in its `unchanged_names` field.'
-            );
-            throw new Error('should never get here');
-          }
+      // Skip the verification of the existence filter mismatch when
+      // testing against the Firestore emulator because the Firestore
+      // emulator does not include the `unchanged_names` bloom filter when
+      // it sends ExistenceFilter messages. Some day the emulator _may_
+      // implement this logic, at which time this short-circuit can be
+      // removed.
+      if (USE_EMULATOR) {
+        return 'passed';
+      }
 
-          expect(bloomFilter.hashCount, 'bloomFilter.hashCount').to.be.above(0);
-          expect(
-            bloomFilter.bitmapLength,
-            'bloomFilter.bitmapLength'
-          ).to.be.above(0);
-          expect(bloomFilter.padding, 'bloomFilterPadding').to.be.above(0);
-          expect(bloomFilter.padding, 'bloomFilterPadding').to.be.below(8);
-
-          // Retry the entire test if a bloom filter false positive occurs.
-          // Although statistically rare, false positives are expected to
-          // happen occasionally. When a false positive _does_ happen, just
-          // retry the test with a different set of documents. If that retry
-          // _also_ experiences a false positive, then fail the test because
-          // that is so improbable that something must have gone wrong.
-          if (attemptNumber > 1 && !bloomFilter.applied) {
-            return 'retry';
-          }
-          expect(bloomFilter.applied, 'bloomFilter.applied').to.be.true;
+      // Verify that upon resuming the query that Watch sent an existence
+      // filter that included a bloom filter, and that the bloom filter
+      // was successfully used to avoid a full requery.
+      // TODO(b/271949433) Remove this check for "nightly" once the bloom
+      // filter logic is deployed to production, circa May 2023.
+      if (TARGET_BACKEND === 'nightly') {
+        expect(
+          existenceFilterMismatches,
+          'existenceFilterMismatches'
+        ).to.have.length(1);
+        const { localCacheCount, existenceFilterCount, bloomFilter } =
+          existenceFilterMismatches[0];
+
+        expect(localCacheCount, 'localCacheCount').to.equal(100);
+        expect(existenceFilterCount, 'existenceFilterCount').to.equal(50);
+        if (!bloomFilter) {
+          expect.fail(
+            'The existence filter should have specified ' +
+              'a bloom filter in its `unchanged_names` field.'
+          );
+          throw new Error('should never get here');
         }
 
-        return 'passed';
-      };
-
-      // Run the test
-      let attemptNumber = 0;
-      while (true) {
-        attemptNumber++;
-        const iterationResult = await withTestCollection(
-          persistence,
-          testDocs,
-          runTestIteration
-        );
-        if (iterationResult === 'passed') {
-          break;
+        expect(bloomFilter.hashCount, 'bloomFilter.hashCount').to.be.above(0);
+        expect(
+          bloomFilter.bitmapLength,
+          'bloomFilter.bitmapLength'
+        ).to.be.above(0);
+        expect(bloomFilter.padding, 'bloomFilterPadding').to.be.above(0);
+        expect(bloomFilter.padding, 'bloomFilterPadding').to.be.below(8);
+
+        // Retry the entire test if a bloom filter false positive occurs.
+        // Although statistically rare, false positives are expected to
+        // happen occasionally. When a false positive _does_ happen, just
+        // retry the test with a different set of documents. If that retry
+        // _also_ experiences a false positive, then fail the test because
+        // that is so improbable that something must have gone wrong.
+        if (attemptNumber > 1 && !bloomFilter.applied) {
+          return 'retry';
         }
+        expect(bloomFilter.applied, 'bloomFilter.applied').to.be.true;
+      }
+
+      return 'passed';
+    };
+
+    // Run the test
+    let attemptNumber = 0;
+    while (true) {
+      attemptNumber++;
+      const iterationResult = await withTestCollection(
+        persistence,
+        testDocs,
+        runTestIteration
+      );
+      if (iterationResult === 'passed') {
+        break;
       }
     }
-  ).timeout('90s');
+  }).timeout('90s');
 });
 
 function verifyDocumentChange<T>(
