create-ailk 0.1.0 → 0.2.0

package/templates/apps/web/app/[locale]/flows/[slug]/__tests__/FlowStepperClient.test.tsx

@@ -0,0 +1,341 @@
+/**
+ * Tests for FlowStepperClient's segment-keyed completion redirect (#3960 D5).
+ *
+ * AC1 — two different segments navigate to two different
+ *       /{locale}/thanks/{slug} paths.
+ * AC2 — the redirect URL carries no PII: the mocked FlowStepper submits a
+ *       step whose values contain an email, a name, a phone number, and
+ *       free text, and the pushed URL (a) matches the no-query/no-fragment
+ *       shape and (b) contains none of those submitted substrings — proving
+ *       the wiring, not just the resolver, never routes a form value into
+ *       the URL.
+ * AC4 — backward compatibility: no `thankYou` block on the config never
+ *       navigates (no `onCompleted` reaches FlowStepper at all); no
+ *       `segment` on a `thankYou`-bearing flow resolves to `default`.
+ *
+ * `@working-theory/ui`'s FlowStepper is mocked as a minimal stub that calls
+ * the real `onSubmitStep`/`onCompleted` props it receives — FlowStepper's
+ * OWN submission/onCompleted-firing behavior is already covered by its own
+ * package test (packages/ui/src/sections/__tests__/FlowStepper.test.tsx);
+ * this file is scoped to FlowStepperClient's own responsibility — the
+ * Server Action binding and the onCompleted → router.push wiring.
+ */
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import type { FlowConfig } from "@working-theory/validation";
+import type { ReactElement } from "react";
+
+const mockPush = jest.fn();
+jest.mock("next/navigation", () => ({
+  useRouter: () => ({ push: mockPush }),
+}));
+
+jest.mock("next-intl", () => ({
+  useTranslations: () => (key: string) => key,
+  useMessages: () => ({}),
+}));
+
+// FlowStepperClient binds onSubmitStep directly to this Server Action, and
+// the boundary under test here is the onCompleted -> router.push wiring, not
+// the action itself (covered by flow.actions.test.ts); internal-module mock
+// is the narrowest possible scope.
+// eslint-disable-next-line no-restricted-syntax -- see comment above
+jest.mock("../flow.actions", () => ({
+  submitFlowStepAction: jest.fn(),
+}));
+
+interface MockFlowStepperProps {
+  onSubmitStep: (payload: {
+    stepKey: string;
+    values: Record<string, unknown>;
+    locale?: string;
+  }) => Promise<{
+    ok: boolean;
+    response?: { completed: boolean; segment?: string };
+  }>;
+  onCompleted?: (result: { segment?: string }) => void;
+}
+
+// The PII-laden payload a real form submission would carry — proves AC2 by
+// construction: onCompleted only ever receives `{ segment }` downstream, so
+// none of this can reach the pushed URL.
+const PII_PAYLOAD = {
+  email: "jane@example.com",
+  name: "Jane Doe",
+  phone: "555-123-4567",
+  message: "Please reach out about the enterprise plan as soon as possible",
+};
+
+let capturedOnCompleted: MockFlowStepperProps["onCompleted"];
+
+jest.mock("@working-theory/ui", () => ({
+  FlowStepper: (props: MockFlowStepperProps) => {
+    capturedOnCompleted = props.onCompleted;
+    async function handleSubmit(): Promise<void> {
+      const result = await props.onSubmitStep({
+        stepKey: "contact",
+        values: PII_PAYLOAD,
+        locale: "en",
+      });
+      if (result.ok && result.response?.completed) {
+        props.onCompleted?.({
+          ...(result.response.segment !== undefined
+            ? { segment: result.response.segment }
+            : {}),
+        });
+      }
+    }
+    return require("react").createElement(
+      "button",
+      { "data-testid": "mock-submit", onClick: handleSubmit },
+      "Submit",
+    ) as ReactElement;
+  },
+}));
+
+import { submitFlowStepAction } from "../flow.actions";
+import { FlowStepperClient } from "../FlowStepperClient";
+
+const mockSubmitFlowStepAction = submitFlowStepAction as jest.MockedFunction<
+  typeof submitFlowStepAction
+>;
+
+function thankYouFlowConfig(): FlowConfig {
+  return {
+    slug: "get-a-quote",
+    defaultLocale: "en",
+    steps: [
+      {
+        key: "contact",
+        type: "field",
+        copy: { title: { en: "Let's get started" } },
+        fields: [
+          {
+            name: "email",
+            inputType: "email",
+            required: true,
+            copy: { label: { en: "Email" } },
+          },
+        ],
+      },
+    ],
+    thankYou: {
+      default: "flow-thanks",
+      bySegment: {
+        qualified: "flow-thanks-qualified",
+        standard: "flow-thanks",
+      },
+    },
+  } as FlowConfig;
+}
+
+function noThankYouFlowConfig(): FlowConfig {
+  const { thankYou: _thankYou, ...rest } = thankYouFlowConfig();
+  return rest as FlowConfig;
+}
+
+beforeEach(() => {
+  mockPush.mockClear();
+  mockSubmitFlowStepAction.mockClear();
+  capturedOnCompleted = undefined;
+});
+
+describe("FlowStepperClient — segment-keyed completion redirect (AC1)", () => {
+  it("navigates to the segment's mapped thank-you page", async () => {
+    const user = userEvent.setup();
+    mockSubmitFlowStepAction.mockResolvedValueOnce({
+      ok: true,
+      response: {
+        sessionId: "sess1",
+        landed: "contact",
+        nextStepKey: null,
+        completed: true,
+        segment: "qualified",
+      },
+    });
+
+    render(
+      <FlowStepperClient
+        config={thankYouFlowConfig()}
+        locale="en"
+        slug="get-a-quote"
+      />,
+    );
+    await user.click(screen.getByTestId("mock-submit"));
+
+    expect(mockPush).toHaveBeenCalledWith("/en/thanks/flow-thanks-qualified");
+  });
+
+  it("a DIFFERENT segment navigates to a DIFFERENT thank-you page", async () => {
+    const user = userEvent.setup();
+    mockSubmitFlowStepAction.mockResolvedValueOnce({
+      ok: true,
+      response: {
+        sessionId: "sess1",
+        landed: "contact",
+        nextStepKey: null,
+        completed: true,
+        segment: "standard",
+      },
+    });
+
+    render(
+      <FlowStepperClient
+        config={thankYouFlowConfig()}
+        locale="en"
+        slug="get-a-quote"
+      />,
+    );
+    await user.click(screen.getByTestId("mock-submit"));
+
+    expect(mockPush).toHaveBeenCalledWith("/en/thanks/flow-thanks");
+  });
+});
+
+describe("FlowStepperClient — no PII in the redirect URL (AC2)", () => {
+  it("the pushed URL matches the no-query/no-fragment shape and carries none of the submitted PII substrings", async () => {
+    const user = userEvent.setup();
+    mockSubmitFlowStepAction.mockResolvedValueOnce({
+      ok: true,
+      response: {
+        sessionId: "sess1",
+        landed: "contact",
+        nextStepKey: null,
+        completed: true,
+        segment: "qualified",
+      },
+    });
+
+    render(
+      <FlowStepperClient
+        config={thankYouFlowConfig()}
+        locale="en"
+        slug="get-a-quote"
+      />,
+    );
+    await user.click(screen.getByTestId("mock-submit"));
+
+    // Prove the PII actually reached onSubmitStep (the wiring propagates
+    // real form data as usual) — the interesting assertion is that NONE of
+    // it reaches the push call below.
+    expect(mockSubmitFlowStepAction).toHaveBeenCalledWith(
+      "get-a-quote",
+      expect.objectContaining({ values: PII_PAYLOAD }),
+    );
+
+    expect(mockPush).toHaveBeenCalledTimes(1);
+    const pushedUrl = mockPush.mock.calls[0]?.[0] as string;
+    expect(pushedUrl).toMatch(/^\/[A-Za-z-]+\/thanks\/[a-z0-9-]+$/);
+    for (const value of Object.values(PII_PAYLOAD)) {
+      expect(pushedUrl).not.toContain(value);
+    }
+  });
+});
+
+describe("FlowStepperClient — locale validated before redirect interpolation (AILK #4707)", () => {
+  // NEXT_PUBLIC_ENABLED_LOCALES is unset in this test env, so the
+  // configured-locale set the component validates against is ["en"]
+  // (mirrors middleware.test.ts's own "not set in test env" baseline).
+  it("falls back to the default locale when the [locale] route param is not in the configured set", async () => {
+    const user = userEvent.setup();
+    mockSubmitFlowStepAction.mockResolvedValueOnce({
+      ok: true,
+      response: {
+        sessionId: "sess1",
+        landed: "contact",
+        nextStepKey: null,
+        completed: true,
+        segment: "qualified",
+      },
+    });
+
+    render(
+      <FlowStepperClient
+        config={thankYouFlowConfig()}
+        locale="fr"
+        slug="get-a-quote"
+      />,
+    );
+    await user.click(screen.getByTestId("mock-submit"));
+
+    expect(mockPush).toHaveBeenCalledWith("/en/thanks/flow-thanks-qualified");
+  });
+
+  it("falls back to the default locale for a malformed/unexpected locale segment", async () => {
+    const user = userEvent.setup();
+    mockSubmitFlowStepAction.mockResolvedValueOnce({
+      ok: true,
+      response: {
+        sessionId: "sess1",
+        landed: "contact",
+        nextStepKey: null,
+        completed: true,
+        segment: "qualified",
+      },
+    });
+
+    render(
+      <FlowStepperClient
+        config={thankYouFlowConfig()}
+        locale="../evil"
+        slug="get-a-quote"
+      />,
+    );
+    await user.click(screen.getByTestId("mock-submit"));
+
+    expect(mockPush).toHaveBeenCalledWith("/en/thanks/flow-thanks-qualified");
+  });
+});
+
+describe("FlowStepperClient — backward compatibility (AC4)", () => {
+  it("never navigates when the config carries no thankYou block", async () => {
+    const user = userEvent.setup();
+    mockSubmitFlowStepAction.mockResolvedValueOnce({
+      ok: true,
+      response: {
+        sessionId: "sess1",
+        landed: "contact",
+        nextStepKey: null,
+        completed: true,
+        segment: "qualified",
+      },
+    });
+
+    render(
+      <FlowStepperClient
+        config={noThankYouFlowConfig()}
+        locale="en"
+        slug="get-a-quote"
+      />,
+    );
+
+    expect(capturedOnCompleted).toBeUndefined();
+
+    await user.click(screen.getByTestId("mock-submit"));
+    expect(mockPush).not.toHaveBeenCalled();
+  });
+
+  it("falls back to thankYou.default when the completion carries no segment", async () => {
+    const user = userEvent.setup();
+    mockSubmitFlowStepAction.mockResolvedValueOnce({
+      ok: true,
+      response: {
+        sessionId: "sess1",
+        landed: "contact",
+        nextStepKey: null,
+        completed: true,
+      },
+    });
+
+    render(
+      <FlowStepperClient
+        config={thankYouFlowConfig()}
+        locale="en"
+        slug="get-a-quote"
+      />,
+    );
+    await user.click(screen.getByTestId("mock-submit"));
+
+    expect(mockPush).toHaveBeenCalledWith("/en/thanks/flow-thanks");
+  });
+});

