create-ailk 0.23.0 → 0.25.1

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

@@ -1,268 +0,0 @@
-/**
- * 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).