create-ailk 0.27.0 → 0.28.0

package/templates/apps/web/app/[locale]/flows/[slug]/results/[payload]/__tests__/ResultsClient.no-commerce.test.tsx

@@ -0,0 +1,195 @@
+/**
+ * The results page without commerce (#6786 AC2) — the Pro default, where the
+ * route ships with signal-collectors and commerce's `layout.tsx` is absent.
+ *
+ * `ResultsClient` is rendered with no `ResultsCheckoutContext` provider, as
+ * Next renders it in a scaffold that carries no commerce layout: it shows its
+ * non-checkout result — the recommendation, every fit with Book a Call, the
+ * pairing, the Book-a-Call rail and "Email me this plan" — and offers no
+ * checkout action, even for a fit the register can quote.
+ *
+ * This suite ships into that scaffold, so it names no commerce file: it mocks
+ * only `../../../save.actions` (the boundary is ResultsClient → the save
+ * action, covered on its own by `save.actions.test.ts`), plus `next-intl` and
+ * `@working-theory/api-client` as `ResultsClient.checkout.test.tsx` does.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import type { FlowConfig } from "@working-theory/validation";
+
+jest.mock("@working-theory/api-client", () => ({
+  __esModule: true,
+  flows: { get: jest.fn() },
+}));
+
+const mockSave = jest.fn();
+// The boundary under test is ResultsClient's own wiring to its Server Action,
+// not the action itself (save.actions.test.ts) — the same narrow-scope
+// justification ResultsClient.checkout.test.tsx carries.
+// eslint-disable-next-line no-restricted-syntax -- see comment above
+jest.mock("../../../save.actions", () => ({
+  saveRecommendationAction: (...args: unknown[]) => mockSave(...args),
+}));
+
+jest.mock("next-intl", () => ({
+  __esModule: true,
+  useTranslations: () => (key: string) => key,
+  useMessages: () => ({}),
+}));
+
+import { ResultsClient } from "../ResultsClient";
+
+const SLUG = "ailk-recommender";
+const ANSWERS = { team_size: "agency" };
+
+/** A register that CAN quote `pro` — so only commerce's absence withholds Get Started. */
+const CONFIG = {
+  slug: SLUG,
+  defaultLocale: "en",
+  mode: "recommending",
+  steps: [
+    {
+      key: "team",
+      type: "segmentation",
+      copy: { title: { en: "Team" } },
+      questions: [
+        {
+          name: "team_size",
+          options: [
+            { value: "solo", label: { en: "Solo" } },
+            { value: "agency", label: { en: "Agency" } },
+          ],
+        },
+      ],
+    },
+  ],
+  offers: [
+    {
+      key: "pro",
+      copy: { name: { en: "Pro" } },
+      price: { kind: "exact", amount: 249, period: "annual" },
+      rules: [
+        {
+          when: { answer: "team_size", eq: "agency" },
+          reason: { en: "You run an agency." },
+        },
+      ],
+    },
+    {
+      key: "consult",
+      copy: { name: { en: "Consulting" } },
+      price: { kind: "label", label: { en: "Application-based" } },
+      rules: [
+        {
+          when: { answer: "team_size", eq: "agency" },
+          reason: { en: "Agencies ask." },
+        },
+      ],
+    },
+  ],
+  rateTable: {
+    currency: "usd",
+    seatRates: [{ offer: "pro", amount: 249, period: "annual" }],
+    creditLadder: {
+      denomination: "annual",
+      tiers: [{ credits: 10, amount: 99 }],
+      custom: { en: "Contact us" },
+    },
+  },
+  recommendation: {
+    key: "recommendation",
+    copy: { title: { en: "Your recommendation" } },
+  },
+} as FlowConfig;
+
+function renderResults(): void {
+  render(
+    <ResultsClient
+      config={CONFIG}
+      locale="en"
+      answers={ANSWERS}
+      slug={SLUG}
+      payload="v1-abc"
+    />,
+  );
+}
+
+beforeEach(() => {
+  mockSave.mockReset();
+  mockSave.mockResolvedValue({ ok: true, leadId: "lead_1" });
+});
+
+describe("#6786 AC2 — with commerce absent, the results page renders its non-checkout result", () => {
+  it("renders the recommendation and every fit, each with Book a Call — no Get Started", () => {
+    renderResults();
+    expect(screen.getByTestId("flow-results")).toBeInTheDocument();
+    expect(
+      screen.getByRole("heading", { name: "Your recommendation" }),
+    ).toBeInTheDocument();
+    expect(
+      screen.getByTestId("recommendation-card-pro-terminal-bookCall"),
+    ).toBeInTheDocument();
+    expect(
+      screen.getByTestId("recommendation-card-consult-terminal-bookCall"),
+    ).toBeInTheDocument();
+    expect(screen.queryAllByTestId(/-terminal-getStarted$/)).toHaveLength(0);
+    expect(
+      screen.getByTestId("flow-side-panel-safe-default"),
+    ).toBeInTheDocument();
+  });
+
+  it("offers no checkout action anywhere — no price card, no Pay", () => {
+    renderResults();
+    expect(screen.queryByTestId("checkout-price-card")).not.toBeInTheDocument();
+    expect(screen.queryByTestId("flow-results-pay")).not.toBeInTheDocument();
+    expect(
+      screen.queryByRole("button", { name: "getStarted" }),
+    ).not.toBeInTheDocument();
+  });
+
+  it("still saves the plan by email", async () => {
+    const user = userEvent.setup();
+    renderResults();
+    await user.click(screen.getByRole("button", { name: "emailMePlan" }));
+    await user.type(
+      screen.getByLabelText("emailStepSaveTitle"),
+      "jane@example.com",
+    );
+    await user.click(screen.getByTestId("flow-results-save"));
+    expect(mockSave).toHaveBeenCalledTimes(1);
+    expect(mockSave).toHaveBeenCalledWith(SLUG, {
+      answers: ANSWERS,
+      email: "jane@example.com",
+      locale: "en",
+    });
+    expect(
+      await screen.findByTestId("results-email-step-saved"),
+    ).toBeInTheDocument();
+  });
+});
+
+describe("#6786 — the page's own files name no commerce module", () => {
+  // A base file importing a commerce file is swept out of the keyless
+  // snapshot with it (`paidModuleTemplateExclusions`), and a scaffold without
+  // commerce has no `@working-theory/ui-commerce` to resolve.
+  const RESULTS_DIR = join(__dirname, "..");
+  it.each([
+    "page.tsx",
+    "ResultsClient.tsx",
+    "ResultsEmailStep.tsx",
+    "checkout-seam.ts",
+    "../../save.actions.ts",
+    "../../email-moment.ts",
+  ])(
+    "%s imports neither @working-theory/ui-commerce, checkout.actions nor the commerce layout",
+    (file) => {
+      const source = readFileSync(join(RESULTS_DIR, file), "utf8");
+      expect(source).not.toContain('"@working-theory/ui-commerce"');
+      expect(source).not.toMatch(/from "[./]*checkout\.actions"/);
+      expect(source).not.toMatch(/from "\.\/layout"/);
+    },
+  );
+});

