test: Add integration tests for Firebase UI authentication methods

Author: exaby73

packages/firebaseui-core/package.json

@@ -23,8 +23,11 @@
     "lint": "tsc --noEmit",
     "format": "prettier --write \"src/**/*.ts\"",
     "clean": "rimraf dist",
-    "test": "vitest run",
-    "test:watch": "vitest"
+    "test": "vitest run tests/unit",
+    "test:watch": "vitest tests/unit",
+    "test:integration": "vitest run tests/integration",
+    "test:integration:watch": "vitest tests/integration",
+    "test:all": "vitest run"
   },
   "keywords": [
     "firebase",
@@ -43,6 +46,7 @@
   },
   "devDependencies": {
     "@types/jsdom": "^21.1.7",
+    "firebase": "^11.0.0",
     "jsdom": "^26.0.0",
     "prettier": "^3.1.1",
     "rimraf": "^6.0.1",

packages/firebaseui-core/tests/integration/auth.integration.test.ts

@@ -0,0 +1,207 @@
+import { describe, it, expect, beforeAll, beforeEach, afterEach } from 'vitest';
+import { initializeApp } from 'firebase/app';
+import { Auth, connectAuthEmulator, getAuth, signOut, deleteUser } from 'firebase/auth';
+import { GoogleAuthProvider } from 'firebase/auth';
+import {
+  fuiSignInWithEmailAndPassword,
+  fuiCreateUserWithEmailAndPassword,
+  fuiSignInWithEmailLink,
+  fuiSendSignInLinkToEmail,
+  fuiSignInAnonymously,
+  fuiSendPasswordResetEmail,
+  fuiSignInWithOAuth,
+} from '../../src/auth';
+
+describe('Firebase UI Auth Integration', () => {
+  let auth: Auth;
+  const testPassword = 'testPassword123!';
+  let testCount = 0;
+
+  const getUniqueEmail = () => `test${Date.now()}-${testCount++}@example.com`;
+
+  beforeAll(() => {
+    const app = initializeApp({
+      apiKey: 'fake-api-key',
+      authDomain: 'fake-auth-domain',
+      projectId: 'fake-project-id',
+    });
+    auth = getAuth(app);
+    connectAuthEmulator(auth, 'http://127.0.0.1:9099', { disableWarnings: true });
+  });
+
+  beforeEach(async () => {
+    if (auth.currentUser) {
+      try {
+        await deleteUser(auth.currentUser);
+      } catch {}
+      await signOut(auth);
+    }
+    window.localStorage.clear();
+    testCount = 0;
+  });
+
+  afterEach(async () => {
+    if (auth.currentUser) {
+      try {
+        await deleteUser(auth.currentUser);
+      } catch {}
+      await signOut(auth);
+    }
+    window.localStorage.clear();
+  });
+
+  describe('Email/Password Authentication', () => {
+    it('should create a new user and sign in', async () => {
+      const email = getUniqueEmail();
+
+      const createResult = await fuiCreateUserWithEmailAndPassword(auth, email, testPassword);
+      expect(createResult.user).toBeDefined();
+      expect(createResult.user.email).toBe(email);
+
+      await signOut(auth);
+
+      const signInResult = await fuiSignInWithEmailAndPassword(auth, email, testPassword);
+      expect(signInResult.user).toBeDefined();
+      expect(signInResult.user.email).toBe(email);
+    });
+
+    it('should fail with invalid credentials', async () => {
+      const email = getUniqueEmail();
+      await expect(fuiSignInWithEmailAndPassword(auth, email, 'wrongpassword')).rejects.toThrow();
+    });
+
+    it('should handle password reset email', async () => {
+      const email = getUniqueEmail();
+      await fuiCreateUserWithEmailAndPassword(auth, email, testPassword);
+      await signOut(auth);
+
+      await expect(fuiSendPasswordResetEmail(auth, email)).resolves.not.toThrow();
+    });
+  });
+
+  describe('Anonymous Authentication', () => {
+    it('should sign in anonymously', async () => {
+      const result = await fuiSignInAnonymously(auth);
+      expect(result.user).toBeDefined();
+      expect(result.user.isAnonymous).toBe(true);
+    });
+
+    it('should upgrade anonymous user to email/password', async () => {
+      const email = getUniqueEmail();
+
+      await fuiSignInAnonymously(auth);
+
+      const result = await fuiCreateUserWithEmailAndPassword(auth, email, testPassword, {
+        enableAutoUpgradeAnonymous: true,
+      });
+
+      expect(result.user).toBeDefined();
+      expect(result.user.email).toBe(email);
+      expect(result.user.isAnonymous).toBe(false);
+    });
+  });
+
+  describe('Email Link Authentication', () => {
+    it('should initiate email link sign in', async () => {
+      const email = getUniqueEmail();
+      await expect(fuiSendSignInLinkToEmail(auth, email)).resolves.not.toThrow();
+
+      expect(window.localStorage.getItem('emailForSignIn')).toBe(email);
+    });
+
+    // Note: Full email link sign-in flow can't be tested in integration tests
+    // as it requires clicking the email link
+  });
+
+  describe('OAuth Authentication', () => {
+    it.skip('should initiate OAuth sign in (skipped - requires user interaction)', async () => {
+      const provider = new GoogleAuthProvider();
+      await fuiSignInWithOAuth(auth, provider);
+    });
+
+    it.skip('should handle OAuth for anonymous upgrade (skipped - requires user interaction)', async () => {
+      await fuiSignInAnonymously(auth);
+      const provider = new GoogleAuthProvider();
+      await fuiSignInWithOAuth(auth, provider, { enableAutoUpgradeAnonymous: true });
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle duplicate email registration', async () => {
+      const email = getUniqueEmail();
+
+      await fuiCreateUserWithEmailAndPassword(auth, email, testPassword);
+      await signOut(auth);
+
+      await expect(fuiCreateUserWithEmailAndPassword(auth, email, testPassword)).rejects.toThrow();
+    });
+
+    it('should handle non-existent user sign in', async () => {
+      const email = getUniqueEmail();
+      await expect(fuiSignInWithEmailAndPassword(auth, email, 'password')).rejects.toThrow();
+    });
+
+    // Note: Firebase Auth has lenient email validation.
+    // We test only definitely invalid email formats here.
+    it('should handle invalid email formats', async () => {
+      const invalidEmails = [
+        'invalid', // No @ symbol
+        '@', // Just @ symbol
+        '@domain', // No local part
+        'user@', // No domain
+      ];
+
+      for (const email of invalidEmails) {
+        await expect(fuiCreateUserWithEmailAndPassword(auth, email, testPassword)).rejects.toThrow();
+      }
+    });
+
+    it('should handle password requirements', async () => {
+      const email = getUniqueEmail();
+      const weakPasswords = ['', '123', 'short'];
+
+      for (const password of weakPasswords) {
+        await expect(fuiCreateUserWithEmailAndPassword(auth, email, password)).rejects.toThrow();
+      }
+    });
+
+    it('should handle multiple anonymous account upgrades', async () => {
+      const email = getUniqueEmail();
+
+      await fuiSignInAnonymously(auth);
+      const result1 = await fuiCreateUserWithEmailAndPassword(auth, email, testPassword, {
+        enableAutoUpgradeAnonymous: true,
+      });
+      expect(result1.user.isAnonymous).toBe(false);
+
+      await signOut(auth);
+      await fuiSignInAnonymously(auth);
+
+      const email2 = getUniqueEmail();
+      const result2 = await fuiCreateUserWithEmailAndPassword(auth, email2, testPassword, {
+        enableAutoUpgradeAnonymous: true,
+      });
+      expect(result2.user.isAnonymous).toBe(false);
+      expect(result2.user.uid).not.toBe(result1.user.uid);
+    });
+
+    it('should handle special characters in email', async () => {
+      const email = `test.name+${Date.now()}@example.com`;
+      const result = await fuiCreateUserWithEmailAndPassword(auth, email, testPassword);
+      expect(result.user.email).toBe(email);
+    });
+
+    it('should handle concurrent sign-in attempts', async () => {
+      const email = getUniqueEmail();
+      await fuiCreateUserWithEmailAndPassword(auth, email, testPassword);
+      await signOut(auth);
+
+      const attempts = Array(3)
+        .fill(null)
+        .map(() => fuiSignInWithEmailAndPassword(auth, email, testPassword));
+
+      const results = await Promise.all(attempts);
+      expect(results.every((result) => result.user.email === email)).toBe(true);
+    });
+  });
+});

packages/firebaseui-core/src/auth.test.ts renamed to packages/firebaseui-core/tests/unit/auth.test.ts

@@ -1,3 +1,4 @@
+/// <reference lib="dom" />
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import {
   Auth,
@@ -26,8 +27,8 @@ import {
   fuiSignInAnonymously,
   fuiSignInWithOAuth,
   fuiCompleteEmailLinkSignIn,
-} from './auth';
-import { FirebaseUIError } from './errors';
+} from '../../src/auth';
+import { FirebaseUIError } from '../../src/errors';
 
 // Mock all Firebase Auth functions
 vi.mock('firebase/auth', async () => {
@@ -66,14 +67,10 @@ describe('Firebase UI Auth', () => {
 
   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);
   });
 
@@ -107,6 +104,34 @@ describe('Firebase UI Auth', () => {
         FirebaseUIError
       );
     });
+
+    it('should handle network errors', async () => {
+      const networkError = { name: 'FirebaseError', code: 'auth/network-request-failed' };
+      (signInWithCredential as any).mockRejectedValue(networkError);
+
+      await expect(fuiSignInWithEmailAndPassword(mockAuth, '[email protected]', 'password')).rejects.toThrow();
+    });
+
+    it('should handle invalid email format', async () => {
+      const invalidEmailError = { name: 'FirebaseError', code: 'auth/invalid-email' };
+      (signInWithCredential as any).mockRejectedValue(invalidEmailError);
+
+      await expect(fuiSignInWithEmailAndPassword(mockAuth, 'invalid-email', 'password')).rejects.toThrow();
+    });
+
+    it('should handle too many requests error', async () => {
+      const tooManyRequestsError = { name: 'FirebaseError', code: 'auth/too-many-requests' };
+      (signInWithCredential as any).mockRejectedValue(tooManyRequestsError);
+
+      await expect(fuiSignInWithEmailAndPassword(mockAuth, '[email protected]', 'password')).rejects.toThrow();
+    });
+
+    it('should handle user disabled error', async () => {
+      const userDisabledError = { name: 'FirebaseError', code: 'auth/user-disabled' };
+      (signInWithCredential as any).mockRejectedValue(userDisabledError);
+
+      await expect(fuiSignInWithEmailAndPassword(mockAuth, '[email protected]', 'password')).rejects.toThrow();
+    });
   });
 
   describe('fuiCreateUserWithEmailAndPassword', () => {
@@ -239,6 +264,56 @@ describe('Firebase UI Auth', () => {
       expect(signInAnonymously).toHaveBeenCalledWith(mockAuth);
       expect(result).toBe(mockUserCredential);
     });
+
+    it('should handle operation not allowed error', async () => {
+      const operationNotAllowedError = { name: 'FirebaseError', code: 'auth/operation-not-allowed' };
+      (signInAnonymously as any).mockRejectedValue(operationNotAllowedError);
+
+      await expect(fuiSignInAnonymously(mockAuth)).rejects.toThrow();
+    });
+
+    it('should handle admin restricted operation error', async () => {
+      const adminRestrictedError = { name: 'FirebaseError', code: 'auth/admin-restricted-operation' };
+      (signInAnonymously as any).mockRejectedValue(adminRestrictedError);
+
+      await expect(fuiSignInAnonymously(mockAuth)).rejects.toThrow();
+    });
+  });
+
+  describe('Anonymous User Upgrade', () => {
+    it('should handle upgrade with existing email', async () => {
+      mockAuth = { currentUser: { isAnonymous: true } } as Auth;
+      const emailExistsError = { name: 'FirebaseError', code: 'auth/email-already-in-use' };
+      (linkWithCredential as any).mockRejectedValue(emailExistsError);
+
+      await expect(
+        fuiCreateUserWithEmailAndPassword(mockAuth, '[email protected]', 'password', {
+          enableAutoUpgradeAnonymous: true,
+        })
+      ).rejects.toThrow();
+    });
+
+    it('should handle upgrade of non-anonymous user', async () => {
+      mockAuth = { currentUser: { isAnonymous: false } } as Auth;
+
+      const result = await fuiCreateUserWithEmailAndPassword(mockAuth, '[email protected]', 'password', {
+        enableAutoUpgradeAnonymous: true,
+      });
+
+      expect(createUserWithEmailAndPassword).toHaveBeenCalled();
+      expect(linkWithCredential).not.toHaveBeenCalled();
+    });
+
+    it('should handle null user during upgrade', async () => {
+      mockAuth = { currentUser: null } as Auth;
+
+      const result = await fuiCreateUserWithEmailAndPassword(mockAuth, '[email protected]', 'password', {
+        enableAutoUpgradeAnonymous: true,
+      });
+
+      expect(createUserWithEmailAndPassword).toHaveBeenCalled();
+      expect(linkWithCredential).not.toHaveBeenCalled();
+    });
   });
 
   describe('fuiSignInWithOAuth', () => {