@exegia/corpora-ui 3.0.0 → 3.1.0

package/src/components/blocks/auth/__tests__/auth-flow-block.test.tsx

@@ -1,183 +0,0 @@
-import { describe, expect, mock, test } from "bun:test"
-import { render, screen, waitFor } from "@testing-library/react"
-import userEvent from "@testing-library/user-event"
-import { createStore } from "jotai"
-
-import { ExegiaProvider } from "@/lib/state"
-import { AuthFlowBlock } from "../auth-flow-block"
-import {
-  DEFAULT_AUTH_FLOW_ID,
-  authFlowStepAtom,
-  authUserAtom,
-  goToAuthStepAtom,
-  isAuthenticatedAtom,
-} from "../auth-state"
-import type { IAuthUser } from "../type"
-
-const USER: IAuthUser = {
-  id: "u-1",
-  name: "Yona Appletree",
-  email: "yo@example.com",
-}
-
-type TStore = ReturnType<typeof createStore>
-
-function mount(store: TStore, ui: React.ReactElement) {
-  return render(<ExegiaProvider store={store}>{ui}</ExegiaProvider>)
-}
-
-/** MorphStep exits run under AnimatePresence; happy-dom serves stale
- * selector-cache results to `waitFor` queries that start while an exit is
- * still running — let the exit settle on real timers, then query once. */
-const settleExit = () => new Promise((resolve) => setTimeout(resolve, 400))
-
-async function submitLogin(email = "yo@example.com", password = "hunter22!") {
-  const user = userEvent.setup()
-  await user.type(screen.getByLabelText("Email"), email)
-  await user.type(screen.getByLabelText("Password"), password)
-  await user.click(screen.getByRole("button", { name: "Login" }))
-  return user
-}
-
-describe("AuthFlowBlock · step switching", () => {
-  test("renders the login step by default with pre-wired navigation", async () => {
-    const user = userEvent.setup()
-    const store = createStore()
-    mount(store, <AuthFlowBlock />)
-
-    expect(screen.getByText("Login to your account")).toBeDefined()
-
-    await user.click(screen.getByRole("button", { name: "Sign up" }))
-    expect(store.get(authFlowStepAtom(DEFAULT_AUTH_FLOW_ID))).toBe("signup")
-    await settleExit()
-    expect(screen.getByText("Create your account")).toBeDefined()
-
-    // Signup's footer goes back to login.
-    await user.click(screen.getByRole("button", { name: "Login" }))
-    expect(store.get(authFlowStepAtom(DEFAULT_AUTH_FLOW_ID))).toBe("login")
-    await settleExit()
-
-    // The forgot-password link sits in the password row, which the login
-    // block reveals once the email is valid.
-    await user.type(screen.getByLabelText("Email"), "yo@example.com")
-    await user.click(
-      await screen.findByRole("button", { name: "Forgot password?" })
-    )
-    expect(store.get(authFlowStepAtom(DEFAULT_AUTH_FLOW_ID))).toBe(
-      "forgot-password"
-    )
-  })
-
-  test("follows the store when something else drives the flow", async () => {
-    const store = createStore()
-    mount(store, <AuthFlowBlock />)
-
-    store.set(goToAuthStepAtom(DEFAULT_AUTH_FLOW_ID), "update-password")
-    expect(await screen.findByText("Update your password")).toBeDefined()
-  })
-})
-
-describe("AuthFlowBlock · directives", () => {
-  test("{ verify } moves to the code step with the masked destination", async () => {
-    const store = createStore()
-    const onLogin = mock(() => ({
-      verify: { identifier: "yo@example.com" } as const,
-    }))
-    mount(store, <AuthFlowBlock onLogin={onLogin} />)
-
-    await submitLogin()
-    expect(onLogin).toHaveBeenCalledTimes(1)
-    expect(store.get(authFlowStepAtom(DEFAULT_AUTH_FLOW_ID))).toBe(
-      "verify-code"
-    )
-    // The masked identifier feeds CodeAuthBlock's destination copy.
-    expect(await screen.findByText(/y•••@example\.com/)).toBeDefined()
-  })
-
-  test("{ user } completes the flow and signs the session in", async () => {
-    const store = createStore()
-    mount(store, <AuthFlowBlock onLogin={() => ({ user: USER })} />)
-
-    await submitLogin()
-    expect(store.get(authFlowStepAtom(DEFAULT_AUTH_FLOW_ID))).toBe("success")
-    expect(store.get(isAuthenticatedAtom)).toBe(true)
-    expect(store.get(authUserAtom)?.id).toBe("u-1")
-    await settleExit()
-    expect(screen.getByText("Welcome")).toBeDefined()
-    expect(screen.getByText("You're signed in")).toBeDefined()
-  })
-
-  test("a resolved handler without a directive stays on the step", async () => {
-    const store = createStore()
-    mount(store, <AuthFlowBlock onLogin={() => undefined} />)
-
-    await submitLogin()
-    expect(store.get(authFlowStepAtom(DEFAULT_AUTH_FLOW_ID))).toBe("login")
-  })
-
-  test("a rejected handler stays on the step and shows the block's error", async () => {
-    const store = createStore()
-    mount(
-      store,
-      <AuthFlowBlock
-        onLogin={() => {
-          throw new Error("Wrong password")
-        }}
-      />
-    )
-
-    await submitLogin()
-    expect(store.get(authFlowStepAtom(DEFAULT_AUTH_FLOW_ID))).toBe("login")
-    expect(await screen.findByText("Wrong password")).toBeDefined()
-    expect(store.get(isAuthenticatedAtom)).toBe(false)
-  })
-})
-
-describe("AuthFlowBlock · customization", () => {
-  test("steps overrides merge over the wiring", async () => {
-    const store = createStore()
-    mount(
-      store,
-      <AuthFlowBlock
-        steps={{ login: { title: "Sign in to Corpora", providers: [] } }}
-      />
-    )
-
-    expect(screen.getByText("Sign in to Corpora")).toBeDefined()
-  })
-
-  test("renderStep replaces a step; undefined keeps the default", async () => {
-    const store = createStore()
-    mount(
-      store,
-      <AuthFlowBlock
-        renderStep={(step) =>
-          step === "success" ? <p>Custom landing</p> : undefined
-        }
-      />
-    )
-
-    expect(screen.getByText("Login to your account")).toBeDefined()
-    store.set(goToAuthStepAtom(DEFAULT_AUTH_FLOW_ID), "success")
-    expect(await screen.findByText("Custom landing")).toBeDefined()
-  })
-
-  test("two flow ids orchestrate independently", async () => {
-    const store = createStore()
-    mount(
-      store,
-      <>
-        <AuthFlowBlock flowId="page" />
-        <AuthFlowBlock flowId="modal" />
-      </>
-    )
-
-    store.set(goToAuthStepAtom("modal"), "forgot-password")
-    expect(await screen.findByText("Reset your password")).toBeDefined()
-    // The page flow is still on login.
-    await waitFor(() =>
-      expect(screen.getByText("Login to your account")).toBeDefined()
-    )
-    expect(store.get(authFlowStepAtom("page"))).toBe("login")
-  })
-})