package/templates/apps/web/app/[locale]/flows/[slug]/results/[payload]/__tests__/landing.test.tsx

@@ -0,0 +1,293 @@
+// oss: false
+/**
+ * Tests for the recommender's landing on the results permalink (#9071 D3,
+ * AC-2(a)).
+ *
+ * A recommending flow with an offer carrying `lookupKey` is an Offerings
+ * recommender: its completed walk lands on `/<locale>/pricing?plan=<plan>`
+ * while the first fit's Price is in the current shown set, else on
+ * `/<locale>/pricing` with no badge. A flow with no such offer, or whose
+ * first fit carries none, renders `ResultsClient` exactly as before with no
+ * shown-set read (AC-3's `page.test.tsx` holds the legacy render unchanged).
+ *
+ * `redirect` throws `NEXT_REDIRECT:<url>` as in `page.test.tsx`; the clock is
+ * jest's modern fake timers, moved 16 s between cases so the page's 15 s
+ * shown-set read never carries over.
+ */
+import { render, screen } from "@testing-library/react";
+import type { FlowConfig, WorkspaceShownSetWire } from "@working-theory/validation";
+import {
+  encodePermalink,
+  PERMALINK_VERSION,
+  workspaceShownSetWireSchema,
+} from "@working-theory/validation";
+import type { ReactElement } from "react";
+
+const mockGet = jest.fn();
+const mockShown = jest.fn();
+jest.mock("@working-theory/api-client", () => ({
+  __esModule: true,
+  flows: { get: (...args: unknown[]) => mockGet(...args) },
+  offerings: { shown: (...args: unknown[]) => mockShown(...args) },
+}));
+
+const mockRedirect = jest.fn((url: string) => {
+  throw new Error(`NEXT_REDIRECT:${url}`);
+});
+jest.mock("next/navigation", () => ({
+  __esModule: true,
+  redirect: (url: string) => mockRedirect(url),
+}));
+
+jest.mock("next-intl", () => ({
+  __esModule: true,
+  useTranslations: () => (key: string) => key,
+  useMessages: () => ({}),
+}));
+
+import Page from "../page";
+
+const SLUG = "recommender";
+const en = (s: string) => ({ en: s });
+
+type Offer = NonNullable<FlowConfig["offers"]>[number];
+
+function offer(key: string, eq: string, lookupKey?: string): Offer {
+  return {
+    key,
+    copy: { name: en(key) },
+    price: { kind: "label", label: en("$29 / month") },
+    rules: [{ when: { answer: "team", eq }, reason: en(`Because ${eq}.`) }],
+    ...(lookupKey !== undefined ? { lookupKey } : {}),
+  };
+}
+
+function config(offers: unknown = [
+  offer("starter", "solo", "starter_monthly"),
+  offer("agency", "agency", "agency-pro_yearly"),
+]): FlowConfig {
+  return {
+    slug: SLUG,
+    defaultLocale: "en",
+    mode: "recommending",
+    steps: [
+      {
+        key: "q0",
+        type: "segmentation",
+        copy: { title: en("Who are you?") },
+        questions: [
+          {
+            name: "team",
+            options: [
+              { value: "solo", label: en("Solo") },
+              { value: "agency", label: en("Agency") },
+            ],
+          },
+        ],
+      },
+    ],
+    offers,
+  } as FlowConfig;
+}
+
+function product(productId: string, plan: string, periods: Array<"monthly" | "yearly">) {
+  return {
+    productId,
+    plan,
+    name: plan,
+    description: null,
+    marketingFeatures: [],
+    unitLabel: null,
+    note: null,
+    termsNote: null,
+    ailkGroup: "plan" as const,
+    ailkOrder: null,
+    recommended: false,
+    prices: periods.map((period) => ({
+      priceId: `price_${plan}${period}`,
+      lookupKey: `${plan}_${period}`,
+      plan,
+      period,
+      interval: period === "monthly" ? ("month" as const) : ("year" as const),
+      amount: 2900,
+      currency: "usd",
+    })),
+  };
+}
+
+function shownSet(
+  over: Partial<WorkspaceShownSetWire> = {},
+  products = [
+    product("prod_starter", "starter", ["monthly", "yearly"]),
+    product("prod_agency", "agency-pro", ["yearly"]),
+  ],
+): WorkspaceShownSetWire {
+  return workspaceShownSetWireSchema.parse({
+    productIds: products.map((p) => p.productId),
+    recommended: { plan: null, addon: null },
+    offerings: products,
+    state: "current",
+    snapshotAt: "2026-10-18T12:00:00.000Z",
+    ...over,
+  });
+}
+
+const SHOWN = { ok: true, status: 200, body: { status: "shown", shownSet: shownSet() } };
+
+function payloadFor(answers: Record<string, string>): string {
+  return encodePermalink({ version: PERMALINK_VERSION, flowSlug: SLUG, answers });
+}
+
+function page(answers: Record<string, string>, locale = "en"): Promise<ReactElement> {
+  return Page({
+    params: Promise.resolve({ locale, slug: SLUG, payload: payloadFor(answers) }),
+  });
+}
+
+async function landing(answers: Record<string, string>, locale = "en"): Promise<string> {
+  const err = await page(answers, locale).then(
+    () => null,
+    (e: unknown) => e,
+  );
+  const message = err instanceof Error ? err.message : "";
+  if (!message.startsWith("NEXT_REDIRECT:")) throw new Error(`no redirect: ${String(err)}`);
+  return message.slice("NEXT_REDIRECT:".length);
+}
+
+const originalLocales = process.env.NEXT_PUBLIC_ENABLED_LOCALES;
+
+beforeAll(() => {
+  delete process.env.NEXT_PUBLIC_ENABLED_LOCALES;
+  jest.useFakeTimers({ now: new Date("2026-10-18T12:00:00.000Z") });
+});
+
+afterAll(() => {
+  jest.useRealTimers();
+  if (originalLocales !== undefined) process.env.NEXT_PUBLIC_ENABLED_LOCALES = originalLocales;
+});
+
+beforeEach(() => {
+  // Past the shared read's 15 s window, so no case sees another's read.
+  jest.setSystemTime(Date.now() + 16_000);
+  mockGet.mockReset();
+  mockShown.mockReset();
+  mockRedirect.mockClear();
+  mockGet.mockResolvedValue({ ok: true, status: 200, body: config() });
+  mockShown.mockResolvedValue(SHOWN);
+});
+
+afterEach(() => {
+  for (const [url] of mockRedirect.mock.calls) {
+    expect(url).toMatch(/^[a-z0-9/?=-]+$/);
+    expect(url).not.toContain("_");
+    expect(url).not.toContain("://");
+  }
+});
+
+describe("#9071 AC-2(a) — a shown recommendation lands on /pricing?plan=<plan>", () => {
+  it("solo → the starter plan", async () => {
+    await expect(landing({ team: "solo" })).resolves.toBe("/en/pricing?plan=starter");
+  });
+
+  it("agency → the agency-pro plan", async () => {
+    await expect(landing({ team: "agency" })).resolves.toBe("/en/pricing?plan=agency-pro");
+  });
+
+  it("a locale that is not enabled lands on the default locale", async () => {
+    await expect(landing({ team: "solo" }, "fr")).resolves.toBe("/en/pricing?plan=starter");
+  });
+});
+
+describe("#9071 AC-2(a) — a product no longer shown lands on /pricing with no badge", () => {
+  it("agency-pro removed from the shown set", async () => {
+    mockShown.mockResolvedValue({
+      ok: true,
+      status: 200,
+      body: {
+        status: "shown",
+        shownSet: shownSet({}, [product("prod_starter", "starter", ["monthly", "yearly"])]),
+      },
+    });
+    await expect(landing({ team: "agency" })).resolves.toBe("/en/pricing");
+  });
+
+  it.each<[string, () => unknown]>([
+    ["unconnected", () => Promise.resolve({ ok: true, status: 200, body: { status: "unconnected" } })],
+    ["empty", () => Promise.resolve({ ok: true, status: 200, body: { status: "empty" } })],
+    [
+      "an expired shown set",
+      () =>
+        Promise.resolve({
+          ok: true,
+          status: 200,
+          body: { status: "shown", shownSet: shownSet({ state: "expired" }) },
+        }),
+    ],
+    ["a 500", () => Promise.resolve({ ok: false, status: 500, error: { code: "internal_error" } })],
+    ["a body the schema refuses", () => Promise.resolve({ ok: true, status: 200, body: { status: "shown" } })],
+    ["a rejecting call", () => Promise.reject(new Error("ECONNREFUSED"))],
+  ])("%s → /en/pricing", async (_label, answer) => {
+    mockShown.mockImplementation(answer);
+    await expect(landing({ team: "solo" })).resolves.toBe("/en/pricing");
+  });
+
+  it("a read that never settles is given up after 5 s → /en/pricing", async () => {
+    mockShown.mockImplementation(() => new Promise(() => undefined));
+    const outcome = landing({ team: "solo" });
+    await jest.advanceTimersByTimeAsync(5_000);
+    await expect(outcome).resolves.toBe("/en/pricing");
+  });
+
+  it("answers matching no rule → /en/pricing with no shown read", async () => {
+    await expect(landing({ team: "other" })).resolves.toBe("/en/pricing");
+    expect(mockShown).not.toHaveBeenCalled();
+  });
+});
+
+describe("#9071 D3a — one shown-set read per instance per 15 seconds", () => {
+  it("two requests at one clock share one read; one 16 s later reads again", async () => {
+    await landing({ team: "solo" });
+    await landing({ team: "agency" });
+    expect(mockShown).toHaveBeenCalledTimes(1);
+    jest.setSystemTime(Date.now() + 16_000);
+    await landing({ team: "solo" });
+    expect(mockShown).toHaveBeenCalledTimes(2);
+  });
+});
+
+describe("#9071 C6 — a flow that is not an Offerings recommender renders as before", () => {
+  it("a mixed flow whose first fit has no lookupKey renders ResultsClient, no redirect, no read", async () => {
+    mockGet.mockResolvedValue({
+      ok: true,
+      status: 200,
+      body: config([offer("free", "solo"), offer("agency", "agency", "agency-pro_yearly")]),
+    });
+    render(await page({ team: "solo" }));
+    expect(screen.getByTestId("flow-results")).toBeInTheDocument();
+    expect(mockRedirect).not.toHaveBeenCalled();
+    expect(mockShown).not.toHaveBeenCalled();
+  });
+
+  it("an offer with lookupKey: null is no Offerings offer: today's page, no read", async () => {
+    mockGet.mockResolvedValue({
+      ok: true,
+      status: 200,
+      body: config([{ ...offer("starter", "solo"), lookupKey: null }]),
+    });
+    render(await page({ team: "solo" }));
+    expect(screen.getByTestId("flow-results")).toBeInTheDocument();
+    expect(mockRedirect).not.toHaveBeenCalled();
+    expect(mockShown).not.toHaveBeenCalled();
+  });
+
+  it("offers that are not an array never reach the landing or the read", async () => {
+    mockGet.mockResolvedValue({
+      ok: true,
+      status: 200,
+      body: config({ starter: offer("starter", "solo", "starter_monthly") }),
+    });
+    await page({ team: "solo" }).catch(() => undefined);
+    expect(mockRedirect).not.toHaveBeenCalled();
+    expect(mockShown).not.toHaveBeenCalled();
+  });
+});