create-ailk 0.2.0 → 0.4.0

package/templates/apps/api/src/services/__tests__/project-listing-flow.test.ts

@@ -1,475 +0,0 @@
-/**
- * @file project-listing-flow.test.ts
- * @description Unit tests for the approve-time projection (#5001 AC1/AC2/AC3):
- * the template default's `questions` block becomes a `FlowDefinition` with the
- * six-category step order and a live `WaitlistExperiment` keyed `{slug}`, the
- * row's `experimentId` is written back, the thank-you shows the confirmation
- * line and never the tier, and two different listings carry the same scoring
- * RULE over their own option values (#5036 D4).
- *
- * The configs the projection builds are asserted against the REAL
- * `flowConfigSchema` / `waitlistExperimentConfigSchema` as they arrive at the
- * (mocked) Prisma upsert, so a projection that could not actually persist
- * fails here rather than at approve time.
- *
- * External dependency boundaries mocked: @working-theory/database (auto-mock
- * via `../../lib/__mocks__/prisma.ts`), plus the same
- * `@working-theory/email` / `@working-theory/license` / `../aeo-score.js`
- * boundary mocks `waitlist-experiments.test.ts` uses — this service composes
- * `upsertFlowDefinition` from `flow-engine.ts`, whose import chain reaches all
- * three.
- */
-// 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 { buildListingDiagnosticScoring } from "@working-theory/database/flows/listing-diagnostic";
-import {
-  flowConfigSchema,
-  projectListingQuestionsSchema,
-  waitlistExperimentConfigSchema,
-  type FlowConfig,
-  type ProjectListingQuestions,
-} from "@working-theory/validation";
-
-import { prisma } from "../../lib/prisma.js";
-import {
-  generateListingFlow,
-  listingAnswerLabels,
-  listingWaitlistKey,
-  type ListingFlowSource,
-} from "../project-listing-flow";
-
-const SITE_ID = "site-abc";
-
-/**
- * The template default (#4998's `projectListingQuestionsSchema`): Q2's
- * founder options terminated by the fixed `just-curious` bail-out, Q3/Q4 at
- * four founder options each, Q5's three fixed urgency values, Q6's four fixed
- * bands, Q7 wording only, no extras.
- */
-const TEMPLATE_DEFAULT: ProjectListingQuestions = projectListingQuestionsSchema.parse({
-  q2: {
-    prompt: "What brings you here?",
-    options: [
-      { value: "shipping-now", label: "I'm shipping something now" },
-      { value: "planning", label: "I'm planning a build" },
-      { value: "just-curious", label: "Just curious" },
-    ],
-  },
-  q3: {
-    prompt: "How painful is this problem today?",
-    options: [
-      { value: "none", label: "Not a problem" },
-      { value: "mild", label: "Mildly annoying" },
-      { value: "real", label: "A real drag" },
-      { value: "blocking", label: "It's blocking me" },
-    ],
-  },
-  q4: {
-    prompt: "How close is this to what you need?",
-    options: [
-      { value: "off", label: "Not what I need" },
-      { value: "adjacent", label: "Adjacent" },
-      { value: "close", label: "Close" },
-      { value: "exact", label: "Exactly it" },
-    ],
-  },
-  q5: {
-    prompt: "When would you use this?",
-    options: [
-      { value: "urgent", label: "Right away" },
-      { value: "planning", label: "Next quarter" },
-      { value: "exploring", label: "Just looking" },
-    ],
-  },
-  q6: {
-    prompt: "What would you pay?",
-    options: [
-      { value: "low", label: "Nothing yet" },
-      { value: "medium", label: "A little" },
-      { value: "high", label: "A real budget" },
-      { value: "critical", label: "Whatever it takes" },
-    ],
-  },
-  q7: { prompt: "Anything else we should know?" },
-  extras: [],
-});
-
-function listing(overrides: Partial<ListingFlowSource> = {}): ListingFlowSource {
-  return {
-    id: "prjl_1",
-    siteId: SITE_ID,
-    slug: "orbit-notes",
-    name: "Orbit Notes",
-    oneLiner: "Meeting notes that file themselves.",
-    questions: TEMPLATE_DEFAULT,
-    ...overrides,
-  };
-}
-
-/** The `FlowConfig` handed to `flowDefinition.upsert`, as it was persisted. */
-function upsertedFlow(): FlowConfig {
-  const call = (prisma.flowDefinition.upsert as jest.Mock).mock.calls[0]?.[0];
-  return call.create.config as FlowConfig;
-}
-
-/** The experiment config handed to `waitlistExperiment.upsert`. */
-function upsertedExperiment(): Record<string, unknown> {
-  const call = (prisma.waitlistExperiment.upsert as jest.Mock).mock.calls[0]?.[0];
-  return call.create.config as Record<string, unknown>;
-}
-
-beforeEach(() => {
-  jest.clearAllMocks();
-  process.env.DATABASE_URL = "postgres://test";
-  (prisma.flowDefinition.upsert as jest.Mock).mockResolvedValue({ id: "flow_1" });
-  (prisma.waitlistExperiment.upsert as jest.Mock).mockResolvedValue({ id: "wlexp_1" });
-  (prisma.projectListing.update as jest.Mock).mockResolvedValue({ id: "prjl_1" });
-});
-
-describe("generateListingFlow — the flow (#5001 AC1)", () => {
-  // #5036 D6d: the write-back is the experiment's KEY, and the key IS the
-  // listing's slug (`buildExperimentConfig`). Storing the id meant a reader
-  // going from a listing to its `WaitlistScore` rows had to fetch the
-  // experiment first purely to learn that key; storing the key is one hop and
-  // the same string on both sides of the join.
-  it("writes a servable flow, a live experiment, and the row's experimentKey", async () => {
-    const result = await generateListingFlow(listing());
-
-    expect(result).toEqual({
-      ok: true,
-      flowSlug: "orbit-notes",
-      experimentKey: "orbit-notes",
-    });
-    expect(prisma.projectListing.update).toHaveBeenCalledWith({
-      where: { id: "prjl_1" },
-      data: { experimentKey: "orbit-notes" },
-    });
-    expect(
-      (prisma.flowDefinition.upsert as jest.Mock).mock.calls[0]?.[0].where,
-    ).toEqual({ siteId_slug: { siteId: SITE_ID, slug: "orbit-notes" } });
-    expect(
-      (prisma.waitlistExperiment.upsert as jest.Mock).mock.calls[0]?.[0].where,
-    ).toEqual({ siteId_key: { siteId: SITE_ID, key: "orbit-notes" } });
-  });
-
-  it("declares the six-category step order, then the confirmation", async () => {
-    await generateListingFlow(listing());
-
-    expect(upsertedFlow().steps.map((s) => s.key)).toEqual([
-      "contact",
-      "segment",
-      "problem",
-      "fit",
-      "urgency",
-      "price",
-      "open",
-      "done",
-    ]);
-  });
-
-  it("appends an extras step only when the row carries extras", async () => {
-    const questions = projectListingQuestionsSchema.parse({
-      ...TEMPLATE_DEFAULT,
-      extras: [
-        {
-          prompt: "Which stack?",
-          options: [
-            { value: "a", label: "TypeScript" },
-            { value: "b", label: "Python" },
-          ],
-        },
-      ],
-    });
-
-    await generateListingFlow(listing({ questions }));
-
-    const steps = upsertedFlow().steps;
-    expect(steps.map((s) => s.key)).toEqual([
-      "contact",
-      "segment",
-      "problem",
-      "fit",
-      "urgency",
-      "price",
-      "open",
-      "extras",
-      "done",
-    ]);
-    const extras = steps.find((s) => s.key === "extras");
-    expect(extras?.type).toBe("field");
-    if (extras?.type !== "field") throw new Error("extras step must be a field step");
-    expect(extras.fields.map((f) => f.name)).toEqual(["extra_1"]);
-    expect(extras.fields[0]?.options?.map((o) => o.value)).toEqual(["x1:0of2", "x1:1of2"]);
-  });
-
-  it("renders a scored question under the founder's OWN values, in order (#5036 D4)", async () => {
-    await generateListingFlow(listing());
-
-    const problem = upsertedFlow().steps.find((s) => s.key === "problem");
-    if (problem?.type !== "field") throw new Error("problem step must be a field step");
-    expect(problem.fields[0]?.options).toEqual([
-      { value: "none", label: { en: "Not a problem" } },
-      { value: "mild", label: { en: "Mildly annoying" } },
-      { value: "real", label: { en: "A real drag" } },
-      { value: "blocking", label: { en: "It's blocking me" } },
-    ]);
-  });
-
-  it("keeps Q2's founder values and pins `just-curious` LAST", async () => {
-    await generateListingFlow(listing());
-
-    const segment = upsertedFlow().steps.find((s) => s.key === "segment");
-    if (segment?.type !== "field") throw new Error("segment step must be a field step");
-    const values = segment.fields[0]?.options?.map((o) => o.value) ?? [];
-    expect(values).toEqual(["shipping-now", "planning", "just-curious"]);
-    expect(values[values.length - 1]).toBe("just-curious");
-  });
-
-  it("makes Q7 an optional textarea", async () => {
-    await generateListingFlow(listing());
-
-    const open = upsertedFlow().steps.find((s) => s.key === "open");
-    if (open?.type !== "field") throw new Error("open step must be a field step");
-    expect(open.fields[0]?.inputType).toBe("textarea");
-    expect(open.fields[0]?.required).toBeUndefined();
-  });
-
-  it("binds the flow to its experiment so completion scores", async () => {
-    await generateListingFlow(listing());
-
-    expect(upsertedFlow().experiment).toEqual({
-      key: "orbit-notes",
-      waitlist: "listing_orbit_notes",
-    });
-  });
-
-  it("persists a config that validates against flowConfigSchema", async () => {
-    await generateListingFlow(listing());
-
-    expect(flowConfigSchema.safeParse(upsertedFlow()).success).toBe(true);
-  });
-});
-
-describe("generateListingFlow — the thank-you (#5001 AC2)", () => {
-  it("shows the confirmation line and the founder's own line, never the tier", async () => {
-    await generateListingFlow(listing());
-
-    const flow = upsertedFlow();
-    const done = flow.steps[flow.steps.length - 1];
-    expect(done?.type).toBe("message");
-    expect(done?.copy).toEqual({
-      title: { en: "You're on the Orbit Notes waitlist" },
-      body: { en: "Meeting notes that file themselves." },
-    });
-
-    // No tier vocabulary anywhere on the visitor's path, and no thankYou /
-    // deliverables block that could route one in.
-    const serialized = JSON.stringify(flow);
-    for (const tier of ["now", "soon", "later", "curious"]) {
-      expect(serialized).not.toContain(`"${tier}"`);
-    }
-    expect(flow.thankYou).toBeUndefined();
-    expect(flow.deliverables).toBeUndefined();
-    expect(flow.scoring).toBeUndefined();
-  });
-
-  it("omits the body when the founder's line is blank", async () => {
-    await generateListingFlow(listing({ oneLiner: "   " }));
-
-    const flow = upsertedFlow();
-    const done = flow.steps[flow.steps.length - 1];
-    expect(done?.copy).toEqual({ title: { en: "You're on the Orbit Notes waitlist" } });
-  });
-});
-
-describe("generateListingFlow — the experiment (#5001 AC1/AC3)", () => {
-  it("is a live, qualifying experiment keyed by the listing slug", async () => {
-    await generateListingFlow(listing());
-
-    const config = upsertedExperiment();
-    expect(config.key).toBe("orbit-notes");
-    expect(config.mode).toBe("qualifying");
-    expect(config.status).toBe("live");
-    expect(config.waitlists).toEqual([
-      { key: "listing_orbit_notes", flowSlug: "orbit-notes" },
-    ]);
-  });
-
-  it("carries the register the shared rule builds for THIS listing", async () => {
-    await generateListingFlow(listing());
-
-    // Deep, not identity: `upsertWaitlistExperiment` persists Zod's parsed
-    // clone, so the register arrives as a structural copy of what
-    // `buildListingDiagnosticScoring` returns for this row's questions.
-    expect(upsertedExperiment().scoring).toEqual(
-      buildListingDiagnosticScoring(TEMPLATE_DEFAULT),
-    );
-  });
-
-  it("declares each scored question's OWN options in the question set (#5036 D4)", async () => {
-    await generateListingFlow(listing());
-
-    const questionSet = upsertedExperiment().questionSet as {
-      questions: { id: string; options?: { value: string }[] }[];
-    };
-    const q3 = questionSet.questions.find((q) => q.id === "q3");
-    expect(q3?.options?.map((o) => o.value)).toEqual(["none", "mild", "real", "blocking"]);
-
-    // Which is what makes the weights keys legal at the config level — the
-    // finite `q{n}:{i}of{k}` value universe the old shared constant forced
-    // the question set to declare is gone.
-    const scoring = upsertedExperiment().scoring as {
-      points: { question: string; weights: Record<string, number> }[];
-    };
-    expect(scoring.points.find((p) => p.question === "q3")?.weights).toEqual({
-      none: 0,
-      mild: 1,
-      real: 2,
-      blocking: 3,
-    });
-  });
-
-  it("persists a config that validates against waitlistExperimentConfigSchema", async () => {
-    await generateListingFlow(listing());
-
-    const parsed = waitlistExperimentConfigSchema.safeParse(upsertedExperiment());
-    expect(parsed.success).toBe(true);
-  });
-
-  it("gives two DIFFERENT listings the same scoring RULE (AC3, #5036 D4)", async () => {
-    await generateListingFlow(listing());
-    const first = upsertedExperiment().scoring as Record<string, unknown>;
-
-    jest.clearAllMocks();
-    (prisma.flowDefinition.upsert as jest.Mock).mockResolvedValue({ id: "flow_2" });
-    (prisma.waitlistExperiment.upsert as jest.Mock).mockResolvedValue({ id: "wlexp_2" });
-    (prisma.projectListing.update as jest.Mock).mockResolvedValue({ id: "prjl_2" });
-
-    // A second listing with DIFFERENT wording AND a different Q3 arity.
-    const otherQuestions = projectListingQuestionsSchema.parse({
-      ...TEMPLATE_DEFAULT,
-      q3: {
-        prompt: "How badly does this hurt?",
-        options: [
-          { value: "x", label: "Not at all" },
-          { value: "y", label: "Somewhat" },
-          { value: "z", label: "Badly" },
-        ],
-      },
-    });
-    await generateListingFlow(
-      listing({ id: "prjl_2", slug: "ledger-lite", name: "Ledger Lite", questions: otherQuestions }),
-    );
-
-    const second = upsertedExperiment().scoring as Record<string, unknown>;
-
-    // Same shape, same ladder, same 0-12 range — only the founder-authored
-    // Q3/Q4 weight KEYS differ, because since #5036 D4 those keys are the
-    // founder's own option values rather than positional tokens.
-    expect(second.scores).toEqual(first.scores);
-    expect(second.tiers).toEqual(first.tiers);
-    expect(second.default).toEqual(first.default);
-    const names = (s: Record<string, unknown>) =>
-      (s.points as { name: string }[]).map((p) => p.name);
-    expect(names(second)).toEqual(names(first));
-    const weights = (s: Record<string, unknown>, question: string) =>
-      (s.points as { question: string; weights: Record<string, number> }[]).find(
-        (p) => p.question === question,
-      )?.weights;
-    expect(weights(second, "q5")).toEqual(weights(first, "q5"));
-    expect(weights(second, "q6")).toEqual(weights(first, "q6"));
-    expect(weights(second, "q3")).toEqual({ x: 0, y: 2, z: 3 });
-    expect(weights(second, "q3")).not.toEqual(weights(first, "q3"));
-  });
-});
-
-describe("generateListingFlow — idempotency + failure", () => {
-  it("re-approving upserts the same keys and rewrites the same experimentKey", async () => {
-    await generateListingFlow(listing());
-    await generateListingFlow(listing());
-
-    const flowCalls = (prisma.flowDefinition.upsert as jest.Mock).mock.calls;
-    const experimentCalls = (prisma.waitlistExperiment.upsert as jest.Mock).mock.calls;
-    expect(flowCalls).toHaveLength(2);
-    expect(flowCalls[0]?.[0]).toEqual(flowCalls[1]?.[0]);
-    expect(experimentCalls[0]?.[0]).toEqual(experimentCalls[1]?.[0]);
-    expect(prisma.projectListing.update).toHaveBeenNthCalledWith(2, {
-      where: { id: "prjl_1" },
-      data: { experimentKey: "orbit-notes" },
-    });
-  });
-
-  it("refuses a slug the flow grammar rejects, and writes nothing", async () => {
-    // A listing slug may carry a doubled hyphen (#4998's `^[a-z0-9-]{3,48}$`);
-    // `flowSlugSchema` may not.
-    const result = await generateListingFlow(listing({ slug: "orbit--notes" }));
-
-    expect(result.ok).toBe(false);
-    if (result.ok) throw new Error("expected a rejected slug");
-    expect(result.error.kind).toBe("invalid_input");
-    expect(prisma.waitlistExperiment.upsert).not.toHaveBeenCalled();
-    expect(prisma.projectListing.update).not.toHaveBeenCalled();
-  });
-});
-
-describe("listingWaitlistKey", () => {
-  it("prefixes so a digit-leading slug still yields a legal identifier", () => {
-    expect(listingWaitlistKey("3d-printer")).toBe("listing_3d_printer");
-  });
-});
-
-describe("listingAnswerLabels — the CSV's inverse", () => {
-  it("maps every emitted value back to the founder's own wording", () => {
-    const labels = listingAnswerLabels(TEMPLATE_DEFAULT);
-
-    // Q2-Q6 are all plain value->label now: the flow renders the founder's
-    // own values, so the inverse is their own option list read backwards.
-    expect(labels.q3?.blocking).toBe("It's blocking me");
-    expect(labels.q5?.urgent).toBe("Right away");
-    expect(labels.q6?.critical).toBe("Whatever it takes");
-    expect(labels.q2?.["just-curious"]).toBe("Just curious");
-  });
-
-  it("keeps the positional encoding for the unscored extras", () => {
-    const questions = projectListingQuestionsSchema.parse({
-      ...TEMPLATE_DEFAULT,
-      extras: [
-        {
-          prompt: "Which stack?",
-          options: [
-            { value: "a", label: "TypeScript" },
-            { value: "b", label: "Python" },
-          ],
-        },
-      ],
-    });
-
-    expect(listingAnswerLabels(questions).extra_1).toEqual({
-      "x1:0of2": "TypeScript",
-      "x1:1of2": "Python",
-    });
-  });
-});