package/src/components/blocks/auth/__tests__/auth-state-atom.test.tsx

@@ -1,247 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { render, screen } from "@testing-library/react"
-import userEvent from "@testing-library/user-event"
-import { createStore } from "jotai"
-
-import { ExegiaProvider } from "@/lib/state"
-import {
-  DEFAULT_AUTH_FLOW_ID,
-  authFlowErrorAtom,
-  authFlowIdentifierAtom,
-  authFlowMaskedIdentifierAtom,
-  authFlowStateAtom,
-  authFlowStatusAtom,
-  authFlowStepAtom,
-  authSessionStatusAtom,
-  authUserAtom,
-  beginAuthVerificationAtom,
-  completeAuthFlowAtom,
-  endAuthSessionAtom,
-  failAuthFlowAtom,
-  goToAuthStepAtom,
-  isAuthenticatedAtom,
-  maskAuthIdentifier,
-  removeAuthFlowInstance,
-  resetAuthFlowAtom,
-  signInAtom,
-  updateAuthUserAtom,
-  useAuthFlow,
-  useAuthFlowActions,
-} from "../auth-state"
-import type { IAuthUser } from "../type"
-
-const USER: IAuthUser = {
-  id: "u-1",
-  name: "Yona Appletree",
-  email: "yo@example.com",
-}
-
-describe("auth flow atoms · instance isolation", () => {
-  test("two flow ids never share state", () => {
-    const store = createStore()
-    store.set(beginAuthVerificationAtom("modal"), {
-      identifier: "yo@example.com",
-    })
-
-    expect(store.get(authFlowStepAtom("modal"))).toBe("verify-code")
-    expect(store.get(authFlowStepAtom("page"))).toBe("login")
-    expect(store.get(authFlowIdentifierAtom("page"))).toBeNull()
-  })
-
-  test("two stores never share state under one id", () => {
-    const one = createStore()
-    const two = createStore()
-    one.set(beginAuthVerificationAtom("shared"), {
-      identifier: "yo@example.com",
-    })
-
-    expect(one.get(authFlowStepAtom("shared"))).toBe("verify-code")
-    expect(two.get(authFlowStepAtom("shared"))).toBe("login")
-  })
-})
-
-describe("auth flow atoms · flow drives the session", () => {
-  test("beginVerification → complete(user) drives flow and session together", () => {
-    const store = createStore()
-    const other = createStore()
-    store.set(beginAuthVerificationAtom(DEFAULT_AUTH_FLOW_ID), {
-      identifier: "+15551234567",
-      channel: "sms",
-    })
-    store.set(completeAuthFlowAtom(DEFAULT_AUTH_FLOW_ID), USER)
-
-    const flow = store.get(authFlowStateAtom(DEFAULT_AUTH_FLOW_ID))
-    expect(flow.step).toBe("success")
-    expect(flow.status).toBe("success")
-    expect(flow.error).toBeNull()
-    expect(flow.channel).toBe("sms")
-    expect(store.get(authUserAtom)).toEqual(USER)
-    expect(store.get(isAuthenticatedAtom)).toBe(true)
-
-    // The other store's session never moved.
-    expect(other.get(authSessionStatusAtom)).toBe("unknown")
-    expect(other.get(authUserAtom)).toBeNull()
-  })
-
-  test("complete() without a user leaves the session alone", () => {
-    const store = createStore()
-    store.set(completeAuthFlowAtom(DEFAULT_AUTH_FLOW_ID))
-
-    expect(store.get(authFlowStatusAtom(DEFAULT_AUTH_FLOW_ID))).toBe("success")
-    expect(store.get(authSessionStatusAtom)).toBe("unknown")
-  })
-})
-
-describe("auth flow atoms · status transitions", () => {
-  test("fail sets status and error; goToStep clears them", () => {
-    const store = createStore()
-    store.set(failAuthFlowAtom(DEFAULT_AUTH_FLOW_ID), "Wrong code")
-
-    expect(store.get(authFlowStatusAtom(DEFAULT_AUTH_FLOW_ID))).toBe("error")
-    expect(store.get(authFlowErrorAtom(DEFAULT_AUTH_FLOW_ID))).toBe(
-      "Wrong code"
-    )
-
-    store.set(goToAuthStepAtom(DEFAULT_AUTH_FLOW_ID), "forgot-password")
-    expect(store.get(authFlowStepAtom(DEFAULT_AUTH_FLOW_ID))).toBe(
-      "forgot-password"
-    )
-    expect(store.get(authFlowStatusAtom(DEFAULT_AUTH_FLOW_ID))).toBe("idle")
-    expect(store.get(authFlowErrorAtom(DEFAULT_AUTH_FLOW_ID))).toBeNull()
-  })
-})
-
-describe("maskAuthIdentifier", () => {
-  test("masks emails, keeping the first character and the domain", () => {
-    expect(maskAuthIdentifier("yo@example.com")).toBe("y•••@example.com")
-    expect(maskAuthIdentifier("y@ex.co")).toBe("y•••@ex.co")
-  })
-
-  test("masks phone numbers down to the last 4 characters", () => {
-    expect(maskAuthIdentifier("+15551234567")).toBe("•••4567")
-    expect(maskAuthIdentifier("123")).toBe("•••")
-    // Exactly 4 chars: last-4 would reveal everything — mask it all.
-    expect(maskAuthIdentifier("1234")).toBe("•••")
-  })
-
-  test("the derived atom masks the identifier in flight", () => {
-    const store = createStore()
-    expect(store.get(authFlowMaskedIdentifierAtom("m"))).toBeNull()
-
-    store.set(beginAuthVerificationAtom("m"), {
-      identifier: "yo@example.com",
-    })
-    expect(store.get(authFlowMaskedIdentifierAtom("m"))).toBe(
-      "y•••@example.com"
-    )
-  })
-})
-
-describe("auth session atoms · sign out", () => {
-  test("endAuthSession clears the session and resets the default flow", () => {
-    const store = createStore()
-    store.set(beginAuthVerificationAtom(DEFAULT_AUTH_FLOW_ID), {
-      identifier: "yo@example.com",
-    })
-    store.set(completeAuthFlowAtom(DEFAULT_AUTH_FLOW_ID), USER)
-
-    store.set(endAuthSessionAtom)
-    expect(store.get(authSessionStatusAtom)).toBe("unauthenticated")
-    expect(store.get(authUserAtom)).toBeNull()
-    expect(store.get(isAuthenticatedAtom)).toBe(false)
-
-    const flow = store.get(authFlowStateAtom(DEFAULT_AUTH_FLOW_ID))
-    expect(flow.step).toBe("login")
-    expect(flow.identifier).toBeNull()
-    expect(flow.maskedIdentifier).toBeNull()
-    expect(flow.status).toBe("idle")
-  })
-})
-
-describe("auth session atoms · updateAuthUser", () => {
-  test("shallow-merges a patch into the signed-in user", () => {
-    const store = createStore()
-    store.set(signInAtom, USER)
-    store.set(updateAuthUserAtom, { name: "Yona A.", avatar: "/a.png" })
-
-    expect(store.get(authUserAtom)).toEqual({
-      ...USER,
-      name: "Yona A.",
-      avatar: "/a.png",
-    })
-  })
-
-  test("is a no-op when signed out", () => {
-    const store = createStore()
-    store.set(updateAuthUserAtom, { name: "Nobody" })
-    expect(store.get(authUserAtom)).toBeNull()
-  })
-})
-
-describe("auth flow atoms · reset and teardown", () => {
-  test("resetAuthFlow restores the initial values", () => {
-    const store = createStore()
-    store.set(beginAuthVerificationAtom("r"), {
-      identifier: "+15551234567",
-      channel: "sms",
-      step: "signup",
-    })
-    store.set(failAuthFlowAtom("r"), "nope")
-
-    store.set(resetAuthFlowAtom("r"))
-    expect(store.get(authFlowStateAtom("r"))).toEqual({
-      step: "login",
-      identifier: null,
-      maskedIdentifier: null,
-      channel: "email",
-      status: "idle",
-      error: null,
-    })
-  })
-
-  test("removeAuthFlowInstance drops the slice back to its defaults", () => {
-    const store = createStore()
-    store.set(beginAuthVerificationAtom("gone"), {
-      identifier: "yo@example.com",
-    })
-
-    removeAuthFlowInstance("gone")
-    expect(store.get(authFlowStepAtom("gone"))).toBe("login")
-    expect(store.get(authFlowIdentifierAtom("gone"))).toBeNull()
-  })
-})
-
-describe("ExegiaProvider · siblings share one flow", () => {
-  /** Drives the flow; holds no state of its own. */
-  function Begin() {
-    const { beginVerification } = useAuthFlowActions()
-    return (
-      <button
-        onClick={() => beginVerification({ identifier: "yo@example.com" })}
-        type="button"
-      >
-        begin
-      </button>
-    )
-  }
-
-  /** Reads the flow; no relationship to `Begin` beyond the default id. */
-  function Destination() {
-    const flow = useAuthFlow()
-    return <p>{flow.maskedIdentifier ?? "no destination"}</p>
-  }
-
-  test("one sibling's beginVerification shows in the other's read", async () => {
-    const user = userEvent.setup()
-    render(
-      <ExegiaProvider store={createStore()}>
-        <Begin />
-        <Destination />
-      </ExegiaProvider>
-    )
-
-    expect(screen.getByText("no destination")).toBeDefined()
-    await user.click(screen.getByRole("button", { name: "begin" }))
-    expect(await screen.findByText("y•••@example.com")).toBeDefined()
-  })
-})

