create-ailk 0.2.0 → 0.4.0

package/templates/apps/api/src/services/__tests__/waitlist-experiments.test.ts

@@ -1,341 +0,0 @@
-/**
- * @file waitlist-experiments.test.ts
- * @description Unit tests for the waitlist-experiments service (#4661 D5;
- * extended #4726 for `materializeWaitlistFlows`).
- *
- * External dependency boundaries mocked: @working-theory/database (auto-mock
- * via `../../lib/__mocks__/prisma.ts`, mirroring flow-engine.test.ts), plus
- * — since #4726 composes `upsertFlowDefinition` from `flow-engine.ts` — the
- * same `@working-theory/email` / `@working-theory/license` / `../aeo-score.js`
- * boundary mocks flow-engine.test.ts uses (flow-engine.ts's own import chain
- * reaches all three; `@working-theory/email` in particular re-exports a
- * `.tsx` React-email template Jest's CJS `moduleFileExtensions` can't
- * resolve unmocked).
- */
-// eslint-disable-next-line no-restricted-syntax -- prisma is a DB boundary; __mocks__/prisma.ts activates the auto-mock (Jest requires explicit call for local files)
-jest.mock("../../lib/prisma.js");
-
-jest.mock("@working-theory/email", () => ({
-  sendLeadNotification: jest.fn().mockResolvedValue({ ok: true, messageId: "msg-test" }),
-  sendDeliverableEmail: jest.fn().mockResolvedValue({ ok: true, messageId: "msg-deliverable-test" }),
-}));
-
-jest.mock("@working-theory/license", () => ({
-  checkLicense: jest.fn().mockResolvedValue({
-    tier: "free",
-    plan: null,
-    features: [],
-    expiresAt: null,
-    revoked: false,
-  }),
-}));
-
-// eslint-disable-next-line no-restricted-syntax -- aeo-score.ts is a network boundary (external crawl), same class as the DB mock above
-jest.mock("../aeo-score.js", () => ({
-  scoreUrl: jest.fn(),
-  loadExampleScore: jest.fn(),
-  resolveScoreBudgetMs: () => 6000,
-}));
-
-import { prisma } from "../../lib/prisma.js";
-import {
-  materializeWaitlistFlows,
-  seedWaitlistExperiments,
-  upsertWaitlistExperiment,
-} from "../waitlist-experiments";
-
-const en = (s: string) => ({ en: s });
-const SITE_ID = "site-abc";
-
-beforeEach(() => {
-  jest.clearAllMocks();
-});
-
-function validConfig(key: string) {
-  return {
-    key,
-    mode: "lead-capture" as const,
-    status: "draft" as const,
-    waitlists: [{ key: "main", flowSlug: key }],
-    questionSet: {
-      version: 1 as const,
-      questions: [
-        {
-          id: "email",
-          prompt: en("Your email"),
-          answerType: "email" as const,
-          mapsTo: "email" as const,
-        },
-      ],
-    },
-    tracking: {
-      version: 1 as const,
-      utm: { source: "utm_source", medium: "utm_medium", campaign: "utm_campaign" },
-      waitlists: { main: { campaign: "launch", channels: ["organic"] } },
-    },
-    stripeConfigRef: null,
-  };
-}
-
-/** `validConfig` with two waitlists — for the per-waitlist materialize loop. */
-function validConfigWithTwoWaitlists(key: string) {
-  const base = validConfig(key);
-  return {
-    ...base,
-    waitlists: [
-      { key: "main", flowSlug: `${key}-main` },
-      { key: "vip", flowSlug: `${key}-vip` },
-    ],
-    tracking: {
-      ...base.tracking,
-      waitlists: {
-        main: { campaign: "launch", channels: ["organic"] },
-        vip: { campaign: "launch-vip", channels: ["organic"] },
-      },
-    },
-  };
-}
-
-/**
- * `validConfig` with a SECOND question whose prompt carries no locale in
- * common with the first — `waitlistExperimentConfigSchema` has no
- * locale-parity check (it validates the shape of each question's
- * `LocalizedString` independently), so this config parses successfully, but
- * `compileWaitlistFlow` refuses `unsupported_by_engine` ("no locale is
- * common to every question's prompt") — the compile-time-only failure #4726
- * AC2 targets. Never a `showIf`/score atom: those the SCHEMA-level
- * predicate cross-validation (`walkPredicateAgainstQuestions`) would refuse
- * on its own scoring-register check, before `compileWaitlistFlow` is ever
- * reached — this locale route isolates the compile-only failure cleanly.
- */
-function configWithUncompilableFlow(key: string) {
-  const base = validConfig(key);
-  return {
-    ...base,
-    questionSet: {
-      ...base.questionSet,
-      questions: [
-        ...base.questionSet.questions,
-        { id: "name", prompt: { fr: "Votre nom" }, answerType: "text" as const },
-      ],
-    },
-  };
-}
-
-describe("upsertWaitlistExperiment (D5)", () => {
-  it("validates + upserts a well-formed config on [siteId, key], writing mode/status/config", async () => {
-    (prisma.waitlistExperiment.upsert as jest.Mock).mockResolvedValue({
-      id: "wlexp_1",
-    });
-
-    const config = validConfig("my-experiment");
-    const result = await upsertWaitlistExperiment(SITE_ID, config);
-
-    expect(result).toEqual({ ok: true, id: "wlexp_1" });
-    expect(prisma.waitlistExperiment.upsert).toHaveBeenCalledWith(
-      expect.objectContaining({
-        where: { siteId_key: { siteId: SITE_ID, key: "my-experiment" } },
-        create: expect.objectContaining({
-          siteId: SITE_ID,
-          key: "my-experiment",
-          mode: "lead-capture",
-          status: "draft",
-        }),
-        update: expect.objectContaining({
-          mode: "lead-capture",
-          status: "draft",
-        }),
-      }),
-    );
-  });
-
-  it("rejects an invalid config without touching prisma", async () => {
-    const result = await upsertWaitlistExperiment(SITE_ID, { not: "a config" });
-
-    expect(result.ok).toBe(false);
-    if (!result.ok) expect(result.error.kind).toBe("invalid_input");
-    expect(prisma.waitlistExperiment.upsert).not.toHaveBeenCalled();
-  });
-
-  it("is the ONLY write path — a single upsert call, no second Prisma write", async () => {
-    (prisma.waitlistExperiment.upsert as jest.Mock).mockResolvedValue({
-      id: "wlexp_1",
-    });
-
-    await upsertWaitlistExperiment(SITE_ID, validConfig("my-experiment"));
-
-    expect(prisma.waitlistExperiment.upsert).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe("materializeWaitlistFlows (#4726) — the compile+upsert path and the failure path", () => {
-  it("compiles + upserts one flow_definitions row for a single-waitlist config, slug = flowSlug", async () => {
-    (prisma.flowDefinition.upsert as jest.Mock).mockResolvedValue({
-      id: "flow_1",
-    });
-
-    const config = validConfig("my-experiment");
-    const result = await materializeWaitlistFlows(SITE_ID, config);
-
-    expect(result).toEqual({ ok: true });
-    expect(prisma.flowDefinition.upsert).toHaveBeenCalledTimes(1);
-    expect(prisma.flowDefinition.upsert).toHaveBeenCalledWith(
-      expect.objectContaining({
-        where: { siteId_slug: { siteId: SITE_ID, slug: "my-experiment" } },
-        create: expect.objectContaining({
-          siteId: SITE_ID,
-          slug: "my-experiment",
-          config: expect.objectContaining({ slug: "my-experiment" }),
-        }),
-      }),
-    );
-  });
-
-  it("compiles + upserts one flow_definitions row PER waitlists[] entry, each named by its own flowSlug", async () => {
-    (prisma.flowDefinition.upsert as jest.Mock)
-      .mockResolvedValueOnce({ id: "flow_main" })
-      .mockResolvedValueOnce({ id: "flow_vip" });
-
-    const config = validConfigWithTwoWaitlists("two-wl");
-    const result = await materializeWaitlistFlows(SITE_ID, config);
-
-    expect(result).toEqual({ ok: true });
-    expect(prisma.flowDefinition.upsert).toHaveBeenCalledTimes(2);
-    expect(prisma.flowDefinition.upsert).toHaveBeenNthCalledWith(
-      1,
-      expect.objectContaining({
-        where: { siteId_slug: { siteId: SITE_ID, slug: "two-wl-main" } },
-      }),
-    );
-    expect(prisma.flowDefinition.upsert).toHaveBeenNthCalledWith(
-      2,
-      expect.objectContaining({
-        where: { siteId_slug: { siteId: SITE_ID, slug: "two-wl-vip" } },
-      }),
-    );
-  });
-
-  it("rejects an invalid config without touching prisma", async () => {
-    const result = await materializeWaitlistFlows(SITE_ID, { not: "a config" });
-
-    expect(result.ok).toBe(false);
-    if (!result.ok) expect(result.error.kind).toBe("invalid_input");
-    expect(prisma.flowDefinition.upsert).not.toHaveBeenCalled();
-  });
-
-  it("a compile failure (unsupported_by_engine) exits non-zero naming the waitlist key, and writes no flow_definitions row for it (AC2)", async () => {
-    const config = configWithUncompilableFlow("bad-experiment");
-
-    const result = await materializeWaitlistFlows(SITE_ID, config);
-
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error.kind).toBe("unsupported_by_engine");
-      expect(result.error.message).toContain('"main"');
-    }
-    expect(prisma.flowDefinition.upsert).not.toHaveBeenCalled();
-  });
-});
-
-describe("seedWaitlistExperiments (D5 — the seedFlowPresets loop verbatim, extended #4726 to materialize flows)", () => {
-  beforeEach(() => {
-    (prisma.flowDefinition.upsert as jest.Mock).mockResolvedValue({
-      id: "flow_x",
-    });
-  });
-
-  it("upserts each config once, in order, through upsertWaitlistExperiment", async () => {
-    (prisma.waitlistExperiment.upsert as jest.Mock)
-      .mockResolvedValueOnce({ id: "wlexp_a" })
-      .mockResolvedValueOnce({ id: "wlexp_b" });
-
-    const configA = validConfig("experiment-a");
-    const configB = validConfig("experiment-b");
-
-    const result = await seedWaitlistExperiments(SITE_ID, [configA, configB]);
-
-    expect(result).toEqual({
-      ok: true,
-      seeded: ["experiment-a", "experiment-b"],
-    });
-    expect(prisma.waitlistExperiment.upsert).toHaveBeenCalledTimes(2);
-    expect(prisma.waitlistExperiment.upsert).toHaveBeenNthCalledWith(
-      1,
-      expect.objectContaining({
-        where: { siteId_key: { siteId: SITE_ID, key: "experiment-a" } },
-      }),
-    );
-    expect(prisma.waitlistExperiment.upsert).toHaveBeenNthCalledWith(
-      2,
-      expect.objectContaining({
-        where: { siteId_key: { siteId: SITE_ID, key: "experiment-b" } },
-      }),
-    );
-  });
-
-  it("leaves both a waitlist_experiments row AND one flow_definitions row per waitlists[] entry (AC1)", async () => {
-    (prisma.waitlistExperiment.upsert as jest.Mock).mockResolvedValueOnce({
-      id: "wlexp_a",
-    });
-
-    const config = validConfigWithTwoWaitlists("two-wl");
-
-    const result = await seedWaitlistExperiments(SITE_ID, [config]);
-
-    expect(result).toEqual({ ok: true, seeded: ["two-wl"] });
-    expect(prisma.waitlistExperiment.upsert).toHaveBeenCalledTimes(1);
-    expect(prisma.flowDefinition.upsert).toHaveBeenCalledTimes(2);
-    expect(prisma.flowDefinition.upsert).toHaveBeenNthCalledWith(
-      1,
-      expect.objectContaining({
-        where: { siteId_slug: { siteId: SITE_ID, slug: "two-wl-main" } },
-      }),
-    );
-    expect(prisma.flowDefinition.upsert).toHaveBeenNthCalledWith(
-      2,
-      expect.objectContaining({
-        where: { siteId_slug: { siteId: SITE_ID, slug: "two-wl-vip" } },
-      }),
-    );
-  });
-
-  it("stops at the first invalid config and reports what seeded before it — never a silent partial success", async () => {
-    (prisma.waitlistExperiment.upsert as jest.Mock).mockResolvedValueOnce({
-      id: "wlexp_a",
-    });
-
-    const configA = validConfig("experiment-a");
-    const invalid = { not: "a config" };
-
-    const result = await seedWaitlistExperiments(SITE_ID, [configA, invalid]);
-
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.seeded).toEqual(["experiment-a"]);
-      expect(result.error.kind).toBe("invalid_input");
-    }
-    expect(prisma.waitlistExperiment.upsert).toHaveBeenCalledTimes(1);
-  });
-
-  it("a compile failure stops the run, names the waitlist key, reports nothing seeded for that config, and writes no flow_definitions row for it", async () => {
-    (prisma.waitlistExperiment.upsert as jest.Mock).mockResolvedValueOnce({
-      id: "wlexp_bad",
-    });
-
-    const bad = configWithUncompilableFlow("bad-experiment");
-
-    const result = await seedWaitlistExperiments(SITE_ID, [bad]);
-
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.seeded).toEqual([]);
-      expect(result.error.kind).toBe("unsupported_by_engine");
-      expect(result.error.message).toContain('"main"');
-    }
-    // The experiment row upserts before flow materialization is attempted —
-    // it is `flow_definitions`, not `waitlist_experiments`, that the
-    // compile failure leaves unwritten.
-    expect(prisma.waitlistExperiment.upsert).toHaveBeenCalledTimes(1);
-    expect(prisma.flowDefinition.upsert).not.toHaveBeenCalled();
-  });
-});