create-ailk 0.1.0 → 0.2.0

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

@@ -0,0 +1,341 @@
+/**
+ * @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();
+  });
+});