package/src/components/blocks/auth/__tests__/linked-accounts-block.test.tsx

@@ -1,128 +0,0 @@
-import { describe, expect, mock, test } from "bun:test";
-import { render, screen } from "@testing-library/react";
-import userEvent from "@testing-library/user-event";
-
-import {
-  LinkedAccountsBlock,
-} from "../linked-accounts-block";
-import type { ILinkedIdentity } from "../type";
-
-const IDENTITIES: ILinkedIdentity[] = [
-  { id: "id-1", provider: "google", email: "reader@example.com" },
-  { id: "id-2", provider: "github" },
-];
-
-describe("LinkedAccountsBlock", () => {
-  test("shows the loading row", () => {
-    render(<LinkedAccountsBlock loading />);
-    expect(screen.getByText("Loading connected accounts…")).toBeDefined();
-  });
-
-  test("shows the empty state when nothing is connected", () => {
-    render(<LinkedAccountsBlock identities={[]} />);
-    expect(screen.getByText("No sign-in methods connected yet.")).toBeDefined();
-  });
-
-  test("lists connected identities with their addresses", () => {
-    render(<LinkedAccountsBlock identities={IDENTITIES} />);
-
-    const list = screen.getByRole("list", { name: "Connected accounts" });
-    expect(list.querySelectorAll("li")).toHaveLength(2);
-    expect(screen.getByText("reader@example.com")).toBeDefined();
-  });
-
-  test("offers only the providers that are not connected yet", () => {
-    render(
-      <LinkedAccountsBlock
-        identities={IDENTITIES}
-        providers={["google", "apple", "github"]}
-      />,
-    );
-
-    expect(screen.getByRole("button", { name: "Connect Apple" })).toBeDefined();
-    expect(screen.queryByRole("button", { name: "Connect Google" })).toBeNull();
-    expect(screen.queryByRole("button", { name: "Connect GitHub" })).toBeNull();
-  });
-
-  test("connects a provider through onLink", async () => {
-    const user = userEvent.setup();
-    const onLink = mock(async () => {});
-    render(
-      <LinkedAccountsBlock
-        identities={IDENTITIES}
-        providers={["apple"]}
-        onLink={onLink}
-      />,
-    );
-
-    await user.click(screen.getByRole("button", { name: "Connect Apple" }));
-
-    expect(onLink).toHaveBeenCalledWith("apple");
-  });
-
-  test("disconnects an identity through onUnlink", async () => {
-    const user = userEvent.setup();
-    const onUnlink = mock(async () => {});
-    render(<LinkedAccountsBlock identities={IDENTITIES} onUnlink={onUnlink} />);
-
-    await user.click(screen.getByRole("button", { name: "Disconnect Google" }));
-
-    expect(onUnlink).toHaveBeenCalledWith("id-1");
-  });
-
-  test("guards the last remaining sign-in method", async () => {
-    const user = userEvent.setup();
-    const onUnlink = mock(async () => {});
-    render(
-      <LinkedAccountsBlock identities={[IDENTITIES[0]!]} onUnlink={onUnlink} />,
-    );
-
-    const button = screen.getByRole("button", { name: "Disconnect Google" });
-    expect(button.hasAttribute("disabled")).toBe(true);
-
-    const note = screen.getByText(
-      "This is your only way to sign in, so it can't be disconnected.",
-    );
-    expect(button.getAttribute("aria-describedby")).toBe(note.id);
-
-    await user.click(button);
-    expect(onUnlink).not.toHaveBeenCalled();
-  });
-
-  test("lifts the guard when another sign-in method exists off-list", async () => {
-    const user = userEvent.setup();
-    const onUnlink = mock(async () => {});
-    render(
-      <LinkedAccountsBlock
-        identities={[IDENTITIES[0]!]}
-        hasOtherSignInMethods
-        onUnlink={onUnlink}
-      />,
-    );
-
-    const button = screen.getByRole("button", { name: "Disconnect Google" });
-    expect(button.hasAttribute("disabled")).toBe(false);
-
-    await user.click(button);
-    expect(onUnlink).toHaveBeenCalledWith("id-1");
-  });
-
-  test("surfaces a failing link as an error", async () => {
-    const user = userEvent.setup();
-    render(
-      <LinkedAccountsBlock
-        identities={IDENTITIES}
-        providers={["apple"]}
-        onLink={async () => {
-          throw new Error("That account is already linked elsewhere.");
-        }}
-      />,
-    );
-
-    await user.click(screen.getByRole("button", { name: "Connect Apple" }));
-
-    expect((await screen.findByRole("alert")).textContent).toBe(
-      "That account is already linked elsewhere.",
-    );
-  });
-});