package/templates/apps/web/app/[locale]/flows/[slug]/__tests__/checkout.actions.test.ts

@@ -0,0 +1,287 @@
+/**
+ * Tests for the recommender's two email-moment Server Actions (#4842 D7).
+ *
+ * AC-2 (the action half) — `startCheckoutAction(slug, input)` calls
+ *   `flows.checkout` exactly once with the wire body (the input's fields +
+ *   the two SERVER-BUILT return URLs — the app's own origin + the permalink;
+ *   no money field of any name), calls `redirect(url)` on `ok`, and returns
+ *   `{ ok: false, kind: "not_configured" }` on a 409 WITHOUT throwing.
+ * Security (#4875 review) — a caller-supplied `successUrl` / `cancelUrl` is
+ *   DROPPED, never forwarded; a payload that is not a permalink of THIS flow
+ *   is refused before any api-client call.
+ * D7 — the shared status → kind map (400 / 409 / 429 + retryAfterSeconds /
+ *   other / thrown) on both actions; invalid slug or body → `invalid_input`
+ *   without calling the api-client; the visitor IP is forwarded (#4730).
+ *
+ * Mock shape: `flow.actions.test.ts:18–29` (`@working-theory/api-client` +
+ * `next/headers`), plus `next/navigation`'s `redirect` mocked to THROW
+ * (`page.test.tsx`'s idiom) so the hand-off is observable as a rejection.
+ */
+
+import { encodePermalink, PERMALINK_VERSION } from "@working-theory/validation";
+
+import type { StartCheckoutInput } from "../checkout.actions.js";
+import { saveRecommendationAction, startCheckoutAction } from "../checkout.actions.js";
+
+jest.mock("@working-theory/api-client", () => ({
+  flows: {
+    checkout: jest.fn(),
+    save: jest.fn(),
+  },
+}));
+
+jest.mock("next/headers", () => ({
+  __esModule: true,
+  headers: jest.fn().mockResolvedValue({ get: () => null }),
+}));
+
+const mockRedirect = jest.fn((url: string) => {
+  throw new Error(`NEXT_REDIRECT:${url}`);
+});
+jest.mock("next/navigation", () => ({
+  __esModule: true,
+  redirect: (url: string) => mockRedirect(url),
+}));
+
+import { flows } from "@working-theory/api-client";
+import { headers } from "next/headers";
+
+const mockCheckout = flows.checkout as jest.Mock;
+const mockSave = flows.save as jest.Mock;
+const mockHeaders = headers as jest.Mock;
+
+const SLUG = "ailk-recommender";
+const ANSWERS = { team_size: "agency", wants_seo: "yes" };
+const PAYLOAD = encodePermalink({ version: PERMALINK_VERSION, flowSlug: SLUG, answers: ANSWERS });
+// `resolveBaseUrl()` — the app's configured origin (`NEXT_PUBLIC_BASE_URL`,
+// else its documented fallback) — the SAME source layout.tsx / sitemap.xml use.
+const ORIGIN = process.env["NEXT_PUBLIC_BASE_URL"] ?? "https://ailk.example.com";
+const PERMALINK = `${ORIGIN}/en/flows/${SLUG}/results/${PAYLOAD}`;
+
+const CHECKOUT_INPUT: StartCheckoutInput = {
+  answers: ANSWERS,
+  email: "jane@example.com",
+  locale: "en",
+  offerKey: "pro",
+  seats: 2,
+  period: "annual" as const,
+  creditStop: { kind: "none" as const },
+  payload: PAYLOAD,
+};
+
+/** The wire body the action must hand `flows.checkout` for CHECKOUT_INPUT. */
+const CHECKOUT_BODY = {
+  answers: ANSWERS,
+  email: "jane@example.com",
+  locale: "en",
+  offerKey: "pro",
+  seats: 2,
+  period: "annual" as const,
+  creditStop: { kind: "none" as const },
+  successUrl: `${PERMALINK}?checkout=success`,
+  cancelUrl: `${PERMALINK}?checkout=cancelled`,
+};
+
+const SAVE_BODY = { answers: ANSWERS, email: "jane@example.com", locale: "en" };
+
+beforeEach(() => {
+  jest.spyOn(console, "error").mockImplementation(() => undefined);
+  // #4157 — resolveBaseUrl() reads NEXT_PUBLIC_BASE_URL fresh per call, then
+  // falls back to lib/site-brand.tsx's content/_site.mdx read. Running
+  // inside THIS monorepo checkout, that file is real (ailaunchkit.ai) — set
+  // the env var explicitly (same value ORIGIN above already falls back to)
+  // so the action's resolved origin matches this test's expectation
+  // independent of which real _site.mdx a given test run happens to see.
+  process.env["NEXT_PUBLIC_BASE_URL"] = ORIGIN;
+});
+
+afterEach(() => {
+  jest.clearAllMocks();
+  jest.restoreAllMocks();
+  mockHeaders.mockResolvedValue({ get: () => null });
+  delete process.env["NEXT_PUBLIC_BASE_URL"];
+});
+
+describe("startCheckoutAction — AC-2 (the action half)", () => {
+  it("calls flows.checkout once with the wire body (server-built return URLs, no money field) and redirect(url) on ok", async () => {
+    mockCheckout.mockResolvedValueOnce({
+      ok: true,
+      body: { url: "https://checkout.stripe.com/c/pay/cs_test_123", sessionId: "fs_1" },
+    });
+
+    await expect(startCheckoutAction(SLUG, CHECKOUT_INPUT)).rejects.toThrow(
+      "NEXT_REDIRECT:https://checkout.stripe.com/c/pay/cs_test_123",
+    );
+
+    expect(mockCheckout).toHaveBeenCalledTimes(1);
+    expect(mockCheckout).toHaveBeenCalledWith(SLUG, CHECKOUT_BODY);
+    const sent = mockCheckout.mock.calls[0]?.[1] as Record<string, unknown>;
+    for (const key of ["amount", "total", "unitAmount"]) {
+      expect(Object.keys(sent)).not.toContain(key);
+    }
+    expect(mockRedirect).toHaveBeenCalledTimes(1);
+    expect(mockRedirect).toHaveBeenCalledWith("https://checkout.stripe.com/c/pay/cs_test_123");
+  });
+
+  it("forwards sessionId when present and omits it when absent", async () => {
+    mockCheckout.mockResolvedValueOnce({ ok: false, status: 500, body: {} });
+    await startCheckoutAction(SLUG, { ...CHECKOUT_INPUT, sessionId: "fs_prev" });
+    expect(mockCheckout.mock.calls[0]?.[1]).toMatchObject({ sessionId: "fs_prev" });
+
+    mockCheckout.mockResolvedValueOnce({ ok: false, status: 500, body: {} });
+    await startCheckoutAction(SLUG, CHECKOUT_INPUT);
+    expect(mockCheckout.mock.calls[1]?.[1]).not.toHaveProperty("sessionId");
+  });
+
+  it("DROPS a caller-supplied successUrl / cancelUrl — the wire body carries the server-built ones", async () => {
+    mockCheckout.mockResolvedValueOnce({ ok: false, status: 409, body: {} });
+    const hostile = {
+      ...CHECKOUT_INPUT,
+      successUrl: "https://evil.example/steal",
+      cancelUrl: "https://evil.example/steal",
+    } as StartCheckoutInput;
+    await startCheckoutAction(SLUG, hostile);
+    expect(mockCheckout).toHaveBeenCalledTimes(1);
+    expect(mockCheckout.mock.calls[0]?.[1]).toMatchObject({
+      successUrl: CHECKOUT_BODY.successUrl,
+      cancelUrl: CHECKOUT_BODY.cancelUrl,
+    });
+  });
+
+  it("refuses a payload that is not a permalink of THIS flow, without calling the api-client", async () => {
+    const foreign = encodePermalink({
+      version: PERMALINK_VERSION,
+      flowSlug: "another-flow",
+      answers: ANSWERS,
+    });
+    await expect(
+      startCheckoutAction(SLUG, { ...CHECKOUT_INPUT, payload: foreign }),
+    ).resolves.toEqual({ ok: false, kind: "invalid_input" });
+    await expect(
+      startCheckoutAction(SLUG, { ...CHECKOUT_INPUT, payload: "not-a-permalink!!!" }),
+    ).resolves.toEqual({ ok: false, kind: "invalid_input" });
+    expect(mockCheckout).not.toHaveBeenCalled();
+  });
+
+  it("builds the return URLs with a SAFE locale — an unknown locale segment falls back to the default", async () => {
+    mockCheckout.mockResolvedValueOnce({ ok: false, status: 409, body: {} });
+    await startCheckoutAction(SLUG, { ...CHECKOUT_INPUT, locale: "zz" });
+    expect(mockCheckout.mock.calls[0]?.[1]).toMatchObject({
+      successUrl: `${ORIGIN}/en/flows/${SLUG}/results/${PAYLOAD}?checkout=success`,
+    });
+  });
+
+  it("returns { ok: false, kind: 'not_configured' } on a 409 without throwing", async () => {
+    mockCheckout.mockResolvedValueOnce({ ok: false, status: 409, body: {} });
+    await expect(startCheckoutAction(SLUG, CHECKOUT_INPUT)).resolves.toEqual({
+      ok: false,
+      kind: "not_configured",
+    });
+    expect(mockRedirect).not.toHaveBeenCalled();
+  });
+
+  it("maps 400 → invalid_input, 429 → rate_limited (+retryAfterSeconds), other → unavailable, thrown → network", async () => {
+    mockCheckout.mockResolvedValueOnce({ ok: false, status: 400, body: {} });
+    await expect(startCheckoutAction(SLUG, CHECKOUT_INPUT)).resolves.toEqual({
+      ok: false,
+      kind: "invalid_input",
+    });
+
+    mockCheckout.mockResolvedValueOnce({
+      ok: false,
+      status: 429,
+      body: { retryAfterSeconds: 42 },
+    });
+    await expect(startCheckoutAction(SLUG, CHECKOUT_INPUT)).resolves.toEqual({
+      ok: false,
+      kind: "rate_limited",
+      retryAfterSeconds: 42,
+    });
+
+    mockCheckout.mockResolvedValueOnce({ ok: false, status: 502, body: {} });
+    await expect(startCheckoutAction(SLUG, CHECKOUT_INPUT)).resolves.toEqual({
+      ok: false,
+      kind: "unavailable",
+    });
+
+    mockCheckout.mockRejectedValueOnce(new Error("boom"));
+    await expect(startCheckoutAction(SLUG, CHECKOUT_INPUT)).resolves.toEqual({
+      ok: false,
+      kind: "network",
+    });
+    expect(mockRedirect).not.toHaveBeenCalled();
+  });
+
+  it("logs only the error's NAME on a thrown api-client error — never the error object", async () => {
+    const spy = console.error as jest.Mock;
+    mockCheckout.mockRejectedValueOnce(new TypeError("fetch failed: jane@example.com"));
+    await startCheckoutAction(SLUG, CHECKOUT_INPUT);
+    expect(spy).toHaveBeenCalledTimes(1);
+    const args = spy.mock.calls[0] as unknown[];
+    expect(args).toHaveLength(1);
+    expect(args[0]).toContain("errName=TypeError");
+    expect(String(args[0])).not.toContain("jane@example.com");
+  });
+
+  it("refuses a money field, an invalid email, or a bad slug without calling the api-client", async () => {
+    // A money field is exactly what `.strict()` refuses — it never reaches
+    // the wire body because only the named fields are forwarded; assert the
+    // stricter property: the wire body has no such key at all.
+    mockCheckout.mockResolvedValueOnce({ ok: false, status: 409, body: {} });
+    const withAmount = { ...CHECKOUT_INPUT, amount: 24900 } as StartCheckoutInput;
+    await startCheckoutAction(SLUG, withAmount);
+    expect(Object.keys(mockCheckout.mock.calls[0]?.[1] as object)).not.toContain("amount");
+    mockCheckout.mockClear();
+
+    await expect(
+      startCheckoutAction(SLUG, { ...CHECKOUT_INPUT, email: "not-an-email" }),
+    ).resolves.toEqual({ ok: false, kind: "invalid_input" });
+    await expect(startCheckoutAction("Not A Slug!", CHECKOUT_INPUT)).resolves.toEqual({
+      ok: false,
+      kind: "invalid_input",
+    });
+    expect(mockCheckout).not.toHaveBeenCalled();
+  });
+
+  it("forwards the visitor's x-forwarded-for on the outbound call (#4730)", async () => {
+    mockHeaders.mockResolvedValueOnce({
+      get: (name: string) => (name === "x-forwarded-for" ? "203.0.113.7" : null),
+    });
+    mockCheckout.mockResolvedValueOnce({ ok: false, status: 409, body: {} });
+    await startCheckoutAction(SLUG, CHECKOUT_INPUT);
+    expect(mockCheckout).toHaveBeenCalledWith(SLUG, CHECKOUT_BODY, {
+      headers: { "x-forwarded-for": "203.0.113.7" },
+    });
+  });
+});
+
+describe("saveRecommendationAction — AC-4 (the action half)", () => {
+  it("calls flows.save once with { answers, email, locale } and returns the leadId", async () => {
+    mockSave.mockResolvedValueOnce({ ok: true, body: { leadId: "lead_1", sessionId: "fs_1" } });
+    await expect(saveRecommendationAction(SLUG, SAVE_BODY)).resolves.toEqual({
+      ok: true,
+      leadId: "lead_1",
+    });
+    expect(mockSave).toHaveBeenCalledTimes(1);
+    expect(mockSave).toHaveBeenCalledWith(SLUG, SAVE_BODY);
+    expect(mockCheckout).not.toHaveBeenCalled();
+  });
+
+  it("maps failures exactly as checkout does and never throws", async () => {
+    mockSave.mockResolvedValueOnce({ ok: false, status: 429, body: { retryAfterSeconds: 9 } });
+    await expect(saveRecommendationAction(SLUG, SAVE_BODY)).resolves.toEqual({
+      ok: false,
+      kind: "rate_limited",
+      retryAfterSeconds: 9,
+    });
+    mockSave.mockRejectedValueOnce(new Error("boom"));
+    await expect(saveRecommendationAction(SLUG, SAVE_BODY)).resolves.toEqual({
+      ok: false,
+      kind: "network",
+    });
+    await expect(
+      saveRecommendationAction(SLUG, { ...SAVE_BODY, email: "nope" }),
+    ).resolves.toEqual({ ok: false, kind: "invalid_input" });
+    expect(mockSave).toHaveBeenCalledTimes(2);
+  });
+});