create-ailk 0.19.0 → 0.20.0

package/templates/apps/web/app/[locale]/(authed)/account/__tests__/onboarding.test.tsx

@@ -0,0 +1,323 @@
+/**
+ * Tests for /[locale]/account/onboarding — the client's onboarding page
+ * (#8515, spec docs/specs/8515-standard-client-onboarding-diagnostic-and-spec.md
+ * D12; AC-7).
+ *
+ * The page runs its real server actions (`onboarding/actions.ts`) against the
+ * mocked member read and write, as `popups.test.tsx` runs the New menu's.
+ *
+ * Covers:
+ *   1. With the standard onboarding form (D1's five questions) the page
+ *      renders a text input `answer.q0`, a radio group `answer.q1` of four
+ *      options, five checkboxes `answer.q2`, a URL input `answer.q3` and a
+ *      text input `answer.q4`.
+ *   2. Submitting with `q2` checked twice posts `{ answers }` once, the multi
+ *      answer an array, a blank optional answer omitted, and the sent status
+ *      replaces the form. One checked box still posts an array.
+ *   3. A `409 onboarding_off` refusal shows its copy and keeps the form and
+ *      every answer.
+ *   4. `form: null` shows the unavailable copy and a link back to the
+ *      locale's account; a failed read shows the error row with Retry.
+ *   5. No session is a not-found, and nothing is read.
+ */
+import { fireEvent, render, screen, waitFor, within } from "@testing-library/react";
+
+jest.mock("next-intl/server", () => {
+  const msgs: unknown = require("../../../../../messages/en.json");
+  const dig = (obj: unknown, path: string): unknown =>
+    path.split(".").reduce<unknown>(
+      (acc, k) => (acc !== null && typeof acc === "object" ? (acc as Record<string, unknown>)[k] : undefined),
+      obj,
+    );
+  return {
+    __esModule: true,
+    getTranslations: async (arg: string | { namespace?: string; locale?: string }) => {
+      const ns = typeof arg === "string" ? arg : (arg.namespace ?? "");
+      const messages = dig(msgs, ns);
+      return (key: string, values?: Record<string, unknown>): string => {
+        const value = dig(messages, key);
+        if (typeof value !== "string") return `${ns}.${key}`;
+        return value.replace(/\{(\w+)\}/g, (m, name: string) =>
+          values && name in values ? String(values[name]) : m,
+        );
+      };
+    },
+  };
+});
+
+jest.mock("next/headers", () => ({
+  __esModule: true,
+  headers: jest.fn().mockResolvedValue(new Headers()),
+  cookies: jest.fn().mockResolvedValue({ toString: () => "session=abc" }),
+}));
+
+const mockGetSession = jest.fn();
+// eslint-disable-next-line no-restricted-syntax -- #507: mock-internal rewrite pending; auth.ts's lazy Better-Auth singleton has no HTTP/DB boundary a unit test of the session fields can mock without standing up Prisma.
+jest.mock("../../../../../auth", () => ({
+  __esModule: true,
+  auth: { api: { getSession: (...args: unknown[]) => mockGetSession(...args) } },
+}));
+
+const mockMemberOnboarding = jest.fn();
+const mockMemberSubmitOnboarding = jest.fn();
+const mockMemberRequestQuote = jest.fn();
+jest.mock("@working-theory/api-client", () => ({
+  __esModule: true,
+  waitlistSignups: { me: jest.fn() },
+  subscription: { me: jest.fn() },
+  member: {
+    onboarding: (...args: unknown[]) => mockMemberOnboarding(...args),
+    submitOnboarding: (...args: unknown[]) => mockMemberSubmitOnboarding(...args),
+    requestQuote: (...args: unknown[]) => mockMemberRequestQuote(...args),
+  },
+}));
+
+const mockNotFound = jest.fn(() => {
+  throw new Error("NEXT_NOT_FOUND");
+});
+const mockRefresh = jest.fn();
+jest.mock("next/navigation", () => ({
+  __esModule: true,
+  notFound: () => mockNotFound(),
+  useRouter: () => ({ push: jest.fn(), refresh: mockRefresh }),
+  usePathname: () => "/account/onboarding",
+}));
+
+import {
+  memberOnboardingFormResponseSchema,
+  onboardingFlowConfig,
+  type MemberOnboardingFormResponse,
+} from "@working-theory/validation";
+
+import Page from "../onboarding/page";
+
+const SESSION = {
+  user: { id: "user_1", name: "Cleo", email: "cleo@x.io", emailVerified: true },
+};
+
+/** The cookie a single site forwards (`forwardedCookieInit()`). */
+const INIT = { headers: { cookie: "session=abc" } };
+
+/** D1's form as `GET /v1/member/onboarding` serves it (D7). */
+const FORM: MemberOnboardingFormResponse = memberOnboardingFormResponseSchema.parse({
+  form: {
+    title: "Client onboarding",
+    defaultLocale: "en",
+    steps: onboardingFlowConfig.steps,
+  },
+});
+
+const ok = <T,>(body: T) => ({ ok: true, body });
+const refusal = (status: number, code: string) => ({
+  ok: false,
+  status,
+  body: { ok: false, error: { code, message: "x" } },
+});
+
+beforeEach(() => {
+  mockGetSession.mockReset().mockResolvedValue(SESSION);
+  mockMemberOnboarding.mockReset().mockResolvedValue(ok(FORM));
+  mockMemberSubmitOnboarding
+    .mockReset()
+    .mockResolvedValue(ok({ id: "lead_1", createdAt: "2026-10-14T10:00:00.000Z" }));
+  mockMemberRequestQuote.mockReset();
+  mockNotFound.mockClear();
+  mockRefresh.mockReset();
+});
+
+async function renderPage(locale = "fr"): Promise<HTMLElement> {
+  const element = await Page({ params: Promise.resolve({ locale }) });
+  return render(element).container;
+}
+
+function named(container: HTMLElement, name: string): HTMLInputElement[] {
+  return Array.from(container.querySelectorAll<HTMLInputElement>(`[name="${name}"]`));
+}
+
+function type(container: HTMLElement, name: string, value: string): void {
+  const [control] = named(container, name);
+  fireEvent.change(control!, { target: { value } });
+}
+
+/** Answer the four questions the fill cases share; `q4` is left to the case. */
+function answerCommon(container: HTMLElement): void {
+  type(container, "answer.q0", "Grow");
+  fireEvent.click(screen.getByRole("radio", { name: "This month" }));
+  fireEvent.click(screen.getByRole("checkbox", { name: "Content" }));
+  fireEvent.click(screen.getByRole("checkbox", { name: "Website" }));
+  type(container, "answer.q3", "https://cleo.example");
+}
+
+describe("account onboarding page — the controls (AC-7)", () => {
+  it("renders one control per question, each named answer.<name>", async () => {
+    const container = await renderPage();
+    const form = screen.getByTestId("account-onboarding-form");
+
+    const [q0] = named(container, "answer.q0");
+    expect(q0!.tagName).toBe("INPUT");
+    expect(q0!.type).toBe("text");
+    expect(q0!.required).toBe(true);
+
+    const group = within(form).getByRole("radiogroup", { name: "When do you want to start?" });
+    expect(within(group).getAllByRole("radio").map((r) => r.getAttribute("value"))).toEqual([
+      "This week",
+      "This month",
+      "Later this quarter",
+      "Just exploring",
+    ]);
+    expect(named(container, "answer.q1")).toHaveLength(4);
+
+    const boxes = within(form).getByRole("group", { name: "Where do you want help?" });
+    expect(within(boxes).getAllByRole("checkbox")).toHaveLength(5);
+    expect(named(container, "answer.q2")).toHaveLength(5);
+    expect(named(container, "answer.q2").every((input) => input.type === "checkbox")).toBe(true);
+
+    const [q3] = named(container, "answer.q3");
+    expect(q3!.tagName).toBe("INPUT");
+    expect(q3!.inputMode).toBe("url");
+    expect(screen.getByText("Must start with https://.")).toBeInTheDocument();
+
+    const [q4] = named(container, "answer.q4");
+    expect(q4!.tagName).toBe("INPUT");
+    expect(q4!.type).toBe("text");
+
+    expect(screen.getByLabelText("What do you most want from working with us?")).toBe(q0);
+    expect(screen.getByLabelText(/Your website/)).toBe(q3);
+    expect(mockMemberOnboarding).toHaveBeenCalledWith(INIT);
+  });
+});
+
+describe("account onboarding page — submitting (AC-7)", () => {
+  it("posts the answers once, q2 as an array, and shows the sent status", async () => {
+    const container = await renderPage();
+    answerCommon(container);
+    type(container, "answer.q4", "Thanks");
+    fireEvent.click(screen.getByTestId("account-onboarding-submit"));
+
+    const sent = await screen.findByTestId("account-onboarding-sent");
+    expect(sent).toHaveAttribute("role", "status");
+    expect(sent).toHaveTextContent("Thank you — your answers were sent.");
+    expect(screen.queryByTestId("account-onboarding-form")).not.toBeInTheDocument();
+
+    expect(mockMemberSubmitOnboarding).toHaveBeenCalledTimes(1);
+    expect(mockMemberSubmitOnboarding).toHaveBeenCalledWith(
+      {
+        answers: {
+          q0: "Grow",
+          q1: "This month",
+          q2: ["Content", "Website"],
+          q3: "https://cleo.example",
+          q4: "Thanks",
+        },
+      },
+      INIT,
+    );
+    expect(mockMemberRequestQuote).not.toHaveBeenCalled();
+  });
+
+  it("omits a blank optional answer", async () => {
+    const container = await renderPage();
+    answerCommon(container);
+    type(container, "answer.q4", "   ");
+    fireEvent.click(screen.getByTestId("account-onboarding-submit"));
+
+    await screen.findByTestId("account-onboarding-sent");
+    expect(mockMemberSubmitOnboarding).toHaveBeenCalledTimes(1);
+    expect(mockMemberSubmitOnboarding.mock.calls[0]![0]).toEqual({
+      answers: {
+        q0: "Grow",
+        q1: "This month",
+        q2: ["Content", "Website"],
+        q3: "https://cleo.example",
+      },
+    });
+  });
+
+  it("posts one checked box of a multi question as an array", async () => {
+    const container = await renderPage();
+    type(container, "answer.q0", "Grow");
+    fireEvent.click(screen.getByRole("radio", { name: "This week" }));
+    fireEvent.click(screen.getByRole("checkbox", { name: "Sales" }));
+    fireEvent.click(screen.getByTestId("account-onboarding-submit"));
+
+    await screen.findByTestId("account-onboarding-sent");
+    expect(mockMemberSubmitOnboarding.mock.calls[0]![0]).toEqual({
+      answers: { q0: "Grow", q1: "This week", q2: ["Sales"] },
+    });
+  });
+
+  it("a 409 onboarding_off shows its copy and keeps the form and every answer", async () => {
+    mockMemberSubmitOnboarding.mockResolvedValue(refusal(409, "onboarding_off"));
+    const container = await renderPage();
+    answerCommon(container);
+    fireEvent.click(screen.getByTestId("account-onboarding-submit"));
+
+    const error = await screen.findByTestId("account-onboarding-error");
+    expect(error).toHaveTextContent("Onboarding isn't open to you here right now.");
+    expect(screen.getByTestId("account-onboarding-form")).toBeInTheDocument();
+    expect(screen.queryByTestId("account-onboarding-sent")).not.toBeInTheDocument();
+    expect(named(container, "answer.q0")[0]!.value).toBe("Grow");
+    expect(screen.getByRole("radio", { name: "This month" })).toHaveAttribute("aria-checked", "true");
+    expect(screen.getByRole("checkbox", { name: "Content" })).toHaveAttribute("aria-checked", "true");
+    expect(named(container, "answer.q3")[0]!.value).toBe("https://cleo.example");
+  });
+
+  it.each([
+    ["answers_invalid", 400, "Some answers do not fit these questions. Check them and try again."],
+    ["link_not_https", 400, "A link must start with https://."],
+    ["too_many_requests", 429, "Too many submissions. Try again later."],
+    ["something_else", 500, "Your answers could not be sent. Try again."],
+  ])("a %s refusal shows its own copy", async (code, status, copy) => {
+    mockMemberSubmitOnboarding.mockResolvedValue(refusal(status, code));
+    const container = await renderPage();
+    answerCommon(container);
+    fireEvent.click(screen.getByTestId("account-onboarding-submit"));
+
+    await waitFor(() =>
+      expect(screen.getByTestId("account-onboarding-error")).toHaveTextContent(copy),
+    );
+    expect(screen.getByTestId("account-onboarding-form")).toBeInTheDocument();
+  });
+});
+
+describe("account onboarding page — the other states", () => {
+  it("form: null shows the unavailable copy and a link back to the locale's account", async () => {
+    mockMemberOnboarding.mockResolvedValue(ok({ form: null }));
+    await renderPage("fr");
+    expect(screen.getByTestId("account-onboarding-unavailable")).toHaveTextContent(
+      "Onboarding isn't open to you here right now.",
+    );
+    expect(screen.getByRole("link", { name: "Back to your account" })).toHaveAttribute(
+      "href",
+      "/fr/account",
+    );
+    expect(screen.queryByTestId("account-onboarding-form")).not.toBeInTheDocument();
+  });
+
+  it("a 404 read (no member area) is the unavailable state, not an error", async () => {
+    mockMemberOnboarding.mockResolvedValue(refusal(404, "not_found"));
+    await renderPage();
+    expect(screen.getByTestId("account-onboarding-unavailable")).toBeInTheDocument();
+  });
+
+  it("a failed read renders the error row with Retry", async () => {
+    mockMemberOnboarding.mockResolvedValue(refusal(503, "tenant_unresolved"));
+    await renderPage();
+    expect(screen.getByTestId("inbox-error")).toHaveTextContent(
+      "We couldn't load your onboarding questions.",
+    );
+    expect(screen.queryByTestId("account-onboarding-form")).not.toBeInTheDocument();
+    fireEvent.click(screen.getByTestId("inbox-retry"));
+    expect(mockRefresh).toHaveBeenCalledTimes(1);
+  });
+
+  it("no session renders the heading alone — never a not-found over the sign-in gate — and reads nothing", async () => {
+    mockGetSession.mockResolvedValue(null);
+    await renderPage();
+    expect(mockNotFound).not.toHaveBeenCalled();
+    expect(screen.getByTestId("account-onboarding")).toHaveTextContent("Onboarding");
+    expect(screen.queryByTestId("account-onboarding-form")).not.toBeInTheDocument();
+    expect(screen.queryByTestId("account-onboarding-unavailable")).not.toBeInTheDocument();
+    expect(mockMemberOnboarding).not.toHaveBeenCalled();
+  });
+});

