Merge branch '@invertase/align-core' of https://github.com/firebase/firebaseui-web into @invertase/align-react

Author: Ehesp

packages/core/package.json

@@ -27,10 +27,10 @@
     "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\"",
     "format:check": "prettier --check \"src/**/*.ts\" \"tests/**/*.ts\"",
     "clean": "rimraf dist",
-    "test:unit": "vitest run tests/unit",
-    "test:unit:watch": "vitest tests/unit",
-    "test:integration": "vitest run tests/integration",
-    "test:integration:watch": "vitest tests/integration",
+    "test:unit": "vitest run src",
+    "test:unit:watch": "vitest tests",
+    "test:integration": "vitest run tests",
+    "test:integration:watch": "vitest integration",
     "test": "vitest run",
     "publish:tags": "sh -c 'TAG=\"${npm_package_name}@${npm_package_version}\"; git tag --list \"$TAG\" | grep . || git tag \"$TAG\"; git push origin \"$TAG\"'",
     "release": "pnpm run build && pnpm pack --pack-destination --pack-destination ../../releases/"
@@ -60,6 +60,7 @@
     "tsup": "catalog:",
     "typescript": "catalog:",
     "vite": "catalog:",
+    "vitest-tsconfig-paths": "catalog:",
     "vitest": "catalog:"
   }
 }

packages/core/src/auth.test.ts

