try hand-creating the ExistenceFilterMismatchInfo to see if it survives minification

Author: dconeybe

packages/firestore/src/api.ts

@@ -197,4 +197,3 @@ export { logWarn as _logWarn } from './util/log';
 export { EmptyAuthCredentialsProvider as _EmptyAuthCredentialsProvider } from './api/credentials';
 export { EmptyAppCheckTokenProvider as _EmptyAppCheckTokenProvider } from './api/credentials';
 export { TestingHooks as _TestingHooks } from './util/testing_hooks';
-export { ExistenceFilterMismatchCallback as _TestingHooksExistenceFilterMismatchCallback } from './util/testing_hooks';

packages/firestore/src/remote/watch_change.ts

@@ -37,7 +37,10 @@ import { logDebug, logWarn } from '../util/log';
 import { primitiveComparator } from '../util/misc';
 import { SortedMap } from '../util/sorted_map';
 import { SortedSet } from '../util/sorted_set';
-import { TestingHooks } from '../util/testing_hooks';
+import {
+  ExistenceFilterMismatchInfo,
+  TestingHooks
+} from '../util/testing_hooks';
 
 import { BloomFilter, BloomFilterError } from './bloom_filter';
 import { ExistenceFilter } from './existence_filter';
@@ -801,19 +804,22 @@ function notifyTestingHooksOnExistenceFilterMismatch(
   actualCount: number,
   existenceFilter: ExistenceFilter
 ): void {
-  const expectedCount = existenceFilter.count;
+  const existenceFilterMismatchInfo: ExistenceFilterMismatchInfo = {
+    actualCount,
+    expectedCount: existenceFilter.count
+  };
+
   const unchangedNames = existenceFilter.unchangedNames;
-  const bloomFilterSentFromWatch = !!unchangedNames;
-  const bloomFilterHashCount = unchangedNames?.hashCount ?? 0;
-  const bloomFilterBitmapLength = unchangedNames?.bits?.bitmap?.length ?? 0;
-  const bloomFilterPadding = unchangedNames?.bits?.padding ?? 0;
+  if (unchangedNames) {
+    existenceFilterMismatchInfo.bloomFilter = {
+      applied: bloomFilterApplied,
+      hashCount: unchangedNames?.hashCount ?? 0,
+      bitmapLength: unchangedNames?.bits?.bitmap?.length ?? 0,
+      padding: unchangedNames?.bits?.padding ?? 0
+    };
+  }
+
   TestingHooks.instance?.notifyOnExistenceFilterMismatch(
-    actualCount,
-    expectedCount,
-    bloomFilterSentFromWatch,
-    bloomFilterApplied,
-    bloomFilterHashCount,
-    bloomFilterBitmapLength,
-    bloomFilterPadding
+    existenceFilterMismatchInfo
   );
 }

packages/firestore/src/util/testing_hooks.ts