package/templates/apps/web/app/[locale]/(authed)/account/__tests__/privacy.test.tsx

@@ -0,0 +1,365 @@
+/**
+ * Tests for /[locale]/account/privacy — User settings › Privacy (#8438
+ * D14, AC-4). The deletion-request cases moved here from general.test.tsx,
+ * expectations unchanged (#8438 D16).
+ */
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { act, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
+
+jest.mock("next-intl/server", () => {
+  const msgs: unknown = require("../../../../../messages/en.json");
+  const dig = (obj: unknown, path: string): unknown =>
+    path.split(".").reduce<unknown>(
+      (acc, k) => (acc !== null && typeof acc === "object" ? (acc as Record<string, unknown>)[k] : undefined),
+      obj,
+    );
+  return {
+    __esModule: true,
+    getTranslations: async (arg: string | { namespace?: string; locale?: string }) => {
+      const ns = typeof arg === "string" ? arg : (arg.namespace ?? "");
+      const messages = dig(msgs, ns);
+      return (key: string, values?: Record<string, unknown>): string => {
+        const value = dig(messages, key);
+        if (typeof value !== "string") return `${ns}.${key}`;
+        return value.replace(/\{(\w+)\}/g, (m, name: string) =>
+          values && name in values ? String(values[name]) : m,
+        );
+      };
+    },
+    getLocale: jest.fn().mockResolvedValue("en"),
+  };
+});
+
+const mockHeaders = jest.fn();
+const mockCookies: Record<string, string> = {};
+jest.mock("next/headers", () => ({
+  __esModule: true,
+  headers: (...args: unknown[]) => mockHeaders(...args),
+  cookies: jest.fn().mockResolvedValue({
+    toString: () => "session=abc",
+    get: (name: string) => (name in mockCookies ? { name, value: mockCookies[name] } : undefined),
+  }),
+}));
+
+const mockGetSession = jest.fn();
+// eslint-disable-next-line no-restricted-syntax -- #507: mock-internal rewrite pending; auth.ts's lazy Better-Auth singleton has no HTTP/DB boundary a unit test of the session fields can mock without standing up Prisma.
+jest.mock("../../../../../auth", () => ({
+  __esModule: true,
+  auth: { api: { getSession: (...args: unknown[]) => mockGetSession(...args) } },
+}));
+
+const mockPieces = jest.fn();
+const mockRequestDeletion = jest.fn();
+const mockConsents = jest.fn();
+const mockSetConsent = jest.fn();
+jest.mock("@working-theory/api-client", () => ({
+  __esModule: true,
+  waitlistSignups: { me: jest.fn() },
+  flowCheckouts: { me: jest.fn() },
+  subscription: { me: jest.fn(), portalSession: jest.fn() },
+  leads: { submit: jest.fn() },
+  member: {
+    pieces: (...args: unknown[]) => mockPieces(...args),
+    requestDeletion: (...args: unknown[]) => mockRequestDeletion(...args),
+    consents: (...args: unknown[]) => mockConsents(...args),
+    setConsent: (...args: unknown[]) => mockSetConsent(...args),
+  },
+  hubSignIn: { me: jest.fn() },
+  visitorForwardHeaders: () => null,
+}));
+
+jest.mock("next/navigation", () => ({
+  __esModule: true,
+  useRouter: () => ({ push: jest.fn(), refresh: jest.fn(), replace: jest.fn() }),
+  usePathname: () => "/account/privacy",
+  redirect: jest.fn(),
+}));
+
+import Page from "../privacy/page";
+
+const SESSION = {
+  user: {
+    id: "user_1",
+    name: "Ada Lovelace",
+    email: "ada@example.com",
+    emailVerified: true,
+    createdAt: new Date("2026-09-01T00:00:00.000Z"),
+  },
+};
+const COOKIE_INIT = { headers: { cookie: "session=abc" } };
+const ok = <T,>(body: T) => ({ ok: true, body });
+const refusal = (status: number, code: string) => ({
+  ok: false,
+  status,
+  body: { ok: false, error: { code, message: code } },
+});
+
+function dataPurpose(overrides: Partial<{ id: string; effective: boolean; state: unknown }> = {}) {
+  return {
+    id: overrides.id ?? "data_sharing",
+    kind: "consent" as const,
+    area: "data" as const,
+    required: false,
+    signUp: false,
+    description: "Product-usage data.",
+    statement: "Share product-usage data with us.",
+    policyHref: "/privacy",
+    policyVersion: 1,
+    state: overrides.state === undefined ? null : overrides.state,
+    effective: overrides.effective ?? false,
+  };
+}
+
+function agreementPurpose(overrides: Partial<{ id: string; state: unknown }> = {}) {
+  return {
+    id: overrides.id ?? "account_terms",
+    kind: "agreement" as const,
+    area: null,
+    required: true,
+    signUp: true,
+    description: "Account terms.",
+    statement: "You agree to our Terms and Privacy Policy.",
+    policyHref: "/terms",
+    policyVersion: 1,
+    state: overrides.state === undefined ? null : overrides.state,
+    effective: false,
+  };
+}
+
+let contentRoot: string;
+
+beforeEach(() => {
+  contentRoot = mkdtempSync(join(tmpdir(), "ailk-privacy-"));
+  process.env.AILK_CONTENT_ROOT = contentRoot;
+  writeFileSync(join(contentRoot, "_site.mdx"), '---\nsiteName: "Test"\n---\n');
+  mockHeaders.mockReset().mockResolvedValue(new Headers());
+  for (const key of Object.keys(mockCookies)) delete mockCookies[key];
+  mockGetSession.mockReset().mockResolvedValue(SESSION);
+  mockPieces.mockReset().mockResolvedValue(ok([]));
+  mockRequestDeletion.mockReset().mockResolvedValue(ok({ sentTo: "site-operator" }));
+  mockConsents.mockReset().mockResolvedValue(ok({ purposes: [] }));
+  mockSetConsent.mockReset();
+});
+
+afterEach(() => {
+  rmSync(contentRoot, { recursive: true, force: true });
+});
+
+async function renderPage(locale = "en"): Promise<void> {
+  render(await Page({ params: Promise.resolve({ locale }) }));
+}
+
+describe("AC-4 — the frame", () => {
+  it("the Settings rail reads General, Security, Notifications, Privacy, Billing, Privacy current", async () => {
+    await renderPage();
+    const rail = screen.getByRole("navigation", { name: "Settings" });
+    const links = within(rail).getAllByRole("link");
+    expect(links.map((link) => link.textContent)).toEqual([
+      "General",
+      "Security",
+      "Notifications",
+      "Privacy",
+      "Billing",
+    ]);
+    expect(screen.getByTestId("account-settings-rail-privacy")).toHaveAttribute("aria-current", "page");
+  });
+
+  it("a non-default locale prefixes the rail", async () => {
+    await renderPage("fr");
+    expect(screen.getByTestId("account-settings-rail-privacy")).toHaveAttribute("href", "/fr/account/privacy");
+  });
+});
+
+describe("AC-4 — DOM order: summary, cookies, consents, agreements, deletion", () => {
+  it("renders the five sections in order", async () => {
+    mockConsents.mockResolvedValue(
+      ok({ purposes: [dataPurpose(), agreementPurpose()] }),
+    );
+    await renderPage();
+    const pane = screen.getByTestId("account-settings-privacy");
+    const ids = [
+      "account-privacy-summary",
+      "account-privacy-cookies",
+      "account-privacy-consents",
+      "account-privacy-agreements",
+      "account-deletion",
+    ];
+    const positions = ids.map((id) => {
+      const el = within(pane).getByTestId(id);
+      let index = 0;
+      let node: Element | null = pane.firstElementChild;
+      while (node && node !== el) {
+        node = node.nextElementSibling;
+        index += 1;
+      }
+      return index;
+    });
+    expect(positions).toEqual([...positions].sort((a, b) => a - b));
+  });
+});
+
+describe("AC-4 — account-privacy-summary", () => {
+  it("links to the site's privacy policy", async () => {
+    await renderPage();
+    expect(screen.getByTestId("account-privacy-policy")).toHaveAttribute("href", "/privacy");
+  });
+});
+
+describe("AC-4 — account-privacy-cookies (read from the browser cookie, not the ledger)", () => {
+  it.each([
+    ["accepted", "Accepted"],
+    ["declined", "Declined"],
+  ])("reads %s as %s", async (value, label) => {
+    mockCookies["ailk-consent"] = value;
+    await renderPage();
+    expect(within(screen.getByTestId("account-privacy-cookies")).getByText(label)).toBeInTheDocument();
+  });
+
+  it("with no cookie set, reads Not chosen yet", async () => {
+    await renderPage();
+    expect(within(screen.getByTestId("account-privacy-cookies")).getByText("Not chosen yet")).toBeInTheDocument();
+  });
+
+  it("the Change link points at /privacy#cookie-settings", async () => {
+    await renderPage();
+    expect(screen.getByTestId("account-cookie-settings")).toHaveAttribute("href", "/privacy#cookie-settings");
+  });
+});
+
+describe("AC-4 — account-privacy-consents (data-use switches)", () => {
+  it("a declared data purpose renders a switch with its date", async () => {
+    mockConsents.mockResolvedValue(
+      ok({
+        purposes: [
+          dataPurpose({
+            effective: true,
+            state: { granted: true, at: "2026-10-12T12:00:00.000Z", source: "account_settings", policyVersion: 1 },
+          }),
+        ],
+      }),
+    );
+    await renderPage();
+    expect(screen.getByTestId("account-privacy-data-consent-data_sharing-switch")).toBeChecked();
+    expect(screen.getByTestId("account-privacy-data-consent-data_sharing-date")).toHaveTextContent(
+      "Given Oct 12, 2026",
+    );
+  });
+
+  it("toggling calls setConsentAction, and a failed answer reverts the switch with its message", async () => {
+    mockConsents.mockResolvedValue(ok({ purposes: [dataPurpose({ effective: true })] }));
+    mockSetConsent.mockResolvedValue(refusal(500, "internal"));
+    await renderPage();
+    fireEvent.click(screen.getByTestId("account-privacy-data-consent-data_sharing-switch"));
+    await waitFor(() =>
+      expect(screen.getByTestId("account-privacy-data-consent-data_sharing-error")).toBeInTheDocument(),
+    );
+    expect(screen.getByTestId("account-privacy-data-consent-data_sharing-switch")).toBeChecked();
+    expect(mockSetConsent).toHaveBeenCalledWith({ purposeId: "data_sharing", granted: false, locale: "en" }, COOKIE_INIT);
+  });
+
+  it("with no data purpose declared, shows the one line", async () => {
+    await renderPage();
+    expect(screen.getByTestId("account-privacy-data-consent-empty")).toHaveTextContent(
+      "This site asks for no other data-use consents.",
+    );
+  });
+});
+
+describe("AC-4 — account-privacy-agreements (read-only)", () => {
+  it("an accepted agreement shows its version and date, read-only", async () => {
+    mockConsents.mockResolvedValue(
+      ok({
+        purposes: [
+          agreementPurpose({
+            state: { granted: true, at: "2026-10-01T12:00:00.000Z", source: "sign_up", policyVersion: 1 },
+          }),
+        ],
+      }),
+    );
+    await renderPage();
+    const row = screen.getByTestId("account-privacy-agreement-account_terms");
+    expect(within(row).getByText("Version 1")).toBeInTheDocument();
+    expect(within(row).getByText("Accepted Oct 1, 2026")).toBeInTheDocument();
+    expect(within(row).queryByRole("switch")).not.toBeInTheDocument();
+    expect(within(row).queryByRole("button")).not.toBeInTheDocument();
+  });
+
+  it("an agreement with no grant shows None yet", async () => {
+    mockConsents.mockResolvedValue(ok({ purposes: [agreementPurpose()] }));
+    await renderPage();
+    expect(screen.getByTestId("account-privacy-agreement-account_terms-accepted")).toHaveTextContent("None yet");
+  });
+});
+
+describe("AC-4 — a failed consents read", () => {
+  it("keeps sections 1, 2 and 5 and shows the one error line in place of 3 and 4", async () => {
+    mockConsents.mockResolvedValue(refusal(503, "tenant_unresolved"));
+    await renderPage();
+    expect(screen.getByTestId("account-privacy-summary")).toBeInTheDocument();
+    expect(screen.getByTestId("account-privacy-cookies")).toBeInTheDocument();
+    expect(screen.getByTestId("account-deletion")).toBeInTheDocument();
+    expect(screen.queryByTestId("account-privacy-consents")).not.toBeInTheDocument();
+    expect(screen.queryByTestId("account-privacy-agreements")).not.toBeInTheDocument();
+    expect(screen.getByTestId("account-privacy-unavailable")).toHaveTextContent(
+      "Your consent choices can't be shown right now.",
+    );
+  });
+});
+
+// ── Deletion (moved from general.test.tsx, #8438 D16 — expectations unchanged) ──
+
+describe("AC-4 — Request account deletion through the member API (moved from General, D16)", () => {
+  async function requestDeletion(): Promise<void> {
+    await act(async () => {
+      fireEvent.click(screen.getByTestId("account-deletion-request"));
+    });
+  }
+
+  it.each([
+    ["site-operator", "Sent to the site operator."],
+    ["hub-operator", "Sent to the hub operator."],
+  ])("an answer naming %s shows %s — the answer picks the line", async (sentTo, line) => {
+    mockRequestDeletion.mockResolvedValue(ok({ sentTo }));
+    await renderPage();
+    await requestDeletion();
+    expect(mockRequestDeletion).toHaveBeenCalledWith({}, COOKIE_INIT);
+    await waitFor(() => expect(screen.getByRole("status")).toHaveTextContent(line));
+    expect(screen.queryByTestId("account-deletion-request")).not.toBeInTheDocument();
+  });
+
+  it("a refusal shows its line and keeps the button", async () => {
+    mockRequestDeletion.mockResolvedValue(refusal(403, "email_unverified"));
+    await renderPage();
+    await requestDeletion();
+    await waitFor(() =>
+      expect(screen.getByRole("alert")).toHaveTextContent("Confirm your email address first, then ask again."),
+    );
+    expect(screen.getByTestId("account-deletion-request")).toBeEnabled();
+  });
+});
+
+describe("a single site with no member API (a 404 from the pieces read) — moved from general.test.tsx", () => {
+  it("points the deletion request at Support, with no Request button (C2, D5)", async () => {
+    mockPieces.mockResolvedValue(refusal(404, "not_found"));
+    await renderPage();
+    expect(screen.queryByTestId("account-deletion-request")).not.toBeInTheDocument();
+    expect(screen.getByTestId("account-deletion-support")).toHaveAttribute("href", "/account/support");
+    expect(screen.getByText("To ask for your account to be deleted, contact support.")).toBeInTheDocument();
+  });
+});
+
+describe("the standalone shape (#8430)", () => {
+  it("takes the screen as the Admin's settings do: the rail column and the pane are the page's own landmarks", async () => {
+    await renderPage();
+    const settings = screen.getByTestId("account-settings");
+    expect(settings).toHaveClass("min-h-screen");
+    const column = within(settings).getByRole("complementary");
+    expect(column.firstElementChild).toBe(screen.getByTestId("account-settings-back"));
+    expect(within(settings).getByRole("main")).toContainElement(
+      screen.getByRole("heading", { level: 1 }),
+    );
+  });
+});