create-ailk 0.21.0 → 0.23.0

package/templates/apps/api/src/services/offerings/__tests__/checkout-session-record.test.ts

@@ -0,0 +1,268 @@
+/**
+ * services/offerings/checkout-session-record.ts — the Checkout session record
+ * (#8930, spec docs/specs/8930-the-offerings-checkout-session-record-spec.md
+ * D4, D5, D7, AC-4, AC-5; contract A11): a record is written once, for a
+ * workspace of the named Organization, and read back exactly; a read answers
+ * `null` only when the database holds no row, never for an error or a corrupt
+ * row; and no error or log line carries a session, Price or key value.
+ *
+ * The world is the in-memory Prisma double, which declares no unique key for
+ * this model (spec §1 fact 7), so the duplicate write is driven through the
+ * `create` spy.
+ */
+// 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(),
+);
+
+const mockLogger = {
+  error: jest.fn(),
+  warn: jest.fn(),
+  info: jest.fn(),
+  debug: jest.fn(),
+};
+jest.mock("@working-theory/observability", () => ({
+  logger: {
+    error: (...args: unknown[]) => mockLogger.error(...args),
+    warn: (...args: unknown[]) => mockLogger.warn(...args),
+    info: (...args: unknown[]) => mockLogger.info(...args),
+    debug: (...args: unknown[]) => mockLogger.debug(...args),
+  },
+}));
+
+import { prisma } from "../../../lib/prisma.js";
+import {
+  CheckoutSessionRecordError,
+  readCheckoutSessionRecord,
+  recordCheckoutSession,
+  type CheckoutSessionRecordInput,
+} from "../checkout-session-record.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[]>;
+  workspace: { findUnique: jest.Mock };
+  offeringsCheckoutSession: { create: jest.Mock; findUnique: jest.Mock };
+};
+
+const ORG_A = "org_01920000-8930-7000-8000-0000000000a1";
+const ORG_B = "org_01920000-8930-7000-8000-0000000000a2";
+const WS_A1 = "wksp_01920000-8930-7000-8000-0000000000b1";
+const WS_A2 = "wksp_01920000-8930-7000-8000-0000000000b2";
+const WS_B1 = "wksp_01920000-8930-7000-8000-0000000000c1";
+const WS_NONE = "wksp_01920000-8930-7000-8000-0000000000d1";
+
+const SESSION = "cs_test_a1Recorded8930";
+const PRICE = "price_1Secret8930";
+const KEY = "growth8930_monthly";
+
+const VALID: CheckoutSessionRecordInput = {
+  sessionId: SESSION,
+  workspaceId: WS_A1,
+  organizationId: ORG_A,
+  priceId: PRICE,
+  lookupKey: KEY,
+  mode: "test",
+};
+
+const RECORD_KEYS = [
+  "createdAt",
+  "lookupKey",
+  "mode",
+  "organizationId",
+  "priceId",
+  "sessionId",
+  "workspaceId",
+];
+
+/** The reason a call rejected with, failing when it rejected with anything else. */
+async function reasonOf(call: Promise<unknown>): Promise<string> {
+  const err = await call.then(
+    () => {
+      throw new Error("expected a rejection");
+    },
+    (e: unknown) => e,
+  );
+  expect(err).toBeInstanceOf(CheckoutSessionRecordError);
+  const recordError = err as CheckoutSessionRecordError;
+  // No input value and no database message reaches the error (D7).
+  const text = `${recordError.message} ${JSON.stringify(Object.entries(recordError))}`;
+  for (const secret of [SESSION, PRICE, KEY])
+    expect(text).not.toContain(secret);
+  expect(recordError.cause).toBeUndefined();
+  expect(Object.keys(recordError)).not.toContain("cause");
+  return recordError.reason;
+}
+
+beforeEach(() => {
+  for (const key of Object.keys(db.__db)) delete db.__db[key];
+  db.__db.workspace = [
+    { id: WS_A1, organizationId: ORG_A, name: "A1" },
+    { id: WS_A2, organizationId: ORG_A, name: "A2" },
+    { id: WS_B1, organizationId: ORG_B, name: "B1" },
+  ];
+  db.workspace.findUnique.mockClear();
+  db.offeringsCheckoutSession.create.mockClear();
+  db.offeringsCheckoutSession.findUnique.mockClear();
+  for (const fn of Object.values(mockLogger)) fn.mockClear();
+});
+
+afterEach(() => {
+  // Across the whole file, no log line carries a session, Price or key value.
+  const logged = JSON.stringify(
+    Object.values(mockLogger).flatMap((fn) => fn.mock.calls),
+  );
+  for (const secret of [SESSION, PRICE, KEY])
+    expect(logged).not.toContain(secret);
+});
+
+describe("recordCheckoutSession + readCheckoutSessionRecord (#8930 D4, D5, AC-4)", () => {
+  it("writes a record once and reads it back exactly", async () => {
+    await expect(recordCheckoutSession(VALID)).resolves.toBeUndefined();
+    expect(db.offeringsCheckoutSession.create).toHaveBeenCalledTimes(1);
+
+    const record = await readCheckoutSessionRecord(SESSION);
+    expect(record).toEqual({ ...VALID, createdAt: expect.any(Date) });
+    expect(Object.keys(record as object).sort()).toEqual(RECORD_KEYS);
+
+    const [[args]] = db.offeringsCheckoutSession.findUnique.mock.calls as [
+      [Row],
+    ];
+    expect(args.where).toEqual({ sessionId: SESSION });
+    expect(Object.keys(args.select as Row).sort()).toEqual(RECORD_KEYS);
+  });
+
+  it("writes a live record of a live session", async () => {
+    const live = {
+      ...VALID,
+      sessionId: "cs_live_a1Recorded8930",
+      mode: "live" as const,
+    };
+    await recordCheckoutSession(live);
+    expect(await readCheckoutSessionRecord(live.sessionId)).toEqual({
+      ...live,
+      createdAt: expect.any(Date),
+    });
+  });
+
+  it("answers another session's id with null, never the recorded one", async () => {
+    await recordCheckoutSession(VALID);
+    expect(await readCheckoutSessionRecord("cs_test_neverRecorded")).toBeNull();
+  });
+
+  it.each([["ch_1"], [""], [undefined], [42]])(
+    "answers %p with null and no database read",
+    async (sessionId) => {
+      expect(await readCheckoutSessionRecord(sessionId)).toBeNull();
+      expect(db.offeringsCheckoutSession.findUnique).not.toHaveBeenCalled();
+    },
+  );
+
+  it("rejects read_failed, never null, when the read rejects", async () => {
+    db.offeringsCheckoutSession.findUnique.mockRejectedValueOnce(
+      new Error(`connection reset reading ${SESSION}`),
+    );
+    expect(await reasonOf(readCheckoutSessionRecord(SESSION))).toBe(
+      "read_failed",
+    );
+    expect(mockLogger.error).toHaveBeenCalledWith(
+      { reason: "checkout_record_read_failed" },
+      expect.any(String),
+    );
+  });
+
+  it("answers a corrupt row as unreadable, never null, and logs the reason alone", async () => {
+    db.__db.offeringsCheckoutSession = [
+      {
+        ...VALID,
+        id: "ocsess_01920000-8930-7000-8000-000000000001",
+        mode: "prod",
+        createdAt: new Date(),
+      },
+    ];
+    expect(await readCheckoutSessionRecord(SESSION)).toBe("unreadable");
+    expect(mockLogger.error).toHaveBeenCalledTimes(1);
+    expect(mockLogger.error).toHaveBeenCalledWith(
+      { reason: "checkout_record_unreadable" },
+      expect.any(String),
+    );
+  });
+});
+
+describe("recordCheckoutSession refuses before it writes (#8930 D4, AC-5)", () => {
+  // Not a literal at the call, so the type allows the key the parse refuses.
+  const withExtraKey = { ...VALID, email: "buyer@example.com" };
+  it.each<[string, CheckoutSessionRecordInput]>([
+    ["an unknown extra key", withExtraKey],
+    [
+      "a lookup key the parser refuses",
+      { ...VALID, lookupKey: "growth_quarterly" },
+    ],
+    ["a live mode on a test session", { ...VALID, mode: "live" }],
+    ["a malformed organization id", { ...VALID, organizationId: "org_1" }],
+  ])("refuses %s as invalid", async (_label, input) => {
+    expect(await reasonOf(recordCheckoutSession(input))).toBe("invalid");
+    expect(db.offeringsCheckoutSession.create).not.toHaveBeenCalled();
+    expect(db.workspace.findUnique).not.toHaveBeenCalled();
+  });
+
+  it("refuses another Organization's workspace as workspace_mismatch", async () => {
+    expect(
+      await reasonOf(recordCheckoutSession({ ...VALID, workspaceId: WS_B1 })),
+    ).toBe("workspace_mismatch");
+    expect(db.offeringsCheckoutSession.create).not.toHaveBeenCalled();
+  });
+
+  it("refuses a workspace with no row as workspace_mismatch", async () => {
+    expect(
+      await reasonOf(recordCheckoutSession({ ...VALID, workspaceId: WS_NONE })),
+    ).toBe("workspace_mismatch");
+    expect(db.offeringsCheckoutSession.create).not.toHaveBeenCalled();
+  });
+
+  it("refuses a second record of one session as conflict and keeps the first", async () => {
+    await recordCheckoutSession(VALID);
+    db.offeringsCheckoutSession.create.mockRejectedValueOnce(
+      Object.assign(new Error("Unique constraint failed"), { code: "P2002" }),
+    );
+    expect(
+      await reasonOf(recordCheckoutSession({ ...VALID, workspaceId: WS_A2 })),
+    ).toBe("conflict");
+    expect(await readCheckoutSessionRecord(SESSION)).toEqual({
+      ...VALID,
+      createdAt: expect.any(Date),
+    });
+  });
+
+  it("answers any other write error as write_failed, with no database message", async () => {
+    db.offeringsCheckoutSession.create.mockRejectedValueOnce(
+      new Error(
+        `new row for relation violates check constraint: (${SESSION}, ${PRICE}, ${KEY})`,
+      ),
+    );
+    expect(await reasonOf(recordCheckoutSession(VALID))).toBe("write_failed");
+    expect(mockLogger.error).toHaveBeenCalledWith(
+      { workspaceId: WS_A1, reason: "checkout_record_write_failed" },
+      expect.any(String),
+    );
+  });
+
+  it("answers a failed workspace lookup as write_failed, with no write", async () => {
+    db.workspace.findUnique.mockRejectedValueOnce(
+      new Error("connection reset"),
+    );
+    expect(await reasonOf(recordCheckoutSession(VALID))).toBe("write_failed");
+    expect(db.offeringsCheckoutSession.create).not.toHaveBeenCalled();
+  });
+});
+
+// "One file names the delegate" (#8930 D3, AC-6) runs `git grep`, which a
+// scaffold cannot: it lives in delegate-confinement.test.ts, kept out of the
+// template (#9179).