@@ -65,9 +65,7 @@ export class TestingHooks {
    * The relative order in which callbacks are notified is unspecified; do not
    * rely on any particular ordering.
    *
-   * @param callback the callback to invoke upon existence filter mismatch; see
-   * the documentation for `notifyOnExistenceFilterMismatch()` for the meaning
-   * of these arguments.
+   * @param callback the callback to invoke upon existence filter mismatch.
    *
    * @return a function that, when called, unregisters the given callback; only
    * the first invocation of the returned function does anything; all subsequent
@@ -83,64 +81,57 @@ export class TestingHooks {
 
   /**
    * Invokes all currently-registered `onExistenceFilterMismatch` callbacks.
-   * @param bloomFilterApplied true if a full requery was averted because the
-   * limbo documents were successfully deduced using the bloom filter, or false
-   * if a full requery had to be performed, such as due to a false positive in
-   * the bloom filter.
-   * @param actualCount the number of documents that matched the query in the
-   * local cache.
-   * @param expectedCount the number of documents that matched the query on the
-   * server, as specified in the ExistenceFilter message's `count` field.
-   * @param bloomFilterSentFromWatch whether the ExistenceFilter message
-   * included the `unchangedNames` bloom filter. If false, the remaining
-   * arguments are not applicable and may have any values.
-   * @param bloomFilterApplied whether a full requery was averted by using the
-   * bloom filter; if false, then a false positive occurred, requiring a full
-   * requery to deduce which documents should go into limbo.
-   * @param bloomFilterHashCount the number of hash functions used in the bloom
-   * filter.
-   * @param bloomFilterBitmapLength the number of bytes used by the bloom
-   * filter.
-   * @param bloomFilterPadding the number of bits of padding in the last byte
-   * of the bloom filter.
+   * @param info Information about the existence filter mismatch.
    */
-  notifyOnExistenceFilterMismatch(
-    actualCount: number,
-    expectedCount: number,
-    bloomFilterSentFromWatch: boolean,
-    bloomFilterApplied: boolean,
-    bloomFilterHashCount: number,
-    bloomFilterBitmapLength: number,
-    bloomFilterPadding: number
-  ): void {
-    this.onExistenceFilterMismatchCallbacks.forEach(callback => {
-      callback(
-        actualCount,
-        expectedCount,
-        bloomFilterSentFromWatch,
-        bloomFilterApplied,
-        bloomFilterHashCount,
-        bloomFilterBitmapLength,
-        bloomFilterPadding
-      );
-    });
+  notifyOnExistenceFilterMismatch(info: ExistenceFilterMismatchInfo): void {
+    this.onExistenceFilterMismatchCallbacks.forEach(callback => callback(info));
   }
 }
 
 /**
  * The signature of callbacks registered with
  * `TestingUtils.onExistenceFilterMismatch()`.
- *
- * @internal
+ */
+export interface ExistenceFilterMismatchInfo {
+  /** The number of documents that matched the query in the local cache. */
+  actualCount: number;
+
+  /**
+   * The number of documents that matched the query on the server, as specified
+   * in the ExistenceFilter message's `count` field.
+   */
+  expectedCount: number;
+
+  /**
+   * Information about the bloom filter provided by Watch in the ExistenceFilter
+   * message's `unchangedNames` field. If this property is omitted or undefined
+   * then that means that Watch did _not_ provide a bloom filter.
+   */
+  bloomFilter?: {
+    /**
+     * Whether a full requery was averted by using the bloom filter. If false,
+     * then something happened, such as a false positive, to prevent using the
+     * bloom filter to avoid a full requery.
+     */
+    applied: boolean;
+
+    /** The number of hash functions used in the bloom filter. */
+    hashCount: number;
+
+    /** The number of bytes in the bloom filter's bitmask. */
+    bitmapLength: number;
+
+    /** The number of bits of padding in the last byte of the bloom filter. */
+    padding: number;
+  };
+}
+
+/**
+ * The signature of callbacks registered with
+ * `TestingUtils.onExistenceFilterMismatch()`.
  */
 export type ExistenceFilterMismatchCallback = (
-  actualCount: number,
-  expectedCount: number,
-  bloomFilterSentFromWatch: boolean,
-  bloomFilterApplied: boolean,
-  bloomFilterHashCount: number,
-  bloomFilterBitmapLength: number,
-  bloomFilterPadding: number
+  info: ExistenceFilterMismatchInfo
 ) => void;
 
 /** The global singleton instance of `TestingHooks`. */

packages/firestore/test/integration/api/query.test.ts

@@ -2122,41 +2122,40 @@ apiDescribe('Queries', (persistence: boolean) => {
                 existenceFilterMismatches,
                 'existenceFilterMismatches'
               ).to.have.length(1);
-              const {
-                actualCount,
-                expectedCount,
-                bloomFilterSentFromWatch,
-                bloomFilterApplied,
-                bloomFilterHashCount,
-                bloomFilterBitmapLength,
-                bloomFilterPadding
-              } = existenceFilterMismatches[0];
+              const { actualCount, expectedCount, bloomFilter } =
+                existenceFilterMismatches[0];
 
               expect(actualCount, 'actualCount').to.equal(100);
               expect(expectedCount, 'expectedCount').to.equal(50);
-              expect(bloomFilterSentFromWatch, 'bloomFilterSentFromWatch').to.be
-                .true;
+              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');
+              }
+
+              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 && !bloomFilterApplied) {
+              if (attemptNumber > 1 && !bloomFilter.applied) {
                 return 'retry';
               }
-
-              expect(bloomFilterApplied, 'bloomFilterApplied').to.be.true;
-              expect(bloomFilterHashCount, 'bloomFilterHashCount').to.be.above(
-                0
-              );
-              expect(
-                bloomFilterBitmapLength,
-                'bloomFilterBitmapLength'
-              ).to.be.above(0);
-              expect(bloomFilterPadding, 'bloomFilterPadding').to.be.above(0);
-              expect(bloomFilterPadding, 'bloomFilterPadding').to.be.below(8);
+              expect(bloomFilter.applied, 'bloomFilter.applied').to.be.true;
             }
 
             return 'passed';

packages/firestore/test/integration/util/testing_hooks_util.ts

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-import { _TestingHooks as TestingHooks } from './firebase_export';
+import { _TestingHooks as TestingHooks, _logWarn } from './firebase_export';
 
 /**
  * Captures all existence filter mismatches in the Watch 'Listen' stream that
@@ -29,23 +29,11 @@ export async function captureExistenceFilterMismatches(
 ): Promise<ExistenceFilterMismatchInfo[]> {
   const results: ExistenceFilterMismatchInfo[] = [];
   const onExistenceFilterMismatchCallback = (
-    actualCount: number,
-    expectedCount: number,
-    bloomFilterSentFromWatch: boolean,
-    bloomFilterApplied: boolean,
-    bloomFilterHashCount: number,
-    bloomFilterBitmapLength: number,
-    bloomFilterPadding: number
-  ) =>
-    results.push({
-      actualCount,
-      expectedCount,
-      bloomFilterSentFromWatch,
-      bloomFilterApplied,
-      bloomFilterHashCount,
-      bloomFilterBitmapLength,
-      bloomFilterPadding
-    });
+    info: ExistenceFilterMismatchInfo
+  ) => {
+    _logWarn('zzyzx onExistenceFilterMismatchCallback', info);
+    results.push(info);
+  };
 
   const unregister =
     TestingHooks.getOrCreateInstance().onExistenceFilterMismatch(
@@ -71,9 +59,10 @@ export async function captureExistenceFilterMismatches(
 export interface ExistenceFilterMismatchInfo {
   actualCount: number;
   expectedCount: number;
-  bloomFilterSentFromWatch: boolean;
-  bloomFilterApplied: boolean;
-  bloomFilterHashCount: number;
-  bloomFilterBitmapLength: number;
-  bloomFilterPadding: number;
+  bloomFilter?: {
+    applied: boolean;
+    hashCount: number;
+    bitmapLength: number;
+    padding: number;
+  };
 }