test(firestore): wait out the emulator's Listen-stream backoff

test/firestore.test.tsx flakes in CI at roughly 18% per run (11 of 60
iterations, 2026-08-11). The Firestore emulator intermittently corrupts a
Listen frame, so grpc-js reads four body bytes as a length prefix and reports
RESOURCE_EXHAUSTED with an absurd size. The SDK special-cases that code with
backoff.resetToMax(), parking the stream on a 60 second maximum backoff, then
self-heals.

This is an unresolved upstream emulator bug, firebase/firebase-tools#8654.
There is no fixed version to pin, so the goal is to survive it rather than
prevent it.

Only the tests that read a document which does not exist need a live server
round trip, so they are the only ones that can die; everything else is served
from the local cache. Those tests currently abandon the stream after one
second, so they fail while the SDK is still recovering. Raising both ceilings
lets them wait the backoff out. waitFor polls every 50ms, so a larger budget
costs nothing when the stream is healthy: measured at 80-114ms per test with
the change across five runs, against 79-105ms without it across three.

The budget is 120s rather than 60s because a third party hitting the same
upstream bug found a 60s ceiling insufficient at least once, and observed a
test self-heal at ~35s under a 120s ceiling.

Verified: a simulated 65 second stall survives the new budget while failing
under the default, and both typechecks are clean. Not verified, and it cannot
be locally: that this rescues a real occurrence. The desync has never
reproduced on a dev machine, so the evidence is CI once this lands, where
desyncs should keep appearing while the flake stops.

Refs #776

Author: tyler-reitz

test/firestore.test.tsx

@@ -30,6 +30,17 @@ describe('Firestore', () => {
     </FirebaseAppProvider>
   );
 
+  // The Firestore emulator intermittently corrupts a Listen frame
+  // (firebase/firebase-tools#8654, unresolved upstream). The SDK reads it as
+  // RESOURCE_EXHAUSTED and parks the stream on a 60s maximum backoff, then
+  // self-heals. Only the tests that read a document which does not exist need a
+  // live server round trip, so they are the only ones that can die; everything
+  // else is served from the local cache. Wait the backoff out instead of
+  // failing. `waitFor` polls, so this costs nothing when the stream is healthy.
+  // Remove when #8654 is fixed upstream. See #776.
+  const WAIT_OUT_BACKOFF = 120_000;
+  const BACKOFF_TEST_TIMEOUT = 150_000;
+
   afterEach(async () => {
     cleanup();
 
@@ -108,11 +119,11 @@ describe('Firestore', () => {
 
       const { result } = renderHook(() => useFirestoreDocData<any>(ref, { idField: 'id' }), { wrapper: Provider });
 
-      await waitFor(() => expect(result.current.status).toEqual('success'));
+      await waitFor(() => expect(result.current.status).toEqual('success'), { timeout: WAIT_OUT_BACKOFF });
 
       expect(result.current.status).toEqual('success');
       expect(result.current.data).toBeUndefined();
-    });
+    }, BACKOFF_TEST_TIMEOUT);
 
     it('goes back into a loading state if you swap the query', async () => {
       const mockData = { a: 'hello' };
@@ -177,17 +188,17 @@ describe('Firestore', () => {
       const { result: subscribeResult } = renderHook(() => useFirestoreDoc(ref), { wrapper: Provider });
       const { result: onceResult } = renderHook(() => useFirestoreDocOnce(ref), { wrapper: Provider });
 
-      await waitFor(() => expect(subscribeResult.current.status).toEqual('success'));
-      await waitFor(() => expect(onceResult.current.status).toEqual('success'));
+      await waitFor(() => expect(subscribeResult.current.status).toEqual('success'), { timeout: WAIT_OUT_BACKOFF });
+      await waitFor(() => expect(onceResult.current.status).toEqual('success'), { timeout: WAIT_OUT_BACKOFF });
 
       expect(onceResult.current.data.exists()).toEqual(false);
 
       await act(() => setDoc(ref, { a: 'test' }));
 
-      await waitFor(() => expect(subscribeResult.current.data.exists()).toEqual(true));
+      await waitFor(() => expect(subscribeResult.current.data.exists()).toEqual(true), { timeout: WAIT_OUT_BACKOFF });
 
       expect(onceResult.current.data.exists()).toEqual(false);
-    });
+    }, BACKOFF_TEST_TIMEOUT);
   });
 
   describe('useFirestoreDocDataOnce', () => {