create-ailk 0.22.0 → 0.24.0

package/templates/apps/api/src/routes/content/__tests__/offerings.test.ts

@@ -0,0 +1,731 @@
+/**
+ * @file offerings.test.ts
+ * GET /v1/content/offerings — the HTTP twin of the `get_offerings` MCP tool
+ * (#7177).
+ *
+ * Uses the real content adapter backed by a per-test temp dir (Issue #507).
+ * The resolver is spied on only for the 404 and 500 arms.
+ *
+ * The `provider:` and `categories:` fixtures are written here rather than
+ * through `writeFixturePage`, whose frontmatter parameter is
+ * `Record<string, string>` and so cannot express YAML nesting.
+ */
+
+import * as fs from "fs/promises";
+import * as path from "path";
+import { Writable } from "node:stream";
+
+import cors from "@fastify/cors";
+import {
+  currentShownSet,
+  listOfferings,
+  listOfferingsWithShownSet,
+  type ContentAdapter,
+} from "@working-theory/content-adapters";
+import { logger } from "@working-theory/observability";
+import { shownOfferingsAnswerSchema } from "@working-theory/validation";
+import Fastify from "fastify";
+import type { FastifyInstance } from "fastify";
+
+import { setupContentFixture } from "../../../__tests__/factories/content-fixture";
+import { getContentAdapter } from "../../../lib/content-adapter";
+import * as publicSiteResolver from "../../../services/public-site-resolver.js";
+import { contentRoutes } from "../index";
+import * as commerceClaim from "../../../lib/require-commerce-claim.js";
+import { prisma } from "../../../lib/prisma.js";
+import * as offeringsServices from "../../../services/offerings/index.js";
+import {
+  FIXTURE_NOW,
+  FIXTURE_ORG,
+  FIXTURE_ORG_2_WS,
+  FIXTURE_WS,
+  FIXTURE_WS_2,
+  OFFERINGS_FIXTURE_CATALOG,
+  seedOfferings as seedOfferingsRows,
+} from "../../../services/offerings/__tests__/fixtures.js";
+import { offeringsRoute } from "../offerings";
+import { pricingRoute } from "../pricing";
+import * as shownOfferings from "../shown-offerings";
+import type { ShownOfferingsRouteOptions } from "../shown-offerings";
+
+// #8933 — the Offerings services read and write the in-memory double, so a
+// seeded connected workspace answers its shown set. The content cases above
+// never resolve a workspace (no spoke key, the MDX adapter), so they never
+// reach it.
+// 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(),
+);
+
+/** While set, the shown-set mapping throws (AC-3) — a plain switch, not a mock. */
+const mockMappingThrows = { on: false };
+
+// The real package, with the shown-set mapping behind a switch a case can
+// throw through. Not a stand-in: every other export is the real one.
+jest.mock("@working-theory/content-adapters", () => {
+  const actual = jest.requireActual<
+    typeof import("@working-theory/content-adapters")
+  >("@working-theory/content-adapters");
+  return {
+    __esModule: true,
+    ...actual,
+    listOfferingsWithShownSet: (
+      ...args: Parameters<typeof actual.listOfferingsWithShownSet>
+    ) => {
+      if (mockMappingThrows.on) {
+        throw new Error("mapping refused Growth: For a growing practice.");
+      }
+      return actual.listOfferingsWithShownSet(...args);
+    },
+  };
+});
+
+const fixture = setupContentFixture();
+
+/** Writes an MDX page into the default-locale path. */
+async function writePage(
+  type: "Service" | "Product",
+  slug: string,
+  lines: readonly string[],
+): Promise<void> {
+  const dir = path.join(fixture.getContentRoot(), "en", type);
+  await fs.mkdir(dir, { recursive: true });
+  const frontmatter = [`type: "${type}"`, `slug: "${slug}"`, ...lines].join(
+    "\n",
+  );
+  await fs.writeFile(
+    path.join(dir, `${slug}.mdx`),
+    `---\n${frontmatter}\n---\n\nBody copy.\n`,
+    "utf8",
+  );
+}
+
+async function seedOfferings(): Promise<void> {
+  await writePage("Service", "launch", [
+    `title: "Launch Service"`,
+    `description: "A productized two-week deploy."`,
+    "provider:",
+    "  name: SalesSmyth",
+    "price: 2495",
+    "priceCurrency: USD",
+    "categories:",
+    "  - technology",
+  ]);
+  await writePage("Product", "standard", [
+    `title: "Standard"`,
+    `description: "The flagship marketing template."`,
+    "provider:",
+    "  name: SalesSmyth",
+    "  logo: /logomark.svg",
+  ]);
+}
+
+function names(body: string): string[] {
+  return (
+    JSON.parse(body) as { data: { offerings: { name: string }[] } }
+  ).data.offerings
+    .map((o) => o.name)
+    .sort();
+}
+
+describe("GET /v1/content/offerings", () => {
+  let app: FastifyInstance;
+
+  beforeEach(async () => {
+    app = require("fastify")();
+    await app.register(contentRoutes);
+  });
+
+  afterEach(async () => {
+    jest.restoreAllMocks();
+    await app.close();
+  });
+
+  it("answers 200 with every offering in the API envelope", async () => {
+    await seedOfferings();
+
+    const res = await app.inject({
+      method: "GET",
+      url: "/v1/content/offerings",
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(JSON.parse(res.body).ok).toBe(true);
+    expect(names(res.body)).toEqual(
+      expect.arrayContaining(["Launch Service", "Standard"]),
+    );
+  });
+
+  it("answers Service pages only for ?type=service", async () => {
+    await seedOfferings();
+
+    const res = await app.inject({
+      method: "GET",
+      url: "/v1/content/offerings?type=service",
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(names(res.body)).toEqual(["Launch Service"]);
+  });
+
+  it("answers Product pages only for ?type=product", async () => {
+    await seedOfferings();
+
+    const res = await app.inject({
+      method: "GET",
+      url: "/v1/content/offerings?type=product",
+    });
+
+    expect(res.statusCode).toBe(200);
+    // The seeded page and the fixture's own `test-product`, and no Service.
+    expect(names(res.body)).toEqual(["Product test-product title", "Standard"]);
+  });
+
+  it("refuses a type the tool refuses, echoing no issues", async () => {
+    const res = await app.inject({
+      method: "GET",
+      url: "/v1/content/offerings?type=offer",
+    });
+
+    expect(res.statusCode).toBe(400);
+    const body = JSON.parse(res.body);
+    expect(body.ok).toBe(false);
+    expect(body.error.code).toBe("validation_failed");
+    expect(body).not.toHaveProperty("details");
+    expect(body).not.toHaveProperty("issues");
+    expect(body.error).not.toHaveProperty("details");
+    expect(body.error).not.toHaveProperty("issues");
+  });
+
+  it("refuses a malformed locale, and falls back for an unknown well-formed one", async () => {
+    await seedOfferings();
+
+    const malformed = await app.inject({
+      method: "GET",
+      url: "/v1/content/offerings?locale=english",
+    });
+    expect(malformed.statusCode).toBe(400);
+    expect(JSON.parse(malformed.body).error.code).toBe("validation_failed");
+
+    const unknown = await app.inject({
+      method: "GET",
+      url: "/v1/content/offerings?locale=zz",
+    });
+    expect(unknown.statusCode).toBe(200);
+    expect(names(unknown.body)).toEqual(
+      expect.arrayContaining(["Launch Service", "Standard"]),
+    );
+  });
+
+  it("answers 404 not_found when no public site resolves", async () => {
+    jest
+      .spyOn(publicSiteResolver, "resolvePublicContentAdapter")
+      .mockResolvedValue(null);
+
+    const res = await app.inject({
+      method: "GET",
+      url: "/v1/content/offerings",
+    });
+
+    expect(res.statusCode).toBe(404);
+    const body = JSON.parse(res.body);
+    expect(body.ok).toBe(false);
+    expect(body.error.code).toBe("not_found");
+    // The 404 depends on the spoke key too, so a URL-keyed cache must not
+    // serve one bad key's 404 to another site.
+    expect(String(res.headers["vary"]).toLowerCase()).toContain(
+      "x-ailk-spoke-key",
+    );
+  });
+
+  it("answers 500 internal_error and leaks nothing when the read throws", async () => {
+    const failing: Pick<ContentAdapter, "listPages"> = {
+      listPages: async () => {
+        throw new Error("secret-path");
+      },
+    };
+    jest
+      .spyOn(publicSiteResolver, "resolvePublicContentAdapter")
+      .mockResolvedValue(failing as ContentAdapter);
+
+    const res = await app.inject({
+      method: "GET",
+      url: "/v1/content/offerings",
+    });
+
+    expect(res.statusCode).toBe(500);
+    expect(JSON.parse(res.body).error.code).toBe("internal_error");
+    expect(res.body).not.toContain("secret-path");
+    expect(res.body).not.toContain("stack");
+  });
+
+  /**
+   * D6 — API ↔ MCP parity evidence for #7177.
+   *
+   * The route must return EXACTLY what `listOfferings` returns for the
+   * options the `get_offerings` tool builds from the same arguments.
+   * `apps/api` cannot import `apps/mcp`, so the shared seam is asserted:
+   * `apps/mcp/__tests__/get_offerings.test.ts` pins the other half — tool
+   * answer ≡ `listOfferings` — and the two compose into the 1:1 claim.
+   */
+  describe("parity with the seam the MCP tool calls (#7177 D5)", () => {
+    it("deep-equals listOfferings for ?type=service&locale=en", async () => {
+      await seedOfferings();
+
+      const res = await app.inject({
+        method: "GET",
+        url: "/v1/content/offerings?type=service&locale=en",
+      });
+      expect(res.statusCode).toBe(200);
+
+      const expected = await listOfferings(getContentAdapter(), {
+        type: "service",
+        locale: "en",
+      });
+      expect(JSON.parse(res.body).data).toEqual(
+        JSON.parse(JSON.stringify(expected)),
+      );
+    });
+
+    it("deep-equals listOfferings with no query at all", async () => {
+      await seedOfferings();
+
+      const res = await app.inject({
+        method: "GET",
+        url: "/v1/content/offerings",
+      });
+      expect(res.statusCode).toBe(200);
+
+      const expected = await listOfferings(getContentAdapter(), {
+        locale: "en",
+      });
+      expect(JSON.parse(res.body).data).toEqual(
+        JSON.parse(JSON.stringify(expected)),
+      );
+    });
+  });
+});
+
+describe("GET /v1/content/offerings — Vary beside CORS", () => {
+  let app: FastifyInstance;
+
+  beforeEach(async () => {
+    app = require("fastify")();
+    // Registered as `server.ts` registers it, so CORS's `Vary: Origin` is
+    // written before the route adds its own value.
+    await app.register(cors, {
+      origin: ["https://a.example"],
+      credentials: true,
+    });
+    await app.register(contentRoutes);
+  });
+
+  afterEach(async () => {
+    await app.close();
+  });
+
+  it("appends x-ailk-spoke-key to Vary and keeps Origin", async () => {
+    const res = await app.inject({
+      method: "GET",
+      url: "/v1/content/offerings",
+      headers: { origin: "https://a.example" },
+    });
+
+    expect(res.statusCode).toBe(200);
+    const vary = String(res.headers["vary"])
+      .split(",")
+      .map((v) => v.trim().toLowerCase());
+    expect(vary).toEqual(
+      expect.arrayContaining(["origin", "x-ailk-spoke-key"]),
+    );
+    expect(res.headers["access-control-allow-origin"]).toBe(
+      "https://a.example",
+    );
+  });
+});
+
+/**
+ * #8933 (spec docs/specs/8933-get-pricing-and-get-offerings-spec.md) — on a
+ * connected workspace every read but `type=service` answers the Service
+ * pages followed by the workspace's Offerings shown set, read through
+ * #8924's `readShownOfferings` over #8876's real services, the in-memory
+ * database and the seed at `FIXTURE_NOW`. The resolver's workspace read and
+ * the commerce claim are spied; the content adapter is the real fixture one,
+ * so every fallback is compared with today's `listOfferings` answer over it.
+ */
+describe("GET /v1/content/offerings — the Offerings shown set (#8933)", () => {
+  type Row = Record<string, unknown>;
+  // The in-memory double exposes its store, 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[]> };
+
+  const SECOND = 1000;
+  const HOUR = 60 * 60 * SECOND;
+  const at = (offsetMs: number) => new Date(FIXTURE_NOW.getTime() + offsetMs);
+
+  /** The seed's shown Products as an agent reads them (AC-1). */
+  const EXPECTED_SHOWN = [
+    {
+      name: "Basic",
+      description: "One site, set up once.",
+      provider: null,
+      categories: [],
+      price: 99,
+      priceCurrency: "USD",
+      prices: [
+        { price: 99, priceCurrency: "USD", interval: null, lookupKey: "basic_once" },
+      ],
+    },
+    {
+      name: "Growth",
+      description: "For a growing practice.\nEverything in Basic.",
+      provider: null,
+      categories: [],
+      price: 49,
+      priceCurrency: "USD",
+      prices: [
+        { price: 49, priceCurrency: "USD", interval: "month", lookupKey: "growth_monthly" },
+        { price: 490, priceCurrency: "USD", interval: "year", lookupKey: "growth_yearly" },
+      ],
+    },
+    {
+      name: "SEO audit",
+      description: "",
+      provider: null,
+      categories: [],
+      price: 15,
+      priceCurrency: "USD",
+      prices: [
+        { price: 15, priceCurrency: "USD", interval: "month", lookupKey: "seo-audit_monthly" },
+      ],
+    },
+  ];
+
+  /** Every product name, description, feature string, lookup key and id in the catalog. */
+  const FIXTURE_TEXT: string[] = [
+    ...OFFERINGS_FIXTURE_CATALOG.products.flatMap((product) => [
+      product.name,
+      ...(product.description ? [product.description] : []),
+      ...(product.marketing_features ?? []).map((feature) => feature.name),
+      product.id,
+    ]),
+    ...OFFERINGS_FIXTURE_CATALOG.prices.flatMap((price) => [
+      price.id,
+      ...(price.lookup_key ? [price.lookup_key] : []),
+    ]),
+    "prod_",
+    "price_",
+  ];
+
+  let logLines: string[] = [];
+  let loggerCalls: unknown[][] = [];
+  let apps: FastifyInstance[] = [];
+  let resolveWorkspace: jest.SpyInstance;
+  let resolveClaim: jest.SpyInstance;
+
+  /** A Fastify with a log stream and the three routes that read the shown set. */
+  async function buildApp(
+    options: ShownOfferingsRouteOptions = {},
+  ): Promise<FastifyInstance> {
+    const stream = new Writable({
+      write(chunk: Buffer, _encoding, callback) {
+        logLines.push(chunk.toString());
+        callback();
+      },
+    });
+    const app = Fastify({ logger: { level: "trace", stream } });
+    await app.register(offeringsRoute, options);
+    await app.register(pricingRoute, options);
+    await app.register(shownOfferings.shownOfferingsRoute, options);
+    apps.push(app);
+    return app;
+  }
+
+  async function get(app: FastifyInstance, url = "/v1/content/offerings") {
+    const response = await app.inject({ method: "GET", url });
+    return { response, body: JSON.parse(response.body) as Row };
+  }
+
+  function resolvedTo(workspaceId: string): void {
+    resolveWorkspace.mockResolvedValue({ kind: "resolved", workspaceId });
+  }
+
+  /** Today's content answer — what every fallback must equal. */
+  async function contentAnswer(type?: "service" | "product") {
+    return JSON.parse(
+      JSON.stringify(
+        await listOfferings(getContentAdapter(), { type, locale: "en" }),
+      ),
+    ) as unknown;
+  }
+
+  /** The request log's lines whose `outcome` is `outcome`. */
+  function linesWithOutcome(outcome: string): Row[] {
+    return logLines
+      .map((line) => JSON.parse(line) as Row)
+      .filter((line) => line.outcome === outcome);
+  }
+
+  function capturedLogText(): string {
+    return [
+      ...logLines,
+      ...loggerCalls.map((call) => JSON.stringify(call)),
+    ].join("\n");
+  }
+
+  /** A `sourceFor` that answers the fixture catalog and counts each source call. */
+  function countingSourceFor(
+    answer: () => Promise<typeof OFFERINGS_FIXTURE_CATALOG> = async () =>
+      structuredClone(OFFERINGS_FIXTURE_CATALOG),
+  ) {
+    const calls: string[] = [];
+    const sourceFor: offeringsServices.OfferingsSourceFor = (
+      organizationId,
+    ) => ({
+      listActiveCatalog: () => {
+        calls.push(organizationId);
+        return answer();
+      },
+    });
+    return { sourceFor, calls };
+  }
+
+  /** Waits, a macrotask at a time, until `done()` holds (at most a second). */
+  async function until(done: () => boolean): Promise<void> {
+    for (let i = 0; i < 200 && !done(); i += 1) {
+      await new Promise((resolve) => setTimeout(resolve, 5));
+    }
+  }
+
+  beforeEach(async () => {
+    for (const key of Object.keys(db.__db)) delete db.__db[key];
+    offeringsServices.resetOfferingsRefreshStateForTests();
+    await seedOfferingsRows(prisma, { now: FIXTURE_NOW });
+    await seedOfferings();
+    logLines = [];
+    loggerCalls = [];
+    mockMappingThrows.on = false;
+    for (const level of ["error", "warn", "info", "debug"] as const) {
+      jest.spyOn(logger, level).mockImplementation(((...args: unknown[]) => {
+        loggerCalls.push([level, ...args]);
+      }) as never);
+    }
+    resolveWorkspace = jest.spyOn(publicSiteResolver, "resolvePublicWorkspace");
+    resolvedTo(FIXTURE_WS);
+    resolveClaim = jest
+      .spyOn(commerceClaim, "resolveCommerceClaim")
+      .mockResolvedValue("claimed");
+  });
+
+  afterEach(async () => {
+    // AC-5 (T6): across every case, no log line carries Stripe text.
+    const text = capturedLogText();
+    for (const fragment of FIXTURE_TEXT) expect(text).not.toContain(fragment);
+    mockMappingThrows.on = false;
+    await Promise.all(apps.map((app) => app.close()));
+    apps = [];
+    jest.restoreAllMocks();
+  });
+
+  describe("a connected workspace answers its shown set (AC-1)", () => {
+    it("with no query: the Service pages, then the shown Products in place of the Product pages", async () => {
+      const app = await buildApp({ now: () => FIXTURE_NOW });
+      const { response, body } = await get(app);
+      expect(response.statusCode).toBe(200);
+      const services = (
+        (await contentAnswer("service")) as { offerings: Row[] }
+      ).offerings;
+      expect(services.map((o) => o.name)).toContain("Launch Service");
+      expect(body).toEqual({
+        ok: true,
+        data: { offerings: [...services, ...EXPECTED_SHOWN] },
+      });
+      expect(JSON.stringify(body)).not.toContain("The flagship marketing template.");
+    });
+
+    it("?type=product answers the shown Products alone", async () => {
+      const app = await buildApp({ now: () => FIXTURE_NOW });
+      const { body } = await get(app, "/v1/content/offerings?type=product");
+      expect(body).toEqual({ ok: true, data: { offerings: EXPECTED_SHOWN } });
+      for (const offering of EXPECTED_SHOWN) {
+        expect(offering).not.toHaveProperty("category");
+        expect(offering).not.toHaveProperty("image");
+      }
+    });
+
+    it("deep-equals listOfferingsWithShownSet over the shared read's answer", async () => {
+      const app = await buildApp({ now: () => FIXTURE_NOW });
+      const read = await get(app, "/v1/content/shown-offerings");
+      const shownSet = currentShownSet(
+        shownOfferingsAnswerSchema.parse(read.body.data),
+      );
+      expect(shownSet).not.toBeNull();
+
+      const { body } = await get(app, "/v1/content/offerings?locale=en");
+      const expected = await listOfferingsWithShownSet(
+        getContentAdapter(),
+        { locale: "en" },
+        shownSet!,
+      );
+      expect(body.data).toEqual(JSON.parse(JSON.stringify(expected)));
+    });
+
+    it("?type=service answers today's listOfferings, reading no shown set", async () => {
+      const read = jest.spyOn(shownOfferings, "readShownOfferings");
+      const app = await buildApp({ now: () => FIXTURE_NOW });
+      const { body } = await get(app, "/v1/content/offerings?type=service");
+      expect(body.data).toEqual(await contentAnswer("service"));
+      expect(read).not.toHaveBeenCalled();
+    });
+
+    it("reads the snapshot through readShownOfferings, with the route's options", async () => {
+      const read = jest.spyOn(shownOfferings, "readShownOfferings");
+      const options = { now: () => FIXTURE_NOW };
+      const app = await buildApp(options);
+      await get(app);
+      expect(read).toHaveBeenCalledTimes(1);
+      expect(read.mock.calls[0]![1]).toBe(options);
+    });
+  });
+
+  describe("every other case answers page content exactly as before (AC-3)", () => {
+    it.each([
+      ["the Organization's second workspace (no selection)", FIXTURE_WS_2],
+      ["the second Organization's workspace (no connection)", FIXTURE_ORG_2_WS],
+    ])("%s", async (_name, workspaceId) => {
+      resolvedTo(workspaceId);
+      const app = await buildApp({ now: () => FIXTURE_NOW });
+      const { response, body } = await get(app);
+      expect(response.statusCode).toBe(200);
+      expect(body.data).toEqual(await contentAnswer());
+    });
+
+    it("an expired snapshot (25 hours old)", async () => {
+      const app = await buildApp({ now: () => at(25 * HOUR) });
+      const { response, body } = await get(app, "/v1/content/offerings?type=product");
+      expect(response.statusCode).toBe(200);
+      expect(body.data).toEqual(await contentAnswer("product"));
+    });
+
+    it.each(["unclaimed", "undetermined"] as const)(
+      "a %s licence",
+      async (claim) => {
+        resolveClaim.mockResolvedValue(claim);
+        const app = await buildApp({ now: () => FIXTURE_NOW });
+        const { response, body } = await get(app);
+        expect(response.statusCode).toBe(200);
+        expect(body.data).toEqual(await contentAnswer());
+      },
+    );
+
+    it("a site with no workspace to resolve (not-required)", async () => {
+      resolveWorkspace.mockRestore();
+      const read = jest.spyOn(shownOfferings, "readShownOfferings");
+      const app = await buildApp({ now: () => FIXTURE_NOW });
+      const { response, body } = await get(app);
+      expect(response.statusCode).toBe(200);
+      expect(body.data).toEqual(await contentAnswer());
+      // The content answer came from the read's own `unconnected` arm, not
+      // from a failure that would also have landed on page content.
+      await expect(read.mock.results[0]!.value).resolves.toEqual({
+        status: "unconnected",
+      });
+      expect(linesWithOutcome("shown_set_failed")).toEqual([]);
+    });
+
+    it("a shown-set read that rejects logs one fixed warn and answers content, never a 500", async () => {
+      jest
+        .spyOn(shownOfferings, "readShownOfferings")
+        .mockRejectedValue(new Error("read refused One site, set up once."));
+      const app = await buildApp({ now: () => FIXTURE_NOW });
+      const { response, body } = await get(app);
+      expect(response.statusCode).toBe(200);
+      expect(body.data).toEqual(await contentAnswer());
+      expect(linesWithOutcome("shown_set_failed")).toEqual([
+        expect.objectContaining({ level: 40, errName: "Error" }),
+      ]);
+      expect(capturedLogText()).not.toContain("read refused");
+    });
+
+    it("a mapping that throws answers content, never a 500", async () => {
+      mockMappingThrows.on = true;
+      const app = await buildApp({ now: () => FIXTURE_NOW });
+      const { response, body } = await get(app);
+      expect(response.statusCode).toBe(200);
+      expect(body.data).toEqual(await contentAnswer());
+      expect(linesWithOutcome("shown_set_failed")).toHaveLength(1);
+      expect(capturedLogText()).not.toContain("mapping refused");
+    });
+  });
+
+  describe("no request calls Stripe itself (AC-4, T7)", () => {
+    it("a snapshot 30 seconds old answers five sequential requests with no source call", async () => {
+      const refresh = jest.spyOn(offeringsServices, "refreshWorkspaceSnapshot");
+      const { sourceFor, calls } = countingSourceFor();
+      const app = await buildApp({ sourceFor, now: () => at(30 * SECOND) });
+      for (let i = 0; i < 5; i += 1) {
+        const { body } = await get(app, "/v1/content/offerings?type=product");
+        expect(body.data).toEqual({ offerings: EXPECTED_SHOWN });
+      }
+      expect(calls).toEqual([]);
+      expect(refresh).not.toHaveBeenCalled();
+    });
+
+    it("five concurrent stale requests across the three reads make one source call between them", async () => {
+      const refresh = jest.spyOn(offeringsServices, "refreshWorkspaceSnapshot");
+      let release!: () => void;
+      const held = new Promise<void>((resolve) => (release = resolve));
+      const { sourceFor, calls } = countingSourceFor(async () => {
+        await held;
+        return structuredClone(OFFERINGS_FIXTURE_CATALOG);
+      });
+      const app = await buildApp({ sourceFor, now: () => at(61 * SECOND) });
+
+      const pending = Promise.all(
+        [
+          "/v1/content/offerings",
+          "/v1/content/pricing",
+          "/v1/content/shown-offerings",
+          "/v1/content/offerings",
+          "/v1/content/pricing",
+        ].map((url) => get(app, url)),
+      );
+      await until(() => refresh.mock.calls.length === 5);
+      release();
+      const answers = await pending;
+
+      expect(calls).toEqual([FIXTURE_ORG]);
+      for (const { response } of answers) expect(response.statusCode).toBe(200);
+      expect(refresh).toHaveBeenCalledTimes(5);
+      for (const call of refresh.mock.calls) {
+        expect(call[2]).not.toHaveProperty("force");
+      }
+    });
+
+    it("registered with no options, a stale snapshot is served and never refreshed", async () => {
+      const refresh = jest.spyOn(offeringsServices, "refreshWorkspaceSnapshot");
+      const app = await buildApp({ now: () => at(61 * SECOND) });
+      const { body } = await get(app, "/v1/content/offerings?type=product");
+      expect(body.data).toEqual({ offerings: EXPECTED_SHOWN });
+      expect(refresh).not.toHaveBeenCalled();
+    });
+
+    it("a refresh that rejects with Stripe text logs none of it", async () => {
+      const keyBody = "y".repeat(24);
+      const { sourceFor } = countingSourceFor(async () => {
+        throw new Error(`Growth refused for rk_test_${keyBody}`);
+      });
+      const app = await buildApp({ sourceFor, now: () => at(61 * SECOND) });
+      const { response } = await get(app);
+      expect(response.statusCode).toBe(200);
+      const text = capturedLogText();
+      expect(text).not.toContain("rk_test_");
+      expect(text).not.toContain(keyBody);
+    });
+  });
+});