create-ailk 0.23.0 → 0.25.1

package/templates/apps/api/src/services/offerings/__tests__/readers.test.ts

@@ -1,681 +0,0 @@
-/**
- * services/offerings — the read services and the bounded refresh (#8876 spec
- * D7, D8, D9, D11): the typed shape (AC-3), a shown set built with no Stripe
- * call (AC-6), the 24-hour last-good copy (AC-7), the refresh bound (AC-8),
- * checkout's allowlist never reading the snapshot (AC-10) and nothing
- * leaking into a log or an error (AC-12).
- *
- * Every suite runs over `createInMemoryPrisma()` and the D9 seed, with
- * `@working-theory/stripe-client` mocked so that touching any of its exports
- * throws.
- */
-// eslint-disable-next-line no-restricted-syntax -- lib/prisma.ts wraps the external DB boundary (PrismaClient requires a live connection); the in-memory double is the repo-standard where-honouring test double for it.
-jest.mock("../../../lib/prisma.js", () =>
-  jest
-    .requireActual<typeof import("../../../__tests__/factories/in-memory-prisma")>(
-      "../../../__tests__/factories/in-memory-prisma",
-    )
-    .createInMemoryPrisma(),
-);
-
-jest.mock(
-  "@working-theory/stripe-client",
-  () =>
-    new Proxy(
-      {},
-      {
-        get: (_target, key) => {
-          if (key === "__esModule") return true;
-          throw new Error(`@working-theory/stripe-client.${String(key)} was touched`);
-        },
-      },
-    ),
-);
-
-const mockLog = jest.fn();
-jest.mock("@working-theory/observability", () => ({
-  logger: {
-    error: (...args: unknown[]) => mockLog("error", ...args),
-    warn: (...args: unknown[]) => mockLog("warn", ...args),
-    info: (...args: unknown[]) => mockLog("info", ...args),
-    debug: (...args: unknown[]) => mockLog("debug", ...args),
-  },
-}));
-
-import {
-  offeringsSnapshotSchema,
-  orgEnabledProductsSchema,
-  workspaceShownSetSchema,
-} from "@working-theory/validation";
-
-import { prisma } from "../../../lib/prisma.js";
-import {
-  LAST_GOOD_MAX_AGE_MS,
-  OfferingsShapeError,
-  OfferingsSourceError,
-  getOrgEnabledProducts,
-  getSellableProductIds,
-  getWorkspaceShownSet,
-  refreshWorkspaceSnapshot,
-  resetOfferingsRefreshStateForTests,
-  shownPriceIdsFor,
-  type OfferingsSourceFor,
-} from "../index.js";
-import {
-  EXPECTED_FIXTURE_HELD,
-  EXPECTED_FIXTURE_OFFERINGS,
-  EXPECTED_SHOWN_SET,
-  FIXTURE_CIPHERTEXT_PLACEHOLDER,
-  FIXTURE_ENABLED_PRODUCT_IDS,
-  FIXTURE_KEY_LAST4,
-  FIXTURE_NOW,
-  FIXTURE_ORG,
-  FIXTURE_ORG_2,
-  FIXTURE_ORG_2_WS,
-  FIXTURE_SHOWN_PRODUCT_IDS,
-  FIXTURE_WEBHOOK_TOKEN,
-  FIXTURE_WS,
-  FIXTURE_WS_2,
-  OFFERINGS_FIXTURE_CATALOG,
-  fixtureSourceFor,
-  refusingSourceFor,
-  seedOfferings,
-} from "./fixtures.js";
-
-type Row = Record<string, unknown>;
-// The in-memory double exposes its store and recorded delegates, which the
-// PrismaClient type the import carries does not name, so it is named here once.
-// eslint-disable-next-line no-restricted-syntax -- justified above
-const db = prisma as unknown as {
-  __db: Record<string, Row[]>;
-  workspaceOfferings: { findUnique: jest.Mock; create: (args: { data: Row }) => Promise<Row> };
-};
-
-const SECOND = 1000;
-const at = (offsetMs: number) => new Date(FIXTURE_NOW.getTime() + offsetMs);
-
-/** The keys an offering carries (D4). */
-const OFFERING_KEYS = [
-  "ailkGroup",
-  "ailkOrder",
-  "description",
-  "marketingFeatures",
-  "name",
-  "note",
-  "plan",
-  "prices",
-  "productId",
-  "recommended",
-  "termsNote",
-  "unitLabel",
-];
-const PRICE_KEYS = ["amount", "currency", "interval", "lookupKey", "period", "plan", "priceId"];
-
-function enabledRow(): Row {
-  return db.__db.organizationOfferings!.find((r) => r.organizationId === FIXTURE_ORG)!;
-}
-function offeringsRow(workspaceId = FIXTURE_WS): Row {
-  return db.__db.workspaceOfferings!.find((r) => r.workspaceId === workspaceId)!;
-}
-
-/** A `sourceFor` that answers the fixture catalog and counts each source built. */
-function countingSourceFor(answer: () => Promise<typeof OFFERINGS_FIXTURE_CATALOG> = async () =>
-  structuredClone(OFFERINGS_FIXTURE_CATALOG)) {
-  const calls: string[] = [];
-  const sourceFor: OfferingsSourceFor = (organizationId) => {
-    calls.push(organizationId);
-    return { listActiveCatalog: answer };
-  };
-  return { sourceFor, calls };
-}
-
-const rejecting = () =>
-  countingSourceFor(async () => {
-    throw new Error("upstream failed");
-  });
-
-beforeEach(async () => {
-  for (const key of Object.keys(db.__db)) delete db.__db[key];
-  mockLog.mockClear();
-  db.workspaceOfferings.findUnique.mockClear();
-  resetOfferingsRefreshStateForTests();
-  await seedOfferings(prisma, { now: FIXTURE_NOW });
-});
-
-describe("the typed shape (AC-3)", () => {
-  it("getWorkspaceShownSet answers a value its schema parses unchanged, with D4's keys", async () => {
-    const shown = await getWorkspaceShownSet(FIXTURE_WS, { now: FIXTURE_NOW });
-    expect(workspaceShownSetSchema.parse(shown)).toEqual(shown);
-    expect(shown!.offerings.length).toBeGreaterThan(0);
-    for (const offering of shown!.offerings) {
-      expect(Object.keys(offering).sort()).toEqual(OFFERING_KEYS);
-      for (const price of offering.prices) expect(Object.keys(price).sort()).toEqual(PRICE_KEYS);
-    }
-  });
-
-  it("getOrgEnabledProducts answers a value its schema parses unchanged, every recommended false", async () => {
-    const org = await getOrgEnabledProducts(FIXTURE_ORG, fixtureSourceFor, { now: FIXTURE_NOW });
-    expect(orgEnabledProductsSchema.parse(org)).toEqual(org);
-    expect(org).toEqual({
-      organizationId: FIXTURE_ORG,
-      productIds: FIXTURE_ENABLED_PRODUCT_IDS,
-      offerings: EXPECTED_FIXTURE_OFFERINGS.filter((o) => FIXTURE_ENABLED_PRODUCT_IDS.includes(o.productId)).map(
-        (o) => ({ ...o, recommended: false }),
-      ),
-      held: [],
-    });
-    for (const offering of org!.offerings) expect(Object.keys(offering).sort()).toEqual(OFFERING_KEYS);
-  });
-
-  it("getOrgEnabledProducts filters the held list to the enabled set", async () => {
-    enabledRow().enabledProductIds = ["prod_fixture_growth", "prod_fixture_legacy"];
-    const org = await getOrgEnabledProducts(FIXTURE_ORG, fixtureSourceFor, { now: FIXTURE_NOW });
-    expect(org!.offerings.map((o) => o.productId)).toEqual(["prod_fixture_growth"]);
-    expect(org!.held).toEqual(EXPECTED_FIXTURE_HELD.filter((h) => h.productId === "prod_fixture_legacy"));
-  });
-
-  it.each([
-    ["getWorkspaceShownSet", workspaceShownSetSchema, () => getWorkspaceShownSet(FIXTURE_WS, { now: FIXTURE_NOW })],
-    [
-      "getOrgEnabledProducts",
-      orgEnabledProductsSchema,
-      () => getOrgEnabledProducts(FIXTURE_ORG, fixtureSourceFor, { now: FIXTURE_NOW }),
-    ],
-  ] as const)("%s rejects with OfferingsShapeError when its schema's parse throws", async (_name, schema, read) => {
-    const spy = jest.spyOn(schema, "parse").mockImplementation(() => {
-      throw new Error("Growth prod_fixture_growth For a growing practice");
-    });
-    try {
-      const error = await read().catch((err: unknown) => err);
-      expect(error).toBeInstanceOf(OfferingsShapeError);
-      const text = JSON.stringify({ ...(error as object), message: (error as Error).message });
-      expect(text).not.toMatch(/Growth|prod_fixture|growing/);
-      expect((error as Error).cause).toBeUndefined();
-    } finally {
-      spy.mockRestore();
-    }
-  });
-});
-
-describe("a shown set with no Stripe call (AC-6)", () => {
-  it("getWorkspaceShownSet(ws1) deep-equals EXPECTED_SHOWN_SET", async () => {
-    expect(await getWorkspaceShownSet(FIXTURE_WS, { now: FIXTURE_NOW })).toEqual(EXPECTED_SHOWN_SET);
-  });
-
-  it("a product switched off at the Organization leaves the next answer, with no refresh", async () => {
-    enabledRow().enabledProductIds = FIXTURE_ENABLED_PRODUCT_IDS.filter((id) => id !== "prod_fixture_seo_audit");
-    const shown = await getWorkspaceShownSet(FIXTURE_WS, { now: FIXTURE_NOW });
-    expect(shown!.productIds).toEqual(["prod_fixture_growth", "prod_fixture_basic"]);
-    expect(shown!.offerings.map((o) => o.productId)).toEqual(["prod_fixture_basic", "prod_fixture_growth"]);
-  });
-
-  it("a product hidden by the workspace leaves the next answer too", async () => {
-    offeringsRow().shownProductIds = ["prod_fixture_basic"];
-    offeringsRow().recommendedPlanProductId = null;
-    const shown = await getWorkspaceShownSet(FIXTURE_WS, { now: FIXTURE_NOW });
-    expect(shown!.offerings.map((o) => o.productId)).toEqual(["prod_fixture_basic"]);
-  });
-
-  it("a Recommended id that is not shown answers recommended.plan null", async () => {
-    enabledRow().enabledProductIds = ["prod_fixture_basic", "prod_fixture_seo_audit"];
-    const shown = await getWorkspaceShownSet(FIXTURE_WS, { now: FIXTURE_NOW });
-    expect(shown!.recommended).toEqual({ plan: null, addon: null });
-    expect(shown!.offerings.every((o) => o.recommended === false)).toBe(true);
-  });
-
-  it("a Recommended plan id naming an add-on is not Recommended", async () => {
-    offeringsRow().recommendedPlanProductId = "prod_fixture_seo_audit";
-    offeringsRow().recommendedAddonProductId = "prod_fixture_seo_audit";
-    const shown = await getWorkspaceShownSet(FIXTURE_WS, { now: FIXTURE_NOW });
-    expect(shown!.recommended).toEqual({ plan: null, addon: "prod_fixture_seo_audit" });
-    expect(shown!.offerings.filter((o) => o.recommended).map((o) => o.productId)).toEqual([
-      "prod_fixture_seo_audit",
-    ]);
-  });
-
-  it("ws2 (same Organization, no Offerings row) answers null", async () => {
-    expect(await getWorkspaceShownSet(FIXTURE_WS_2, { now: FIXTURE_NOW })).toBeNull();
-  });
-
-  it("a workspace of an Organization with no connection answers null, even with a selection", async () => {
-    expect(offeringsRow(FIXTURE_ORG_2_WS)).toBeDefined();
-    expect(await getWorkspaceShownSet(FIXTURE_ORG_2_WS, { now: FIXTURE_NOW })).toBeNull();
-    expect(await getOrgEnabledProducts(FIXTURE_ORG_2, refusingSourceFor)).toBeNull();
-  });
-
-  it("an unreadable connection on a workspace with no Offerings row still serves nothing, never null", async () => {
-    db.__db.stripeConnection![0]!.mode = "prod";
-    expect(await getSellableProductIds(FIXTURE_WS_2)).toEqual({ organizationId: FIXTURE_ORG, productIds: [], priceIds: null });
-    expect(await getWorkspaceShownSet(FIXTURE_WS_2, { now: FIXTURE_NOW })).toMatchObject({
-      workspaceId: FIXTURE_WS_2,
-      productIds: [],
-      offerings: [],
-      state: "empty",
-    });
-  });
-
-  it("an unknown workspace answers null", async () => {
-    expect(await getWorkspaceShownSet("wksp_01920000-8876-7000-8000-0000000000ff")).toBeNull();
-  });
-
-  it("an unreadable connection serves nothing and never reads as unconnected", async () => {
-    db.__db.stripeConnection![0]!.mode = "prod";
-    expect(await getWorkspaceShownSet(FIXTURE_WS, { now: FIXTURE_NOW })).toEqual({
-      workspaceId: FIXTURE_WS,
-      organizationId: FIXTURE_ORG,
-      productIds: [],
-      recommended: { plan: null, addon: null },
-      offerings: [],
-      state: "empty",
-      snapshotAt: null,
-    });
-    expect(await getSellableProductIds(FIXTURE_WS)).toEqual({ organizationId: FIXTURE_ORG, productIds: [], priceIds: null });
-    expect(await getOrgEnabledProducts(FIXTURE_ORG, refusingSourceFor)).toEqual({
-      organizationId: FIXTURE_ORG,
-      productIds: FIXTURE_ENABLED_PRODUCT_IDS,
-      offerings: [],
-      held: [],
-    });
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS, refusingSourceFor, { now: at(61 * SECOND) })).toBe(
-      "no_connection",
-    );
-  });
-});
-
-describe("the per-Price shown set (#9070 D2, AC-4, AC-5)", () => {
-  const prices = (shown: Awaited<ReturnType<typeof getWorkspaceShownSet>>, productId: string) =>
-    shown!.offerings.find((o) => o.productId === productId)?.prices.map((p) => p.priceId);
-
-  it("a row with no stored Prices answers exactly what it did before, and sells at the Product grain", async () => {
-    expect(offeringsRow().shownPriceIds).toEqual([]);
-    expect(await getWorkspaceShownSet(FIXTURE_WS, { now: FIXTURE_NOW })).toEqual(EXPECTED_SHOWN_SET);
-    expect(await getSellableProductIds(FIXTURE_WS)).toEqual({
-      organizationId: FIXTURE_ORG,
-      productIds: FIXTURE_SHOWN_PRODUCT_IDS,
-      priceIds: null,
-    });
-  });
-
-  it("stored Prices keep only those Prices, drop a Product left with none, and sell only them", async () => {
-    offeringsRow().shownProductIds = ["prod_fixture_growth", "prod_fixture_basic"];
-    offeringsRow().shownPriceIds = ["price_fixture_growth_yearly", "price_fixture_basic_once"];
-    const shown = await getWorkspaceShownSet(FIXTURE_WS, { now: FIXTURE_NOW });
-    expect(workspaceShownSetSchema.parse(shown)).toEqual(shown);
-    expect(shown!.offerings.map((o) => o.productId)).toEqual(["prod_fixture_basic", "prod_fixture_growth"]);
-    expect(prices(shown, "prod_fixture_growth")).toEqual(["price_fixture_growth_yearly"]);
-    expect(prices(shown, "prod_fixture_basic")).toEqual(["price_fixture_basic_once"]);
-    expect(prices(shown, "prod_fixture_seo_audit")).toBeUndefined();
-    expect(await getSellableProductIds(FIXTURE_WS)).toEqual({
-      organizationId: FIXTURE_ORG,
-      productIds: ["prod_fixture_growth", "prod_fixture_basic"],
-      priceIds: ["price_fixture_growth_yearly", "price_fixture_basic_once"],
-    });
-  });
-
-  it("keeps the stored Recommended on a Product with a shown Price — the flag /pricing highlights from", async () => {
-    offeringsRow().shownProductIds = ["prod_fixture_growth"];
-    offeringsRow().shownPriceIds = ["price_fixture_growth_yearly"];
-    const shown = await getWorkspaceShownSet(FIXTURE_WS, { now: FIXTURE_NOW });
-    expect(shown!.recommended).toEqual({ plan: "prod_fixture_growth", addon: null });
-    expect(shown!.offerings).toHaveLength(1);
-    expect(shown!.offerings[0]).toMatchObject({ productId: "prod_fixture_growth", recommended: true });
-    expect(prices(shown, "prod_fixture_growth")).toEqual(["price_fixture_growth_yearly"]);
-  });
-
-  it("a stored Price the catalog no longer carries is not shown, and its Recommended is cleared", async () => {
-    offeringsRow().shownProductIds = ["prod_fixture_growth"];
-    offeringsRow().shownPriceIds = ["price_fixture_gone"];
-    const shown = await getWorkspaceShownSet(FIXTURE_WS, { now: FIXTURE_NOW });
-    expect(shown!.offerings).toEqual([]);
-    expect(shown!.recommended.plan).toBeNull();
-    expect(shown!.state).toBe("current");
-  });
-
-  it("shownPriceIdsFor answers stored ∩ carried, or every Price of each shown Product with none stored", () => {
-    const offerings = EXPECTED_FIXTURE_OFFERINGS.filter((o) => FIXTURE_SHOWN_PRODUCT_IDS.includes(o.productId));
-    expect(
-      shownPriceIdsFor(offerings, {
-        shownProductIds: ["prod_fixture_growth"],
-        shownPriceIds: ["price_fixture_growth_yearly", "price_fixture_gone"],
-      }),
-    ).toEqual(new Set(["price_fixture_growth_yearly"]));
-    expect(
-      shownPriceIdsFor(offerings, { shownProductIds: ["prod_fixture_growth"], shownPriceIds: [] }),
-    ).toEqual(new Set(["price_fixture_growth_monthly", "price_fixture_growth_yearly"]));
-    expect(shownPriceIdsFor(offerings, { shownProductIds: [], shownPriceIds: [] })).toEqual(new Set());
-  });
-});
-
-describe("the last-good copy, for 24 hours (AC-7)", () => {
-  it("is current at snapshotAt + 24h and expired, with no offerings, one millisecond later", async () => {
-    const current = await getWorkspaceShownSet(FIXTURE_WS, { now: at(LAST_GOOD_MAX_AGE_MS) });
-    expect(current!.state).toBe("current");
-    expect(current!.offerings).toHaveLength(3);
-    const expired = await getWorkspaceShownSet(FIXTURE_WS, { now: at(LAST_GOOD_MAX_AGE_MS + 1) });
-    expect(expired).toMatchObject({
-      state: "expired",
-      offerings: [],
-      recommended: { plan: null, addon: null },
-      snapshotAt: FIXTURE_NOW.toISOString(),
-    });
-  });
-
-  it("a snapshotAt ten minutes in the future answers expired", async () => {
-    offeringsRow().snapshotAt = at(10 * 60 * SECOND);
-    expect((await getWorkspaceShownSet(FIXTURE_WS, { now: FIXTURE_NOW }))!.state).toBe("expired");
-  });
-
-  it("a snapshot that fails its schema answers empty and logs snapshot_unreadable", async () => {
-    offeringsRow().snapshot = { v: 1, offerings: [{ productId: "prod_fixture_growth", name: "" }] };
-    const shown = await getWorkspaceShownSet(FIXTURE_WS, { now: FIXTURE_NOW });
-    expect(shown).toMatchObject({ state: "empty", offerings: [], snapshotAt: null });
-    expect(mockLog).toHaveBeenCalledWith("warn", { workspaceId: FIXTURE_WS, reason: "snapshot_unreadable" }, expect.any(String));
-  });
-
-  it("no snapshot answers empty", async () => {
-    offeringsRow().snapshot = null;
-    offeringsRow().snapshotAt = null;
-    expect((await getWorkspaceShownSet(FIXTURE_WS, { now: FIXTURE_NOW }))!.state).toBe("empty");
-  });
-
-  it("a refresh whose source rejects answers source_failed and leaves the last good copy byte-equal", async () => {
-    const before = JSON.stringify([offeringsRow().snapshot, offeringsRow().snapshotAt]);
-    const { sourceFor } = rejecting();
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS, sourceFor, { now: at(61 * SECOND) })).toBe("source_failed");
-    expect(JSON.stringify([offeringsRow().snapshot, offeringsRow().snapshotAt])).toBe(before);
-  });
-
-  it("a refresh after 61 seconds answers refreshed and rewrites both columns through the schema", async () => {
-    const changed = structuredClone(OFFERINGS_FIXTURE_CATALOG);
-    changed.products[0] = { ...changed.products[0], name: "Growth, renamed" };
-    const { sourceFor } = countingSourceFor(async () => structuredClone(changed));
-    const now = at(61 * SECOND);
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS, sourceFor, { now })).toBe("refreshed");
-    expect(offeringsRow().snapshotAt).toEqual(now);
-    const snapshot = offeringsSnapshotSchema.parse(offeringsRow().snapshot);
-    expect(snapshot.offerings.map((o) => o.name)).toEqual(["Basic", "Growth, renamed", "SEO audit"]);
-    expect((await getWorkspaceShownSet(FIXTURE_WS, { now }))!.offerings[1]!.name).toBe("Growth, renamed");
-  });
-
-  it("a refresh writes only the shown ∩ enabled products", async () => {
-    offeringsRow().shownProductIds = ["prod_fixture_growth", "prod_fixture_bidi"];
-    const { sourceFor } = countingSourceFor();
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS, sourceFor, { now: at(61 * SECOND) })).toBe("refreshed");
-    const snapshot = offeringsSnapshotSchema.parse(offeringsRow().snapshot);
-    expect(snapshot.offerings.map((o) => o.productId)).toEqual(["prod_fixture_growth"]);
-  });
-
-  it("a refresh of a workspace with no Offerings row answers no_selection and creates none", async () => {
-    const { sourceFor, calls } = countingSourceFor();
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS_2, sourceFor, { now: at(61 * SECOND) })).toBe("no_selection");
-    expect(await refreshWorkspaceSnapshot(FIXTURE_ORG_2_WS, sourceFor, { now: at(61 * SECOND) })).toBe(
-      "no_connection",
-    );
-    expect(calls).toEqual([]);
-    expect(db.__db.workspaceOfferings!.some((r) => r.workspaceId === FIXTURE_WS_2)).toBe(false);
-  });
-});
-
-describe("the refresh is bounded (AC-8, T7)", () => {
-  it("59 seconds after snapshotAt answers fresh with no call", async () => {
-    const { sourceFor, calls } = countingSourceFor();
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS, sourceFor, { now: at(59 * SECOND) })).toBe("fresh");
-    expect(calls).toHaveLength(0);
-  });
-
-  it("five concurrent refreshes after 61 seconds call the source once and all answer refreshed", async () => {
-    const { sourceFor, calls } = countingSourceFor();
-    const now = at(61 * SECOND);
-    const outcomes = await Promise.all(
-      Array.from({ length: 5 }, () => refreshWorkspaceSnapshot(FIXTURE_WS, sourceFor, { now, force: true })),
-    );
-    expect(outcomes).toEqual(Array(5).fill("refreshed"));
-    expect(calls).toEqual([FIXTURE_ORG]);
-  });
-
-  it("five concurrent non-forced refreshes after 61 seconds call the source once", async () => {
-    const { sourceFor, calls } = countingSourceFor();
-    const now = at(61 * SECOND);
-    const outcomes = await Promise.all(
-      Array.from({ length: 5 }, () => refreshWorkspaceSnapshot(FIXTURE_WS, sourceFor, { now })),
-    );
-    expect(outcomes).toEqual(Array(5).fill("refreshed"));
-    expect(calls).toHaveLength(1);
-  });
-
-  it("after a source_failed, a non-forced refresh 30 seconds later is throttled with no call", async () => {
-    const { sourceFor, calls } = rejecting();
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS, sourceFor, { now: at(61 * SECOND) })).toBe("source_failed");
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS, sourceFor, { now: at(91 * SECOND) })).toBe("throttled");
-    expect(calls).toHaveLength(1);
-    // A minute after the failure the Organization may be read again.
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS, sourceFor, { now: at(121 * SECOND) })).toBe("source_failed");
-    expect(calls).toHaveLength(2);
-  });
-
-  it("a second workspace of the Organization 30 seconds after a read is served from it, with no call", async () => {
-    await db.workspaceOfferings.create({
-      data: {
-        workspaceId: FIXTURE_WS_2,
-        shownProductIds: ["prod_fixture_seo_audit"],
-        recommendedPlanProductId: null,
-        recommendedAddonProductId: null,
-        snapshot: null,
-        snapshotAt: null,
-      },
-    });
-    const { sourceFor, calls } = countingSourceFor();
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS, sourceFor, { now: at(61 * SECOND) })).toBe("refreshed");
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS_2, sourceFor, { now: at(91 * SECOND) })).toBe("refreshed");
-    expect(calls).toHaveLength(1);
-    expect(offeringsSnapshotSchema.parse(offeringsRow(FIXTURE_WS_2).snapshot).offerings.map((o) => o.productId)).toEqual([
-      "prod_fixture_seo_audit",
-    ]);
-    expect(offeringsRow(FIXTURE_WS_2).snapshotAt).toEqual(at(91 * SECOND));
-  });
-
-  it("a refresh never overwrites a snapshot newer than its own now, and answers fresh", async () => {
-    offeringsRow().snapshotAt = at(120 * SECOND);
-    const before = JSON.stringify(offeringsRow().snapshot);
-    const { sourceFor } = countingSourceFor();
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS, sourceFor, { now: at(61 * SECOND), force: true })).toBe(
-      "fresh",
-    );
-    expect(offeringsRow().snapshotAt).toEqual(at(120 * SECOND));
-    expect(JSON.stringify(offeringsRow().snapshot)).toBe(before);
-  });
-
-  it("a refresh replaces a snapshot dated past the skew window", async () => {
-    offeringsRow().snapshotAt = at(61 * SECOND + 10 * 60 * SECOND);
-    const { sourceFor } = countingSourceFor();
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS, sourceFor, { now: at(61 * SECOND) })).toBe("refreshed");
-    expect(offeringsRow().snapshotAt).toEqual(at(61 * SECOND));
-  });
-
-  it("a caller whose now is older than the last read is still held by it (out-of-order now)", async () => {
-    const failing = rejecting();
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS, failing.sourceFor, { now: at(100 * SECOND) })).toBe(
-      "source_failed",
-    );
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS, failing.sourceFor, { now: at(100 * SECOND - 5) })).toBe(
-      "throttled",
-    );
-    await expect(
-      getOrgEnabledProducts(FIXTURE_ORG, failing.sourceFor, { now: at(100 * SECOND - 10) }),
-    ).rejects.toBeInstanceOf(OfferingsSourceError);
-    expect(failing.calls).toHaveLength(1);
-  });
-
-  it("an older now never evicts another Organization's hold", async () => {
-    const failing = rejecting();
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS, failing.sourceFor, { now: at(100 * SECOND) })).toBe(
-      "source_failed",
-    );
-    // A read for another Organization arriving with an older clock.
-    await getOrgEnabledProducts(FIXTURE_ORG_2, refusingSourceFor, { now: at(50 * SECOND) });
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS, failing.sourceFor, { now: at(110 * SECOND) })).toBe(
-      "throttled",
-    );
-    expect(failing.calls).toHaveLength(1);
-  });
-
-  it("a read dated more than the skew after now does not hold the Organization", async () => {
-    const failing = rejecting();
-    await getOrgEnabledProducts(FIXTURE_ORG, failing.sourceFor, { now: at(60 * 60 * SECOND) }).catch(() => undefined);
-    await expect(getOrgEnabledProducts(FIXTURE_ORG, failing.sourceFor, { now: FIXTURE_NOW })).rejects.toBeInstanceOf(
-      OfferingsSourceError,
-    );
-    expect(failing.calls).toHaveLength(2);
-  });
-
-  it("a snapshot dated within the skew after now is fresh, with no call", async () => {
-    offeringsRow().snapshotAt = at(4 * 60 * SECOND);
-    const { sourceFor, calls } = countingSourceFor();
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS, sourceFor, { now: FIXTURE_NOW })).toBe("fresh");
-    expect(calls).toHaveLength(0);
-  });
-
-  it("getOrgEnabledProducts 30 seconds after a failed read rejects with OfferingsSourceError and no call", async () => {
-    const { sourceFor, calls } = rejecting();
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS, sourceFor, { now: at(61 * SECOND) })).toBe("source_failed");
-    await expect(getOrgEnabledProducts(FIXTURE_ORG, sourceFor, { now: at(91 * SECOND) })).rejects.toBeInstanceOf(
-      OfferingsSourceError,
-    );
-    expect(calls).toHaveLength(1);
-  });
-
-  it("getOrgEnabledProducts reuses a read under a minute old, and its own read holds the Organization", async () => {
-    const { sourceFor, calls } = countingSourceFor();
-    await getOrgEnabledProducts(FIXTURE_ORG, sourceFor, { now: FIXTURE_NOW });
-    await getOrgEnabledProducts(FIXTURE_ORG, sourceFor, { now: at(30 * SECOND) });
-    expect(calls).toHaveLength(1);
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS, sourceFor, { now: at(61 * SECOND) })).toBe("refreshed");
-    expect(calls).toHaveLength(2);
-  });
-
-  it("force: true at 59 seconds calls the source once", async () => {
-    const { sourceFor, calls } = countingSourceFor();
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS, sourceFor, { now: at(59 * SECOND), force: true })).toBe(
-      "refreshed",
-    );
-    expect(calls).toHaveLength(1);
-  });
-
-  it("builds a source only for the Organization resolved from Workspace.organizationId", async () => {
-    const { sourceFor, calls } = countingSourceFor();
-    await refreshWorkspaceSnapshot(FIXTURE_WS, sourceFor, { now: at(61 * SECOND), force: true });
-    await getOrgEnabledProducts(FIXTURE_ORG, sourceFor, { now: at(200 * SECOND) });
-    expect(new Set(calls)).toEqual(new Set([FIXTURE_ORG]));
-  });
-
-  it("getWorkspaceShownSet and getSellableProductIds never build a source", async () => {
-    const { sourceFor, calls } = countingSourceFor();
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS, sourceFor, { now: at(61 * SECOND) })).toBe("refreshed");
-    for (const offset of [0, 61 * SECOND, LAST_GOOD_MAX_AGE_MS + 1]) {
-      await getWorkspaceShownSet(FIXTURE_WS, { now: at(offset) });
-      await getSellableProductIds(FIXTURE_WS);
-    }
-    expect(calls).toHaveLength(1);
-  });
-});
-
-describe("checkout's allowlist never reads the display copy (AC-10, contract A4)", () => {
-  it("answers the seeded enabled ∩ shown ids, never selecting the snapshot", async () => {
-    expect(await getSellableProductIds(FIXTURE_WS)).toEqual({
-      organizationId: FIXTURE_ORG,
-      productIds: FIXTURE_SHOWN_PRODUCT_IDS,
-      priceIds: null,
-    });
-    expect(db.workspaceOfferings.findUnique).toHaveBeenCalled();
-    for (const [args] of db.workspaceOfferings.findUnique.mock.calls as Array<[{ select: Row }]>) {
-      expect(Object.keys(args.select)).not.toContain("snapshot");
-      expect(Object.keys(args.select)).not.toContain("snapshotAt");
-    }
-  });
-
-  it("is unchanged when the snapshot names a product neither set holds", async () => {
-    const before = await getSellableProductIds(FIXTURE_WS);
-    offeringsRow().snapshot = {
-      v: 1,
-      offerings: [{ ...EXPECTED_FIXTURE_OFFERINGS[3], productId: "prod_fixture_bidi" }],
-    };
-    expect(await getSellableProductIds(FIXTURE_WS)).toEqual(before);
-  });
-
-  it("answers null with no connection, and for a workspace with no Offerings row", async () => {
-    expect(await getSellableProductIds(FIXTURE_ORG_2_WS)).toBeNull();
-    expect(await getSellableProductIds(FIXTURE_WS_2)).toBeNull();
-  });
-});
-
-describe("nothing leaks into logs or errors (AC-12, contract C5, T6)", () => {
-  /** Every string the fixture holds that must never be logged. */
-  function fixtureSecrets(): string[] {
-    const texts: string[] = [FIXTURE_KEY_LAST4, FIXTURE_WEBHOOK_TOKEN, FIXTURE_CIPHERTEXT_PLACEHOLDER];
-    for (const p of OFFERINGS_FIXTURE_CATALOG.products) {
-      texts.push(p.id as string, p.name as string);
-      if (typeof p.description === "string") texts.push(p.description);
-      for (const f of (p.marketing_features as Array<{ name: string }>) ?? []) texts.push(f.name);
-    }
-    for (const price of OFFERINGS_FIXTURE_CATALOG.prices) texts.push(price.id as string, price.lookup_key as string);
-    return texts;
-  }
-
-  it("a log capture across every reader and every refresh outcome holds no fixture text", async () => {
-    const key = `rk_test_${"Zx9".repeat(12)}`;
-    const keyed = countingSourceFor(async () => {
-      throw Object.assign(new Error(`Invalid API Key provided: ${key}`), { raw: { message: key } });
-    });
-    const { sourceFor } = countingSourceFor();
-
-    await getWorkspaceShownSet(FIXTURE_WS, { now: FIXTURE_NOW });
-    await getSellableProductIds(FIXTURE_WS);
-    await getOrgEnabledProducts(FIXTURE_ORG, sourceFor, { now: FIXTURE_NOW });
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS, sourceFor, { now: at(30 * SECOND) })).toBe("fresh");
-    resetOfferingsRefreshStateForTests();
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS, keyed.sourceFor, { now: at(61 * SECOND) })).toBe(
-      "source_failed",
-    );
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS, keyed.sourceFor, { now: at(62 * SECOND) })).toBe("throttled");
-    const sourceError = await getOrgEnabledProducts(FIXTURE_ORG, keyed.sourceFor, { now: at(63 * SECOND) }).catch(
-      (err: unknown) => err,
-    );
-    resetOfferingsRefreshStateForTests();
-    const orgError = await getOrgEnabledProducts(FIXTURE_ORG, keyed.sourceFor, { now: at(64 * SECOND) }).catch(
-      (err: unknown) => err,
-    );
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS, sourceFor, { now: at(200 * SECOND) })).toBe("refreshed");
-    expect(await refreshWorkspaceSnapshot(FIXTURE_WS_2, sourceFor, { now: at(200 * SECOND) })).toBe("no_selection");
-    expect(await refreshWorkspaceSnapshot(FIXTURE_ORG_2_WS, sourceFor, { now: at(200 * SECOND) })).toBe(
-      "no_connection",
-    );
-    offeringsRow().snapshot = { v: 1, offerings: [{ productId: "prod_fixture_growth", name: "Growth" }] };
-    await getWorkspaceShownSet(FIXTURE_WS, { now: at(200 * SECOND) });
-    db.__db.stripeConnection![0]!.keyLast4 = "42";
-    await getWorkspaceShownSet(FIXTURE_WS, { now: at(200 * SECOND) });
-
-    expect(mockLog).toHaveBeenCalled();
-    const logged = JSON.stringify(mockLog.mock.calls);
-    for (const secret of [...fixtureSecrets(), key, "Invalid API Key", "upstream"]) {
-      expect(logged).not.toContain(secret);
-    }
-    expect(mockLog).toHaveBeenCalledWith(
-      "warn",
-      { workspaceId: FIXTURE_WS, outcome: "source_failed", errName: "Error" },
-      expect.any(String),
-    );
-    expect(mockLog).toHaveBeenCalledWith(
-      "warn",
-      { organizationId: FIXTURE_ORG, outcome: "source_failed", errName: "Error" },
-      expect.any(String),
-    );
-
-    for (const err of [sourceError, orgError]) {
-      expect(err).toBeInstanceOf(OfferingsSourceError);
-      expect((err as Error).cause).toBeUndefined();
-      const text = JSON.stringify({ ...(err as object), message: (err as Error).message, stack: (err as Error).stack });
-      expect(text).not.toContain(key);
-      expect(text).not.toContain("Invalid API Key");
-    }
-  });
-});