@@ -63,7 +63,7 @@ export async function signInWithEmailAndPassword(
 
     if (hasBehavior(ui, "autoUpgradeAnonymousCredential")) {
       const result = await getBehavior(ui, "autoUpgradeAnonymousCredential")(ui, credential);
-
+      
       if (result) {
         return handlePendingCredential(ui, result);
       }
@@ -168,6 +168,7 @@ export async function sendSignInLinkToEmail(ui: FirebaseUIConfiguration, email:
 
     ui.setState("pending");
     await _sendSignInLinkToEmail(ui.auth, email, actionCodeSettings);
+    // TODO: Should this be a behavior ("storageStrategy")?
     window.localStorage.setItem("emailForSignIn", email);
   } catch (error) {
     handleFirebaseError(ui, error);
@@ -248,7 +249,7 @@ export async function completeEmailLinkSignIn(
 
     ui.setState("pending");
     const result = await signInWithEmailLink(ui, email, currentUrl);
-    ui.setState("idle");
+    ui.setState("idle"); // TODO(ehesp): Do we need this here?
     return handlePendingCredential(ui, result);
   } catch (error) {
     handleFirebaseError(ui, error);

packages/core/src/auth.ts

@@ -0,0 +1,220 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createMockUI } from "~/tests/utils";
+import { autoAnonymousLogin, autoUpgradeAnonymousUsers, getBehavior, hasBehavior } from "./behaviors";
+import { Auth, signInAnonymously, User, UserCredential, linkWithCredential, linkWithRedirect, AuthCredential, AuthProvider } from "firebase/auth";
+
+vi.mock("firebase/auth", () => ({
+  signInAnonymously: vi.fn(),
+  linkWithCredential: vi.fn(),
+  linkWithRedirect: vi.fn(),
+}));
+
+describe("hasBehavior", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("should return true if the behavior is enabled, but not call it", () => {
+    const mockBehavior = vi.fn();
+    const ui = createMockUI({
+      behaviors: {
+        autoAnonymousLogin: mockBehavior,
+      },
+    });
+
+    expect(hasBehavior(ui, "autoAnonymousLogin")).toBe(true);
+    expect(mockBehavior).not.toHaveBeenCalled();
+  });
+
+  it("should return false if the behavior is not enabled", () => {
+    const ui = createMockUI();
+    expect(hasBehavior(ui, "autoAnonymousLogin")).toBe(false);
+  });
+});
+
+describe("getBehavior", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("should throw if the behavior is not enabled", () => {
+    const ui = createMockUI();
+    expect(() => getBehavior(ui, "autoAnonymousLogin")).toThrow();
+  });
+
+  it("should call the behavior if it is enabled", () => {
+    const mockBehavior = vi.fn();
+    const ui = createMockUI({
+      behaviors: {
+        autoAnonymousLogin: mockBehavior,
+      },
+    });
+
+    expect(hasBehavior(ui, "autoAnonymousLogin")).toBe(true);
+    expect(getBehavior(ui, "autoAnonymousLogin")).toBe(mockBehavior);
+  });
+});
+
+describe("autoAnonymousLogin", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should sign the user in anonymously if they are not signed in', async () => {
+    const mockAuthStateReady = vi.fn().mockResolvedValue(undefined);
+    const mockUI = createMockUI({
+      auth: {
+        currentUser: null,
+        authStateReady: mockAuthStateReady,
+      } as unknown as Auth,
+    });
+    
+    vi.mocked(signInAnonymously).mockResolvedValue({} as UserCredential);
+    
+    await autoAnonymousLogin().autoAnonymousLogin(mockUI);
+
+    expect(mockAuthStateReady).toHaveBeenCalled();
+    expect(signInAnonymously).toHaveBeenCalledWith(mockUI.auth);
+
+    expect(vi.mocked(mockUI.setState).mock.calls).toEqual([["loading"], ["idle"]]);
+  });
+
+  it('should not attempt to sign in anonymously if the user is already signed in', async () => {
+    const mockAuthStateReady = vi.fn().mockResolvedValue(undefined);
+    const mockUI = createMockUI({
+      auth: {
+        currentUser: { uid: "test-user" } as User,
+        authStateReady: mockAuthStateReady,
+      } as unknown as Auth,
+    });
+    
+    vi.mocked(signInAnonymously).mockResolvedValue({} as UserCredential);
+    
+    await autoAnonymousLogin().autoAnonymousLogin(mockUI);
+
+    expect(mockAuthStateReady).toHaveBeenCalled();
+    expect(signInAnonymously).not.toHaveBeenCalled();
+
+    expect(vi.mocked(mockUI.setState).mock.calls).toEqual([ ["idle"]]);
+  });
+
+  it("should return noop behavior in SSR mode", async () => {
+    // Mock window as undefined to simulate SSR
+    const originalWindow = global.window;
+    // @ts-ignore
+    delete global.window;
+
+    const behavior = autoAnonymousLogin();
+    const mockUI = createMockUI();
+
+    const result = await behavior.autoAnonymousLogin(mockUI);
+
+    expect(result).toEqual({ uid: "server-placeholder" });
+    expect(signInAnonymously).not.toHaveBeenCalled();
+
+    // Restore window
+    global.window = originalWindow;
+  });
+});
+
+describe("autoUpgradeAnonymousUsers", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("autoUpgradeAnonymousCredential", () => {
+    it("should upgrade anonymous user with credential", async () => {
+      const mockCredential = { providerId: "password" } as AuthCredential;
+      const mockUserCredential = { user: { uid: "test-user" } } as UserCredential;
+      const mockAnonymousUser = { uid: "anonymous-user", isAnonymous: true } as User;
+      
+      const mockUI = createMockUI({
+        auth: {
+          currentUser: mockAnonymousUser,
+        } as unknown as Auth,
+      });
+
+      vi.mocked(linkWithCredential).mockResolvedValue(mockUserCredential);
+
+      const behavior = autoUpgradeAnonymousUsers();
+      const result = await behavior.autoUpgradeAnonymousCredential(mockUI, mockCredential);
+
+      expect(linkWithCredential).toHaveBeenCalledWith(mockAnonymousUser, mockCredential);
+      expect(vi.mocked(mockUI.setState).mock.calls).toEqual([["pending"], ["idle"]]);
+      expect(result).toBe(mockUserCredential);
+    });
+
+    it("should return undefined if user is not anonymous", async () => {
+      const mockCredential = { providerId: "password" } as AuthCredential;
+      const mockRegularUser = { uid: "regular-user", isAnonymous: false } as User;
+      
+      const mockUI = createMockUI({
+        auth: {
+          currentUser: mockRegularUser,
+        } as unknown as Auth,
+      });
+
+      const behavior = autoUpgradeAnonymousUsers();
+      const result = await behavior.autoUpgradeAnonymousCredential(mockUI, mockCredential);
+
+      expect(linkWithCredential).not.toHaveBeenCalled();
+      expect(vi.mocked(mockUI.setState).mock.calls).toEqual([]);
+      expect(result).toBeUndefined();
+    });
+
+    it("should return undefined if no current user", async () => {
+      const mockCredential = { providerId: "password" } as AuthCredential;
+      
+      const mockUI = createMockUI({
+        auth: {
+          currentUser: null,
+        } as unknown as Auth,
+      });
+
+      const behavior = autoUpgradeAnonymousUsers();
+      const result = await behavior.autoUpgradeAnonymousCredential(mockUI, mockCredential);
+
+      expect(linkWithCredential).not.toHaveBeenCalled();
+      expect(vi.mocked(mockUI.setState).mock.calls).toEqual([]);
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe("autoUpgradeAnonymousProvider", () => {
+    it("should upgrade anonymous user with provider", async () => {
+      const mockProvider = { providerId: "google.com" } as AuthProvider;
+      const mockAnonymousUser = { uid: "anonymous-user", isAnonymous: true } as User;
+      
+      const mockUI = createMockUI({
+        auth: {
+          currentUser: mockAnonymousUser,
+        } as unknown as Auth,
+      });
+
+      vi.mocked(linkWithRedirect).mockResolvedValue(undefined as never);
+
+      const behavior = autoUpgradeAnonymousUsers();
+      await behavior.autoUpgradeAnonymousProvider(mockUI, mockProvider);
+
+      expect(linkWithRedirect).toHaveBeenCalledWith(mockAnonymousUser, mockProvider);
+      expect(vi.mocked(mockUI.setState).mock.calls).toEqual([["pending"]]);
+    });
+
+    it("should return early if user is not anonymous", async () => {
+      const mockProvider = { providerId: "google.com" } as AuthProvider;
+      const mockRegularUser = { uid: "regular-user", isAnonymous: false } as User;
+      
+      const mockUI = createMockUI({
+        auth: {
+          currentUser: mockRegularUser,
+        } as unknown as Auth,
+      });
+
+      const behavior = autoUpgradeAnonymousUsers();
+      await behavior.autoUpgradeAnonymousProvider(mockUI, mockProvider);
+
+      expect(linkWithRedirect).not.toHaveBeenCalled();
+      expect(vi.mocked(mockUI.setState).mock.calls).toEqual([]);
+    });
+  });
+});

packages/core/src/behaviors.test.ts

@@ -0,0 +1,70 @@
+import { FirebaseApp } from "firebase/app";
+import { Auth } from "firebase/auth";
+import { describe, it, expect } from "vitest";
+import { initializeUI } from "./config";
+import { enUs, registerLocale } from "@firebase-ui/translations";
+import { autoUpgradeAnonymousUsers } from "./behaviors";
+
+describe('initializeUI', () => {
+  it('should return a valid deep store with default values', () => {
+    const config = {
+      app: {} as FirebaseApp,
+      auth: {} as Auth,
+    };
+
+    const ui = initializeUI(config);
+    expect(ui).toBeDefined();
+    expect(ui.get()).toBeDefined();
+    expect(ui.get().app).toBe(config.app);
+    expect(ui.get().auth).toBe(config.auth);
+    expect(ui.get().behaviors).toEqual({});
+    expect(ui.get().state).toEqual("idle");
+    expect(ui.get().locale).toEqual(enUs);
+  });
+
+  it('should merge behaviors', () => {
+    const config = {
+      app: {} as FirebaseApp,
+      auth: {} as Auth,
+      behaviors: [autoUpgradeAnonymousUsers()],
+    };
+
+    const ui = initializeUI(config);
+    expect(ui).toBeDefined();
+    expect(ui.get()).toBeDefined();
+    expect(ui.get().behaviors).toHaveProperty("autoUpgradeAnonymousCredential");
+    expect(ui.get().behaviors).toHaveProperty("autoUpgradeAnonymousProvider");
+  });
+
+  it('should set state and update state when called', () => {
+    const config = {
+      app: {} as FirebaseApp,
+      auth: {} as Auth,
+    };
+
+    const ui = initializeUI(config);
+    expect(ui.get().state).toEqual("idle");
+    ui.get().setState("loading");
+    expect(ui.get().state).toEqual("loading");
+    ui.get().setState("idle");
+    expect(ui.get().state).toEqual("idle");
+  });
+
+  it('should set state and update locale when called', () => {
+    const testLocale1 = registerLocale('test1', {});
+    const testLocale2 = registerLocale('test2', {});
+    
+    const config = {
+      app: {} as FirebaseApp,
+      auth: {} as Auth,
+    };
+
+    const ui = initializeUI(config);
+    expect(ui.get().locale.locale).toEqual('en-US');
+    ui.get().setLocale(testLocale1);
+    expect(ui.get().locale.locale).toEqual('test1');
+    ui.get().setLocale(testLocale2);
+    expect(ui.get().locale.locale).toEqual('test2');
+  });
+});
+