test: Add comprehensive unit tests for Firebase UI authentication methods

Author: exaby73

packages/firebaseui-core/package.json

@@ -42,6 +42,8 @@
     "zod": "^3.24.1"
   },
   "devDependencies": {
+    "@types/jsdom": "^21.1.7",
+    "jsdom": "^26.0.0",
     "prettier": "^3.1.1",
     "rimraf": "^6.0.1",
     "tsup": "^8.0.1",

packages/firebaseui-core/src/auth.test.ts

@@ -0,0 +1,291 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+  Auth,
+  EmailAuthProvider,
+  PhoneAuthProvider,
+  createUserWithEmailAndPassword,
+  getAuth,
+  isSignInWithEmailLink,
+  linkWithCredential,
+  linkWithRedirect,
+  sendPasswordResetEmail,
+  sendSignInLinkToEmail,
+  signInAnonymously,
+  signInWithCredential,
+  signInWithPhoneNumber,
+  signInWithRedirect,
+} from 'firebase/auth';
+import {
+  fuiSignInWithEmailAndPassword,
+  fuiCreateUserWithEmailAndPassword,
+  fuiSignInWithPhoneNumber,
+  fuiConfirmPhoneNumber,
+  fuiSendPasswordResetEmail,
+  fuiSendSignInLinkToEmail,
+  fuiSignInWithEmailLink,
+  fuiSignInAnonymously,
+  fuiSignInWithOAuth,
+  fuiCompleteEmailLinkSignIn,
+} from './auth';
+import { FirebaseUIError } from './errors';
+
+// Mock all Firebase Auth functions
+vi.mock('firebase/auth', async () => {
+  const actual = await vi.importActual('firebase/auth');
+  return {
+    ...(actual as object),
+    getAuth: vi.fn(),
+    signInWithCredential: vi.fn(),
+    createUserWithEmailAndPassword: vi.fn(),
+    signInWithPhoneNumber: vi.fn(),
+    sendPasswordResetEmail: vi.fn(),
+    sendSignInLinkToEmail: vi.fn(),
+    isSignInWithEmailLink: vi.fn(),
+    signInAnonymously: vi.fn(),
+    linkWithCredential: vi.fn(),
+    linkWithRedirect: vi.fn(),
+    signInWithRedirect: vi.fn(),
+    EmailAuthProvider: {
+      credential: vi.fn(),
+      credentialWithLink: vi.fn(),
+    },
+    PhoneAuthProvider: {
+      credential: vi.fn(),
+    },
+  };
+});
+
+describe('Firebase UI Auth', () => {
+  let mockAuth: Auth;
+
+  const mockCredential = { type: 'password', token: 'mock-token' };
+  const mockUserCredential = { user: { uid: 'mock-uid' } };
+  const mockConfirmationResult = { verificationId: 'mock-verification-id' };
+  const mockError = { name: 'FirebaseError', code: 'auth/user-not-found' };
+  const mockProvider = { providerId: 'google.com' };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Create a fresh mock auth instance for each test
+    mockAuth = { currentUser: null } as Auth;
+    // Reset localStorage
+    window.localStorage.clear();
+    // Mock EmailAuthProvider
+    (EmailAuthProvider.credential as any).mockReturnValue(mockCredential);
+    (EmailAuthProvider.credentialWithLink as any).mockReturnValue(mockCredential);
+    // Mock PhoneAuthProvider
+    (PhoneAuthProvider.credential as any).mockReturnValue(mockCredential);
+  });
+
+  describe('fuiSignInWithEmailAndPassword', () => {
+    it('should sign in with email and password', async () => {
+      (signInWithCredential as any).mockResolvedValue(mockUserCredential);
+
+      const result = await fuiSignInWithEmailAndPassword(mockAuth, '[email protected]', 'password');
+
+      expect(EmailAuthProvider.credential).toHaveBeenCalledWith('[email protected]', 'password');
+      expect(signInWithCredential).toHaveBeenCalledWith(mockAuth, mockCredential);
+      expect(result).toBe(mockUserCredential);
+    });
+
+    it('should upgrade anonymous user when enabled', async () => {
+      mockAuth = { currentUser: { isAnonymous: true } } as Auth;
+      (linkWithCredential as any).mockResolvedValue(mockUserCredential);
+
+      const result = await fuiSignInWithEmailAndPassword(mockAuth, '[email protected]', 'password', {
+        enableAutoUpgradeAnonymous: true,
+      });
+
+      expect(linkWithCredential).toHaveBeenCalledWith(mockAuth.currentUser, mockCredential);
+      expect(result).toBe(mockUserCredential);
+    });
+
+    it('should throw FirebaseUIError on error', async () => {
+      (signInWithCredential as any).mockRejectedValue(mockError);
+
+      await expect(fuiSignInWithEmailAndPassword(mockAuth, '[email protected]', 'password')).rejects.toBeInstanceOf(
+        FirebaseUIError
+      );
+    });
+  });
+
+  describe('fuiCreateUserWithEmailAndPassword', () => {
+    it('should create user with email and password', async () => {
+      (createUserWithEmailAndPassword as any).mockResolvedValue(mockUserCredential);
+
+      const result = await fuiCreateUserWithEmailAndPassword(mockAuth, '[email protected]', 'password');
+
+      expect(createUserWithEmailAndPassword).toHaveBeenCalledWith(mockAuth, '[email protected]', 'password');
+      expect(result).toBe(mockUserCredential);
+    });
+
+    it('should upgrade anonymous user when enabled', async () => {
+      mockAuth = { currentUser: { isAnonymous: true } } as Auth;
+      (linkWithCredential as any).mockResolvedValue(mockUserCredential);
+
+      const result = await fuiCreateUserWithEmailAndPassword(mockAuth, '[email protected]', 'password', {
+        enableAutoUpgradeAnonymous: true,
+      });
+
+      expect(linkWithCredential).toHaveBeenCalledWith(mockAuth.currentUser, mockCredential);
+      expect(result).toBe(mockUserCredential);
+    });
+  });
+
+  describe('fuiSignInWithPhoneNumber', () => {
+    it('should initiate phone number sign in', async () => {
+      (signInWithPhoneNumber as any).mockResolvedValue(mockConfirmationResult);
+      const mockRecaptcha = { type: 'recaptcha' };
+
+      const result = await fuiSignInWithPhoneNumber(mockAuth, '+1234567890', mockRecaptcha as any);
+
+      expect(signInWithPhoneNumber).toHaveBeenCalledWith(mockAuth, '+1234567890', mockRecaptcha);
+      expect(result).toBe(mockConfirmationResult);
+    });
+  });
+
+  describe('fuiConfirmPhoneNumber', () => {
+    it('should confirm phone number sign in', async () => {
+      (getAuth as any).mockReturnValue(mockAuth);
+      (signInWithCredential as any).mockResolvedValue(mockUserCredential);
+
+      const result = await fuiConfirmPhoneNumber({ verificationId: 'mock-id' } as any, '123456');
+
+      expect(PhoneAuthProvider.credential).toHaveBeenCalledWith('mock-id', '123456');
+      expect(signInWithCredential).toHaveBeenCalledWith(mockAuth, mockCredential);
+      expect(result).toBe(mockUserCredential);
+    });
+
+    it('should upgrade anonymous user when enabled', async () => {
+      const mockAuthWithAnonymousUser = { currentUser: { isAnonymous: true } } as Auth;
+      (getAuth as any).mockReturnValue(mockAuthWithAnonymousUser);
+      (linkWithCredential as any).mockResolvedValue(mockUserCredential);
+
+      const result = await fuiConfirmPhoneNumber({ verificationId: 'mock-id' } as any, '123456', {
+        enableAutoUpgradeAnonymous: true,
+      });
+
+      expect(linkWithCredential).toHaveBeenCalled();
+      expect(result).toBe(mockUserCredential);
+    });
+  });
+
+  describe('fuiSendPasswordResetEmail', () => {
+    it('should send password reset email', async () => {
+      (sendPasswordResetEmail as any).mockResolvedValue(undefined);
+
+      await fuiSendPasswordResetEmail(mockAuth, '[email protected]');
+
+      expect(sendPasswordResetEmail).toHaveBeenCalledWith(mockAuth, '[email protected]');
+    });
+  });
+
+  describe('fuiSendSignInLinkToEmail', () => {
+    it('should send sign in link to email', async () => {
+      (sendSignInLinkToEmail as any).mockResolvedValue(undefined);
+      const expectedActionCodeSettings = {
+        url: window.location.href,
+        handleCodeInApp: true,
+      };
+
+      await fuiSendSignInLinkToEmail(mockAuth, '[email protected]');
+
+      expect(sendSignInLinkToEmail).toHaveBeenCalledWith(mockAuth, '[email protected]', expectedActionCodeSettings);
+      expect(window.localStorage.getItem('emailForSignIn')).toBe('[email protected]');
+    });
+
+    it('should handle anonymous upgrade flag', async () => {
+      mockAuth = { currentUser: { isAnonymous: true } } as Auth;
+      (sendSignInLinkToEmail as any).mockResolvedValue(undefined);
+
+      await fuiSendSignInLinkToEmail(mockAuth, '[email protected]', { enableAutoUpgradeAnonymous: true });
+
+      expect(window.localStorage.getItem('emailLinkAnonymousUpgrade')).toBe('true');
+    });
+  });
+
+  describe('fuiSignInWithEmailLink', () => {
+    it('should sign in with email link', async () => {
+      (signInWithCredential as any).mockResolvedValue(mockUserCredential);
+
+      const result = await fuiSignInWithEmailLink(mockAuth, '[email protected]', 'mock-link');
+
+      expect(EmailAuthProvider.credentialWithLink).toHaveBeenCalledWith('[email protected]', 'mock-link');
+      expect(signInWithCredential).toHaveBeenCalledWith(mockAuth, mockCredential);
+      expect(result).toBe(mockUserCredential);
+    });
+
+    it('should upgrade anonymous user when enabled', async () => {
+      mockAuth = { currentUser: { isAnonymous: true } } as Auth;
+      window.localStorage.setItem('emailLinkAnonymousUpgrade', 'true');
+      (linkWithCredential as any).mockResolvedValue(mockUserCredential);
+
+      const result = await fuiSignInWithEmailLink(mockAuth, '[email protected]', 'mock-link', {
+        enableAutoUpgradeAnonymous: true,
+      });
+
+      expect(linkWithCredential).toHaveBeenCalled();
+      expect(result).toBe(mockUserCredential);
+      expect(window.localStorage.getItem('emailLinkAnonymousUpgrade')).toBeNull();
+    });
+  });
+
+  describe('fuiSignInAnonymously', () => {
+    it('should sign in anonymously', async () => {
+      (signInAnonymously as any).mockResolvedValue(mockUserCredential);
+
+      const result = await fuiSignInAnonymously(mockAuth);
+
+      expect(signInAnonymously).toHaveBeenCalledWith(mockAuth);
+      expect(result).toBe(mockUserCredential);
+    });
+  });
+
+  describe('fuiSignInWithOAuth', () => {
+    it('should sign in with OAuth provider', async () => {
+      (signInWithRedirect as any).mockResolvedValue(undefined);
+
+      await fuiSignInWithOAuth(mockAuth, mockProvider as any);
+
+      expect(signInWithRedirect).toHaveBeenCalledWith(mockAuth, mockProvider);
+    });
+
+    it('should upgrade anonymous user when enabled', async () => {
+      mockAuth = { currentUser: { isAnonymous: true } } as Auth;
+      (linkWithRedirect as any).mockResolvedValue(undefined);
+
+      await fuiSignInWithOAuth(mockAuth, mockProvider as any, { enableAutoUpgradeAnonymous: true });
+
+      expect(linkWithRedirect).toHaveBeenCalledWith(mockAuth.currentUser, mockProvider);
+    });
+  });
+
+  describe('fuiCompleteEmailLinkSignIn', () => {
+    it('should complete email link sign in when valid', async () => {
+      (isSignInWithEmailLink as any).mockReturnValue(true);
+      window.localStorage.setItem('emailForSignIn', '[email protected]');
+      (signInWithCredential as any).mockResolvedValue(mockUserCredential);
+
+      const result = await fuiCompleteEmailLinkSignIn(mockAuth, 'mock-url');
+
+      expect(result).toBe(mockUserCredential);
+      expect(window.localStorage.getItem('emailForSignIn')).toBeNull();
+    });
+
+    it('should return null when not a valid sign in link', async () => {
+      (isSignInWithEmailLink as any).mockReturnValue(false);
+
+      const result = await fuiCompleteEmailLinkSignIn(mockAuth, 'mock-url');
+
+      expect(result).toBeNull();
+    });
+
+    it('should return null when no email in storage', async () => {
+      (isSignInWithEmailLink as any).mockReturnValue(true);
+
+      const result = await fuiCompleteEmailLinkSignIn(mockAuth, 'mock-url');
+
+      expect(result).toBeNull();
+    });
+  });
+});

packages/firebaseui-core/vitest.config.ts

@@ -3,7 +3,7 @@ import { defineConfig } from 'vitest/config';
 export default defineConfig({
   test: {
     // Use the same environment as the package
-    environment: 'node',
+    environment: 'jsdom',
     // Include TypeScript files
     include: ['src/**/*.{test,spec}.{js,ts}'],
     // Exclude build output and node_modules