create-ailk 0.1.0 → 0.2.0

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

@@ -0,0 +1,567 @@
+/**
+ * @file waitlist-followup.test.ts
+ * @description Unit tests for the waitlist follow-up-sequence sweep service
+ * (#4732).
+ *
+ * External dependency boundaries mocked:
+ *   - @working-theory/database (via moduleNameMapper → prisma-client.js mock; prisma singleton via __mocks__/prisma.ts)
+ *   - @working-theory/email sendAbandonEmail + getResendClient
+ *   - @working-theory/observability logger
+ */
+
+// 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");
+
+const mockSendAbandonEmail = jest.fn();
+const mockContactsGet = jest.fn();
+jest.mock("@working-theory/email", () => ({
+  sendAbandonEmail: (...args: unknown[]) => mockSendAbandonEmail(...args),
+  getResendClient: () => ({ contacts: { get: (...args: unknown[]) => mockContactsGet(...args) } }),
+}));
+
+const mockLoggerInfo = jest.fn();
+const mockLoggerWarn = jest.fn();
+const mockLoggerError = jest.fn();
+jest.mock("@working-theory/observability", () => ({
+  logger: {
+    info: (...args: unknown[]) => mockLoggerInfo(...args),
+    warn: (...args: unknown[]) => mockLoggerWarn(...args),
+    error: (...args: unknown[]) => mockLoggerError(...args),
+    debug: jest.fn(),
+  },
+}));
+
+import { prisma } from "../../lib/prisma.js";
+import { runWaitlistFollowUpSweep } from "../waitlist-followup";
+
+// ─── Fixtures ─────────────────────────────────────────────────────────────────
+
+const en = (s: string) => ({ en: s });
+
+const SITE_ID = "site-abc";
+const DEFINITION_ID = "flow_00000000-0000-7000-8000-0000000000f1";
+const NOW = new Date("2026-09-04T12:00:00.000Z");
+
+const FOLLOW_UP_ENTRY = {
+  key: "t_plus_3d_hot_warm",
+  offsetDays: 3,
+  tiers: ["hot", "warm"],
+  copy: {
+    subject: en("Ready to talk through your results?"),
+    body: en("Grab 20 minutes on our calendar."),
+  },
+  cta: { label: en("Book a walkthrough"), href: "https://example.com/book" },
+};
+
+// The full four-entry register (mirrors packages/validation's
+// ailk-founder-diagnostic.fixture.ts `followUps` export, D6) — used only by
+// the AC-3 multi-tier selection test below, which is the one test that needs
+// the cross-product of offsets and tiers to have any discriminating power.
+const FULL_FOLLOW_UPS_REGISTER = [
+  FOLLOW_UP_ENTRY, // t_plus_3d_hot_warm — offsetDays 3, tiers [hot, warm]
+  {
+    key: "t_plus_3d_product",
+    offsetDays: 3,
+    tiers: ["product"],
+    copy: {
+      subject: en("A closer look at your weakest dimension"),
+      body: en("Here's a deeper breakdown of the one area holding you back."),
+    },
+  },
+  {
+    key: "t_plus_10d",
+    offsetDays: 10,
+    tiers: ["hot", "warm", "product", "watching"],
+    copy: {
+      subject: en("What we're seeing across founder sites"),
+      body: en("A quick look at how sites like yours are scoring."),
+    },
+  },
+  {
+    key: "t_plus_21d",
+    offsetDays: 21,
+    tiers: ["hot", "warm"],
+    copy: {
+      subject: en("Still interested in fixing this?"),
+      body: en("The offer we mentioned is still open."),
+    },
+  },
+];
+
+function flowDefRow(overrides: Partial<{ followUps: unknown }> = {}) {
+  return {
+    id: DEFINITION_ID,
+    siteId: SITE_ID,
+    slug: "ailk-founder-diagnostic",
+    config: {
+      slug: "ailk-founder-diagnostic",
+      defaultLocale: "en",
+      steps: [
+        {
+          key: "contact",
+          type: "field",
+          copy: { title: en("Let's get started") },
+          fields: [
+            {
+              name: "email",
+              inputType: "email",
+              required: true,
+              mapsTo: "email",
+              copy: { label: en("Email") },
+            },
+          ],
+        },
+      ],
+      ...("followUps" in overrides
+        ? { followUps: overrides.followUps }
+        : { followUps: [FOLLOW_UP_ENTRY] }),
+    },
+  };
+}
+
+function sessionRow(overrides: Partial<Record<string, unknown>> = {}) {
+  return {
+    id: "flsess_00000000-0000-7000-8000-0000000000c1",
+    siteId: SITE_ID,
+    flowSlug: "ailk-founder-diagnostic",
+    leadId: "lead_00000000-0000-7000-8000-0000000000a1",
+    email: "lead@example.com",
+    locale: null,
+    completedAt: new Date("2026-09-01T00:00:00.000Z"), // 3 days before NOW — due for offsetDays:3
+    ...overrides,
+  };
+}
+
+describe("runWaitlistFollowUpSweep", () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    process.env = { ...originalEnv };
+    process.env.DATABASE_URL = "postgres://stub";
+    delete process.env.RESEND_AUDIENCE_ID;
+    process.env.AILK_FOLLOWUP_EMAIL_FROM = "followup@example.com";
+
+    mockSendAbandonEmail.mockResolvedValue({ ok: true, messageId: "msg-1" });
+    (prisma.flowDefinition.findMany as jest.Mock).mockResolvedValue([flowDefRow()]);
+    (prisma.flowSession.findMany as jest.Mock).mockResolvedValue([sessionRow()]);
+    (prisma.waitlistScore.findMany as jest.Mock).mockResolvedValue([
+      { leadId: "lead_00000000-0000-7000-8000-0000000000a1", tier: "hot" },
+    ]);
+    (prisma.callback.findMany as jest.Mock).mockResolvedValue([]);
+    (prisma.waitlistFollowUpSend.findMany as jest.Mock).mockResolvedValue([]);
+    (prisma.waitlistFollowUpSend.create as jest.Mock).mockResolvedValue({ id: "wlfu_1" });
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  // ── DB required ──────────────────────────────────────────────────────────
+
+  it("returns flows_not_configured when DATABASE_URL is unset", async () => {
+    delete process.env.DATABASE_URL;
+    const result = await runWaitlistFollowUpSweep();
+    expect(result).toEqual({
+      ok: false,
+      error: { kind: "flows_not_configured", message: expect.any(String) },
+    });
+    expect(prisma.flowDefinition.findMany).not.toHaveBeenCalled();
+  });
+
+  // ── AC-3 — due-tier send ─────────────────────────────────────────────────
+
+  it("sends a due candidate whose tier matches the entry, through sendAbandonEmail, and stamps the send", async () => {
+    const result = await runWaitlistFollowUpSweep({ now: NOW });
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.summary.sent).toBe(1);
+    expect(result.summary.suppressed).toBe(0);
+    expect(result.summary.skipped).toBe(0);
+
+    expect(mockSendAbandonEmail).toHaveBeenCalledWith({
+      to: "lead@example.com",
+      fromAddress: "followup@example.com",
+      subject: "Ready to talk through your results?",
+      body: "Grab 20 minutes on our calendar.",
+      cta: "Book a walkthrough",
+      resumeLink: "https://example.com/book",
+    });
+
+    expect(prisma.waitlistFollowUpSend.create).toHaveBeenCalledWith({
+      data: {
+        siteId: SITE_ID,
+        leadId: "lead_00000000-0000-7000-8000-0000000000a1",
+        followUpKey: "t_plus_3d_hot_warm",
+        sentAt: NOW,
+        status: "sent",
+      },
+    });
+  });
+
+  // ── code-review + acceptance-review round 1 finding: a concurrent
+  // overlapping sweep run racing the SAME (leadId, followUpKey) stamp must
+  // not abort the WHOLE sweep — only that one row's write raced ────────────
+
+  it("a P2002 unique-constraint violation on the stamp write (a concurrent overlapping run) is swallowed, logged, and does not abort the sweep", async () => {
+    (prisma.waitlistFollowUpSend.create as jest.Mock).mockRejectedValue(
+      Object.assign(new Error("Unique constraint failed"), { code: "P2002" }),
+    );
+
+    const result = await runWaitlistFollowUpSweep({ now: NOW });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.summary.sent).toBe(1);
+
+    expect(mockLoggerWarn).toHaveBeenCalledWith(
+      expect.objectContaining({ followUpKey: "t_plus_3d_hot_warm" }),
+      expect.stringContaining("P2002"),
+    );
+  });
+
+  it("any OTHER stamp-write error (not P2002) still propagates as unexpected_error", async () => {
+    (prisma.waitlistFollowUpSend.create as jest.Mock).mockRejectedValue(
+      new Error("connection reset"),
+    );
+
+    const result = await runWaitlistFollowUpSweep({ now: NOW });
+    expect(result).toEqual({
+      ok: false,
+      error: { kind: "unexpected_error", message: "connection reset" },
+    });
+  });
+
+  it("stamps status:'failed' when sendAbandonEmail returns ok:false, and still counts it", async () => {
+    mockSendAbandonEmail.mockResolvedValue({
+      ok: false,
+      error: { kind: "send_failed", message: "Resend down" },
+    });
+
+    const result = await runWaitlistFollowUpSweep({ now: NOW });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.summary.failed).toBe(1);
+    expect(result.summary.sent).toBe(0);
+
+    expect(prisma.waitlistFollowUpSend.create).toHaveBeenCalledWith(
+      expect.objectContaining({ data: expect.objectContaining({ status: "failed" }) }),
+    );
+  });
+
+  // ── AC-4 — wrong-tier skip ───────────────────────────────────────────────
+
+  it("skips a candidate whose tier is not in the entry's tiers[], with no send and no stamp", async () => {
+    (prisma.waitlistScore.findMany as jest.Mock).mockResolvedValue([
+      { leadId: "lead_00000000-0000-7000-8000-0000000000a1", tier: "product" },
+    ]);
+
+    const result = await runWaitlistFollowUpSweep({ now: NOW });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.summary.skipped).toBe(1);
+    expect(result.summary.sent).toBe(0);
+
+    expect(mockSendAbandonEmail).not.toHaveBeenCalled();
+    expect(prisma.waitlistFollowUpSend.create).not.toHaveBeenCalled();
+    expect(mockLoggerInfo).toHaveBeenCalledWith(
+      expect.objectContaining({ outcome: "wrong_tier" }),
+      expect.any(String),
+    );
+  });
+
+  // ── AC-4 — not-yet-due skip ──────────────────────────────────────────────
+
+  it("skips a candidate whose completedAt + offsetDays > now, with no send and no stamp", async () => {
+    (prisma.flowSession.findMany as jest.Mock).mockResolvedValue([
+      sessionRow({ completedAt: new Date("2026-09-03T00:00:00.000Z") }), // 1 day before NOW — not yet due for offsetDays:3
+    ]);
+
+    const result = await runWaitlistFollowUpSweep({ now: NOW });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.summary.skipped).toBe(1);
+    expect(result.summary.sent).toBe(0);
+
+    expect(mockSendAbandonEmail).not.toHaveBeenCalled();
+    expect(prisma.waitlistFollowUpSend.create).not.toHaveBeenCalled();
+    expect(mockLoggerInfo).toHaveBeenCalledWith(
+      expect.objectContaining({ outcome: "not_due" }),
+      expect.any(String),
+    );
+  });
+
+  // ── AC-3 — idempotency: running twice sends zero additional emails ──────
+
+  it("running the sweep twice over the same fixtures sends zero additional emails the second time", async () => {
+    const first = await runWaitlistFollowUpSweep({ now: NOW });
+    expect(first.ok).toBe(true);
+    if (!first.ok) return;
+    expect(first.summary.sent).toBe(1);
+
+    // The second run's dedup query now reflects the first run's stamp.
+    (prisma.waitlistFollowUpSend.findMany as jest.Mock).mockResolvedValue([
+      { leadId: "lead_00000000-0000-7000-8000-0000000000a1" },
+    ]);
+    mockSendAbandonEmail.mockClear();
+
+    const second = await runWaitlistFollowUpSweep({ now: NOW });
+    expect(second.ok).toBe(true);
+    if (!second.ok) return;
+    expect(second.summary.sent).toBe(0);
+    expect(mockSendAbandonEmail).not.toHaveBeenCalled();
+  });
+
+  // ── AC-4 — Callback-suppressed skip ──────────────────────────────────────
+
+  it("skips a candidate whose email matches a Callback.payload.email (case-insensitive), with no send and no stamp", async () => {
+    (prisma.callback.findMany as jest.Mock).mockResolvedValue([
+      { payload: { email: "LEAD@example.com" } },
+    ]);
+
+    const result = await runWaitlistFollowUpSweep({ now: NOW });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.summary.suppressed).toBe(1);
+    expect(result.summary.sent).toBe(0);
+
+    expect(mockSendAbandonEmail).not.toHaveBeenCalled();
+    expect(prisma.waitlistFollowUpSend.create).not.toHaveBeenCalled();
+    expect(mockLoggerInfo).toHaveBeenCalledWith(
+      expect.objectContaining({ outcome: "callback_suppressed" }),
+      expect.any(String),
+    );
+  });
+
+  // ── AC-4 — Resend-unsubscribed skip ──────────────────────────────────────
+
+  it("skips a candidate the mocked Resend Contacts client reports unsubscribed:true, with no send and no stamp", async () => {
+    process.env.RESEND_AUDIENCE_ID = "aud_123";
+    mockContactsGet.mockResolvedValue({
+      data: { id: "c1", email: "lead@example.com", unsubscribed: true },
+      error: null,
+    });
+
+    const result = await runWaitlistFollowUpSweep({ now: NOW });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.summary.suppressed).toBe(1);
+    expect(result.summary.sent).toBe(0);
+
+    expect(mockContactsGet).toHaveBeenCalledWith({
+      email: "lead@example.com",
+      audienceId: "aud_123",
+    });
+    expect(mockSendAbandonEmail).not.toHaveBeenCalled();
+    expect(prisma.waitlistFollowUpSend.create).not.toHaveBeenCalled();
+    expect(mockLoggerInfo).toHaveBeenCalledWith(
+      expect.objectContaining({ outcome: "unsubscribed" }),
+      expect.any(String),
+    );
+  });
+
+  it("a 404/not-found Resend Contacts response is treated as NOT unsubscribed — the send proceeds", async () => {
+    process.env.RESEND_AUDIENCE_ID = "aud_123";
+    mockContactsGet.mockResolvedValue({
+      data: null,
+      error: { statusCode: 404, message: "not_found", name: "not_found" },
+    });
+
+    const result = await runWaitlistFollowUpSweep({ now: NOW });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.summary.sent).toBe(1);
+    expect(mockSendAbandonEmail).toHaveBeenCalled();
+  });
+
+  it("any other Resend Contacts API error skips the send this run WITHOUT stamping", async () => {
+    process.env.RESEND_AUDIENCE_ID = "aud_123";
+    mockContactsGet.mockResolvedValue({
+      data: null,
+      error: { statusCode: 500, message: "internal_error", name: "internal_server_error" },
+    });
+
+    const result = await runWaitlistFollowUpSweep({ now: NOW });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.summary.sent).toBe(0);
+    expect(result.summary.skipped).toBe(1);
+    expect(mockSendAbandonEmail).not.toHaveBeenCalled();
+    expect(prisma.waitlistFollowUpSend.create).not.toHaveBeenCalled();
+  });
+
+  // ── AC-5 — RESEND_AUDIENCE_ID unset → proceeds, guarded BEFORE the call ──
+
+  it("with RESEND_AUDIENCE_ID unset, sends a due, otherwise non-suppressed candidate without ever calling contacts.get at all", async () => {
+    expect(process.env.RESEND_AUDIENCE_ID).toBeUndefined();
+
+    const result = await runWaitlistFollowUpSweep({ now: NOW });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.summary.sent).toBe(1);
+
+    expect(mockContactsGet).not.toHaveBeenCalled();
+  });
+
+  // ── D5 — malformed stored config → skip-and-log, never throws ───────────
+
+  it("skips a flow whose stored config fails schema validation, logging a warning, without aborting the sweep", async () => {
+    (prisma.flowDefinition.findMany as jest.Mock).mockResolvedValue([
+      { id: DEFINITION_ID, siteId: SITE_ID, slug: "broken-flow", config: { not: "a valid flow config" } },
+    ]);
+
+    const result = await runWaitlistFollowUpSweep({ now: NOW });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.summary.sent).toBe(0);
+    expect(mockLoggerWarn).toHaveBeenCalledWith(
+      expect.objectContaining({ siteId: SITE_ID, flowSlug: "broken-flow" }),
+      expect.stringContaining("failed schema validation"),
+    );
+    expect(prisma.flowSession.findMany).not.toHaveBeenCalled();
+  });
+
+  it("never selects a session on a flow with no followUps block", async () => {
+    (prisma.flowDefinition.findMany as jest.Mock).mockResolvedValue([
+      flowDefRow({ followUps: undefined }),
+    ]);
+
+    const result = await runWaitlistFollowUpSweep({ now: NOW });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.summary.scanned).toBe(0);
+    expect(prisma.flowSession.findMany).not.toHaveBeenCalled();
+  });
+
+  // ── sender_unconfigured — env gap must not consume the one send ─────────
+
+  it("leaves the candidate unstamped when no from-address is configured", async () => {
+    delete process.env.AILK_FOLLOWUP_EMAIL_FROM;
+    delete process.env.AILK_LEAD_NOTIFICATION_FROM;
+
+    const result = await runWaitlistFollowUpSweep({ now: NOW });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.summary.skipped).toBe(1);
+    expect(mockSendAbandonEmail).not.toHaveBeenCalled();
+    expect(prisma.waitlistFollowUpSend.create).not.toHaveBeenCalled();
+  });
+
+  // ── unexpected mid-run failure degrades to a structured error ───────────
+
+  it("returns unexpected_error and logs the partial summary on a mid-sweep throw", async () => {
+    (prisma.flowSession.findMany as jest.Mock).mockRejectedValue(new Error("db down"));
+
+    const result = await runWaitlistFollowUpSweep({ now: NOW });
+    expect(result).toEqual({
+      ok: false,
+      error: { kind: "unexpected_error", message: "db down" },
+    });
+    expect(mockLoggerError).toHaveBeenCalled();
+  });
+
+  // ── AC-3 — multi-tier, multi-entry selection (acceptance-review round 1
+  // finding: a single-entry, single-tier fixture cannot demonstrate the
+  // cross-product of offsets and tiers actually composes correctly) ───────
+
+  describe("multi-tier selection over the full four-entry register", () => {
+    const LEAD_HOT = "lead_00000000-0000-7000-8000-00000000000h";
+    const LEAD_WARM = "lead_00000000-0000-7000-8000-00000000000w";
+    const LEAD_PRODUCT = "lead_00000000-0000-7000-8000-00000000000p";
+    const LEAD_WATCHING = "lead_00000000-0000-7000-8000-00000000000v";
+
+    function daysAgo(n: number): Date {
+      return new Date(NOW.getTime() - n * 24 * 60 * 60 * 1000);
+    }
+
+    function multiTierSessions() {
+      return [
+        sessionRow({ leadId: LEAD_HOT, email: "hot@example.com", completedAt: daysAgo(25) }),
+        sessionRow({ leadId: LEAD_WARM, email: "warm@example.com", completedAt: daysAgo(12) }),
+        sessionRow({ leadId: LEAD_PRODUCT, email: "product@example.com", completedAt: daysAgo(5) }),
+        sessionRow({ leadId: LEAD_WATCHING, email: "watching@example.com", completedAt: daysAgo(1) }),
+      ];
+    }
+
+    // The exact expected (leadId, followUpKey) pairs, derived by hand from
+    // FULL_FOLLOW_UPS_REGISTER × the four completedAt offsets above — see
+    // the acceptance-review recipe: due (offsetDays elapsed) AND tier ∈
+    // entry.tiers, both terms required.
+    //   hot      (25d ago): due for 3/10/21, tier hot ∈ every entry's tiers → 3 sends
+    //   warm     (12d ago): due for 3/10, NOT 21; tier warm ∈ both due entries → 2 sends
+    //   product  (5d ago):  due for 3 only; tier product ∈ t_plus_3d_product only → 1 send
+    //   watching (1d ago):  due for none (min offset is 3) → 0 sends
+    const EXPECTED_PAIRS = [
+      { leadId: LEAD_HOT, followUpKey: "t_plus_3d_hot_warm" },
+      { leadId: LEAD_HOT, followUpKey: "t_plus_10d" },
+      { leadId: LEAD_HOT, followUpKey: "t_plus_21d" },
+      { leadId: LEAD_WARM, followUpKey: "t_plus_3d_hot_warm" },
+      { leadId: LEAD_WARM, followUpKey: "t_plus_10d" },
+      { leadId: LEAD_PRODUCT, followUpKey: "t_plus_3d_product" },
+    ];
+
+    beforeEach(() => {
+      (prisma.flowDefinition.findMany as jest.Mock).mockResolvedValue([
+        flowDefRow({ followUps: FULL_FOLLOW_UPS_REGISTER }),
+      ]);
+      (prisma.flowSession.findMany as jest.Mock).mockResolvedValue(multiTierSessions());
+      (prisma.waitlistScore.findMany as jest.Mock).mockResolvedValue([
+        { leadId: LEAD_HOT, tier: "hot" },
+        { leadId: LEAD_WARM, tier: "warm" },
+        { leadId: LEAD_PRODUCT, tier: "product" },
+        { leadId: LEAD_WATCHING, tier: "watching" },
+      ]);
+    });
+
+    it("sends exactly the due (lead, followUpKey) pairs across all four tiers and all four register entries — not merely a matching count", async () => {
+      const result = await runWaitlistFollowUpSweep({ now: NOW });
+      expect(result.ok).toBe(true);
+      if (!result.ok) return;
+
+      expect(result.summary.sent).toBe(EXPECTED_PAIRS.length);
+      expect(mockSendAbandonEmail).toHaveBeenCalledTimes(EXPECTED_PAIRS.length);
+
+      const actualPairs = (prisma.waitlistFollowUpSend.create as jest.Mock).mock.calls.map(
+        ([{ data }]: [{ data: { leadId: string; followUpKey: string } }]) => ({
+          leadId: data.leadId,
+          followUpKey: data.followUpKey,
+        }),
+      );
+      // Set-equality, order-independent: every expected pair present, no
+      // extra pair beyond the expected set (a wrong cross-product selection
+      // — e.g. LEAD_WATCHING receiving anything, or LEAD_WARM receiving
+      // t_plus_21d — fails this even when the total count happens to match).
+      expect(actualPairs).toHaveLength(EXPECTED_PAIRS.length);
+      for (const expected of EXPECTED_PAIRS) {
+        expect(actualPairs).toContainEqual(expected);
+      }
+    });
+
+    it("running the sweep again — with per-key stamps from the first run — sends zero additional emails", async () => {
+      const first = await runWaitlistFollowUpSweep({ now: NOW });
+      expect(first.ok).toBe(true);
+      if (!first.ok) return;
+      expect(first.summary.sent).toBe(EXPECTED_PAIRS.length);
+
+      // Per-key stamps: findMany({ where: { followUpKey, leadId: {in} } })
+      // must return only the leads already stamped for THAT key — a mock
+      // returning the same leadId set for every key (as the round-1 test
+      // did) cannot discriminate once more than one entry exists.
+      (prisma.waitlistFollowUpSend.findMany as jest.Mock).mockImplementation(
+        async ({ where }: { where: { followUpKey: string } }) =>
+          EXPECTED_PAIRS.filter((p) => p.followUpKey === where.followUpKey).map((p) => ({
+            leadId: p.leadId,
+          })),
+      );
+      mockSendAbandonEmail.mockClear();
+      (prisma.waitlistFollowUpSend.create as jest.Mock).mockClear();
+
+      const second = await runWaitlistFollowUpSweep({ now: NOW });
+      expect(second.ok).toBe(true);
+      if (!second.ok) return;
+      expect(second.summary.sent).toBe(0);
+      expect(mockSendAbandonEmail).not.toHaveBeenCalled();
+      expect(prisma.waitlistFollowUpSend.create).not.toHaveBeenCalled();
+    });
+  });
+});