test: replace guard-pattern test with NEVER-observable regression test

The guard-pattern test passed on main because SuspenseSubject's warmup
subscription made onAuthStateChanged fire before getSnapshot() was called.

The new test installs NEVER as the auth:user observable so it can never emit,
isolating the synchronous-user guarantee to the initialData seeding path only.
Fails on main (status:'loading'), passes with the fix (status:'success').

Author: tyler-reitz

test/auth.test.tsx

@@ -1,6 +1,8 @@
 import { cleanup, render, waitFor, renderHook, act } from '@testing-library/react';
 import '@testing-library/jest-dom/extend-expect';
 import * as React from 'react';
+import { NEVER } from 'rxjs';
+import { preloadObservable } from '../src/useObservable';
 import {
   FirebaseAppProvider,
   AuthCheck,
@@ -326,39 +328,37 @@ describe('Authentication', () => {
       expect(result.current.data).toEqual(getAuth(app).currentUser);
     });
 
-    it('synchronously returns a user when mounted as a child of a useSigninCheck guard', async () => {
+    it('synchronously returns the current user without waiting for the observable', async () => {
       await act(async () => {
         await signIn();
       });
 
-      // Capture the very first render of the child — before any re-renders
+      // Replace the auth:user observable with NEVER so it never emits.
+      // Without the fix (no initialData seeding), status is 'loading' on first render.
+      // With the fix (initialData = auth.currentUser), status is 'success' synchronously.
+      const cache = (globalThis as any)._reactFirePreloadedObservables as Map<string, any>;
+      const authUserKey = `auth:user:${getAuth(app).name}`;
+      cache?.delete(authUserKey);
+      preloadObservable(NEVER, authUserKey);
+
       let capturedFirstRender: { user: any; status: string } | undefined;
 
-      const UserChild = () => {
+      const UserComponent = () => {
         const { data: user, status } = useUser();
         if (capturedFirstRender === undefined) {
           capturedFirstRender = { user, status };
         }
-        return <span data-testid="child-user">{user?.email ?? 'no user'}</span>;
-      };
-
-      const Guard = () => {
-        const { data: signinResult, status } = useSigninCheck();
-        if (status !== 'success' || !signinResult?.signedIn) {
-          return <span data-testid="guard-loading">loading</span>;
-        }
-        return <UserChild />;
+        return <span data-testid="user-output">{String(status)}</span>;
       };
 
-      const { findByTestId } = render(<Guard />, { wrapper: Provider });
-
-      await findByTestId('child-user');
+      try {
+        render(<UserComponent />, { wrapper: Provider });
 
-      // On main (without the fix), useUser mounts with a fresh SuspenseSubject
-      // (different observableId from useSigninCheck) and returns status:'loading', data:undefined.
-      // With the fix, currentUser seeds initialData so the first render is already success.
-      expect(capturedFirstRender!.status).toBe('success');
-      expect(capturedFirstRender!.user).toEqual(getAuth(app).currentUser);
+        expect(capturedFirstRender!.status).toBe('success');
+        expect(capturedFirstRender!.user).toEqual(getAuth(app).currentUser);
+      } finally {
+        cache?.delete(authUserKey);
+      }
     });
 
     it('does not show a logged-out user after navigating away', async () => {