create-ailk 0.24.0 → 0.25.1

package/templates/database/__tests__/member-contract.db.test.ts

@@ -1,413 +0,0 @@
-/**
- * @file member-contract.db.test.ts
- *
- * LIVE-DATABASE proof of the member contract (#8168, spec
- * docs/specs/8168-member-area-data-model-spec.md D1–D3, D8, D9; AC-2, AC-4).
- * Requires DATABASE_URL pointing at a Postgres with the migrations applied —
- * the suite SKIPS when DATABASE_URL is unset, keeping the workspace Jest run
- * DB-free (the repo convention; the `apps/api Route Tests (Postgres)`
- * workflow exercises it).
- *
- * Uses the `pg` driver directly, as `member-area.db.test.ts` does. What it
- * proves that a mock cannot:
- *   1. Every CHECK the migration adds to `interactions` and `piece_versions`
- *      refuses its named shape, and an inbound `message` lands.
- *   2. A version can only name a piece of ITS OWN Person and workspace
- *      (piece_versions_piece_fk), and a version number is unique per piece.
- *   3. The request-quote backfill, re-executed VERBATIM from the migration
- *      file (the `flow-workspace-key.db.test.ts` technique), seeds a workspace
- *      that has no magnet, leaves a workspace's own `request-quote` row
- *      byte-for-byte, and adds nothing when run again. It runs inside a
- *      transaction that is rolled back, so no other suite sharing the
- *      database ever sees its rows.
- */
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-import { requestQuoteFlowConfig } from "@working-theory/validation";
-import { Client } from "pg";
-
-const describeDb = process.env.DATABASE_URL ? describe : describe.skip;
-
-const MIGRATION_SQL = readFileSync(
-  join(
-    __dirname,
-    "..",
-    "migrations",
-    "20261012120000_member_contract",
-    "migration.sql",
-  ),
-  "utf8",
-);
-
-/** The text between the `-- BEGIN request-quote backfill` / `-- END …` markers. */
-function backfillBlock(sql: string): string {
-  const match =
-    /-- BEGIN request-quote backfill\n([\s\S]*?)-- END request-quote backfill/.exec(
-      sql,
-    );
-  if (!match?.[1]) throw new Error("request-quote backfill markers not found");
-  return match[1];
-}
-
-describeDb("the member contract (#8168 D1–D3, AC-2, live DB)", () => {
-  let db: Client;
-  const WS_1 = "wksp_01920000-8168-7000-8000-0000000000b1";
-  const USER = "user_01920000-8168-7000-8000-0000000000b1";
-  const ASSET = "asset_01920000-8168-7000-8000-0000000000b1";
-  let person1: string;
-  let person2: string;
-  let piece1: string;
-
-  const cleanup = async () => {
-    await db.query(`DELETE FROM "piece_versions" WHERE "workspace_id" = $1`, [
-      WS_1,
-    ]);
-    await db.query(`DELETE FROM "interactions" WHERE "workspace_id" = $1`, [
-      WS_1,
-    ]);
-    await db.query(`DELETE FROM "pieces" WHERE "workspace_id" = $1`, [WS_1]);
-    await db.query(`DELETE FROM "people" WHERE "workspace_id" = $1`, [WS_1]);
-  };
-
-  beforeAll(async () => {
-    db = new Client({ connectionString: process.env.DATABASE_URL });
-    await db.connect();
-    await cleanup();
-    const insertPerson = (email: string) =>
-      db.query<{ id: string }>(
-        `INSERT INTO "people" ("workspace_id", "email", "updated_at") VALUES ($1, $2, now()) RETURNING "id"`,
-        [WS_1, email],
-      );
-    person1 = (await insertPerson("one@example.com")).rows[0]!.id;
-    person2 = (await insertPerson("two@example.com")).rows[0]!.id;
-    piece1 = (
-      await db.query<{ id: string }>(
-        `INSERT INTO "pieces" ("workspace_id", "person_id", "title", "stage", "updated_by", "updated_at")
-         VALUES ($1, $2, 'Homepage copy', 'writing', $3, now()) RETURNING "id"`,
-        [WS_1, person1, USER],
-      )
-    ).rows[0]!.id;
-  });
-
-  afterAll(async () => {
-    await cleanup();
-    await db.end();
-  });
-
-  type InteractionCols = {
-    direction?: string;
-    kind?: string;
-    subject?: string;
-    body?: string;
-    payload?: unknown;
-  };
-  const insertInteraction = (cols: InteractionCols = {}) =>
-    db.query<{ id: string; kind: string }>(
-      `INSERT INTO "interactions" ("workspace_id", "person_id", "channel", "direction", "kind", "subject", "body", "payload", "created_by")
-       VALUES ($1, $2, 'member', $3, $4, $5, $6, $7, $8) RETURNING "id", "kind"`,
-      [
-        WS_1,
-        person1,
-        cols.direction ?? "inbound",
-        cols.kind ?? "message",
-        cols.subject ?? "A question",
-        cols.body ?? "Can we talk?",
-        cols.payload === undefined ? null : JSON.stringify(cols.payload),
-        USER,
-      ],
-    );
-
-  const quotePayload = {
-    flowSlug: "request-quote",
-    items: [{ name: "need", label: "What do you need?", value: "A homepage" }],
-  };
-
-  it("an existing outbound row keeps kind `message` by default, and an inbound message lands", async () => {
-    const outbound = await db.query<{ kind: string }>(
-      `INSERT INTO "interactions" ("workspace_id", "person_id", "channel", "direction", "subject", "body", "created_by")
-       VALUES ($1, $2, 'member', 'outbound', 'Draft 1', 'Here it is', $3) RETURNING "kind"`,
-      [WS_1, person1, USER],
-    );
-    expect(outbound.rows[0]!.kind).toBe("message");
-    const inbound = await insertInteraction();
-    expect(inbound.rows[0]!.id).toMatch(/^intx_/);
-    const withLink = await insertInteraction({
-      payload: { link: "https://example.com" },
-    });
-    expect(withLink.rows[0]!.kind).toBe("message");
-  });
-
-  it("an inbound quote and review with a payload and an empty body land", async () => {
-    await insertInteraction({
-      kind: "quote",
-      subject: "Request a quote",
-      body: "",
-      payload: quotePayload,
-    });
-    await insertInteraction({
-      kind: "review",
-      subject: "Homepage copy",
-      body: "",
-      payload: { pieceId: piece1, version: 1, review: "approved" },
-    });
-  });
-
-  it.each([
-    [
-      "an outbound quote",
-      { direction: "outbound", kind: "quote", payload: quotePayload },
-      "interactions_outbound_shape",
-    ],
-    [
-      "an outbound message with a payload",
-      { direction: "outbound", payload: { link: "https://example.com" } },
-      "interactions_outbound_shape",
-    ],
-    [
-      "a quote with no payload",
-      { kind: "quote", body: "" },
-      "interactions_payload_by_kind",
-    ],
-    [
-      "a review with no payload",
-      { kind: "review", body: "" },
-      "interactions_payload_by_kind",
-    ],
-    ["an empty-body message", { body: "" }, "interactions_body_length"],
-    ["an all-space message body", { body: "   " }, "interactions_body_length"],
-    [
-      "a quote body over 10000 characters",
-      { kind: "quote", body: "b".repeat(10001), payload: quotePayload },
-      "interactions_body_length",
-    ],
-    ["kind `note`", { kind: "note" }, "interactions_kind_allowed"],
-    [
-      "direction `sideways`",
-      { direction: "sideways" },
-      "interactions_direction_allowed",
-    ],
-    [
-      "a quote whose payload is over 262144 bytes",
-      {
-        kind: "quote",
-        body: "",
-        payload: { ...quotePayload, pad: "x".repeat(262144) },
-      },
-      "interactions_payload_size",
-    ],
-  ])("refuses %s", async (_label, cols, constraint) => {
-    await expect(insertInteraction(cols)).rejects.toMatchObject({
-      code: "23514",
-      constraint,
-    });
-  });
-
-  type VersionCols = {
-    person_id?: string;
-    piece_id?: string;
-    version?: number;
-    asset_id?: string | null;
-    link?: string | null;
-    note?: string | null;
-    review?: string | null;
-    review_comment?: string | null;
-    reviewed_at?: string | null;
-  };
-  const insertVersion = (cols: VersionCols = {}) =>
-    db.query<{ id: string }>(
-      `INSERT INTO "piece_versions" ("workspace_id", "person_id", "piece_id", "version", "asset_id", "link", "note", "delivered_by", "review", "review_comment", "reviewed_at")
-       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) RETURNING "id"`,
-      [
-        WS_1,
-        cols.person_id ?? person1,
-        cols.piece_id ?? piece1,
-        cols.version ?? 99,
-        cols.asset_id === undefined ? null : cols.asset_id,
-        cols.link === undefined ? "https://example.com/draft" : cols.link,
-        cols.note ?? null,
-        USER,
-        cols.review ?? null,
-        cols.review_comment ?? null,
-        cols.reviewed_at ?? null,
-      ],
-    );
-
-  it("mints a pver_ id and accepts a file version and a reviewed link version", async () => {
-    const file = await insertVersion({
-      version: 1,
-      asset_id: ASSET,
-      link: null,
-    });
-    expect(file.rows[0]!.id).toMatch(/^pver_[0-9a-f-]{36}$/);
-    await insertVersion({
-      version: 2,
-      note: "Second pass",
-      review: "changes-requested",
-      review_comment: "Shorter, please",
-      reviewed_at: new Date().toISOString(),
-    });
-  });
-
-  it.each([
-    [
-      "both a file and a link",
-      { asset_id: ASSET },
-      "piece_versions_one_target",
-    ],
-    ["neither a file nor a link", { link: null }, "piece_versions_one_target"],
-    [
-      "an http:// link",
-      { link: "http://example.com" },
-      "piece_versions_link_https",
-    ],
-    [
-      "an https://user@host link",
-      { link: "https://user@example.com" },
-      "piece_versions_link_https",
-    ],
-    [
-      "a link containing a space",
-      { link: "https://example.com/a b" },
-      "piece_versions_link_https",
-    ],
-    ["version 0", { version: 0 }, "piece_versions_version_positive"],
-    ["an all-space note", { note: "  " }, "piece_versions_note_length"],
-    [
-      "review `rejected`",
-      { review: "rejected", reviewed_at: "2026-10-10T00:00:00Z" },
-      "piece_versions_review_allowed",
-    ],
-    [
-      "changes-requested without a comment",
-      { review: "changes-requested", reviewed_at: "2026-10-10T00:00:00Z" },
-      "piece_versions_changes_need_comment",
-    ],
-    [
-      "a review without reviewed_at",
-      { review: "approved" },
-      "piece_versions_review_stamped",
-    ],
-    [
-      "a comment without a review",
-      { review_comment: "Hmm" },
-      "piece_versions_comment_needs_review",
-    ],
-    [
-      "a 5001-character comment",
-      {
-        review: "approved",
-        review_comment: "c".repeat(5001),
-        reviewed_at: "2026-10-10T00:00:00Z",
-      },
-      "piece_versions_comment_length",
-    ],
-    [
-      "a lead_ asset id",
-      { asset_id: "lead_01920000-8168-7000-8000-0000000000b1", link: null },
-      "piece_versions_asset_id_format",
-    ],
-  ])("refuses a version with %s", async (_label, cols, constraint) => {
-    await expect(insertVersion(cols)).rejects.toMatchObject({
-      code: "23514",
-      constraint,
-    });
-  });
-
-  it("refuses a version naming another Person's piece (the three-column FK)", async () => {
-    await expect(
-      insertVersion({ person_id: person2, version: 50 }),
-    ).rejects.toMatchObject({
-      code: "23503",
-      constraint: "piece_versions_piece_fk",
-    });
-  });
-
-  it("refuses a second version 1 of one piece", async () => {
-    await expect(insertVersion({ version: 1 })).rejects.toMatchObject({
-      code: "23505",
-      constraint: "piece_versions_piece_id_version_key",
-    });
-  });
-
-  it("refuses to delete a piece that has a version (RESTRICT)", async () => {
-    await expect(
-      db.query(`DELETE FROM "pieces" WHERE "id" = $1`, [piece1]),
-    ).rejects.toMatchObject({
-      code: "23503",
-      constraint: "piece_versions_piece_fk",
-    });
-  });
-});
-
-describeDb("the request-quote backfill (#8168 D8, D9, AC-4, live DB)", () => {
-  let db: Client;
-  const ORG = "org_01920000-8168-7000-8000-0000000000c1";
-  const WS_NEW = "wksp_01920000-8168-7000-8000-0000000000c1";
-  const WS_OWNS = "wksp_01920000-8168-7000-8000-0000000000c2";
-  const block = backfillBlock(MIGRATION_SQL);
-
-  beforeAll(async () => {
-    db = new Client({ connectionString: process.env.DATABASE_URL });
-    await db.connect();
-  });
-
-  afterAll(async () => {
-    await db.end();
-  });
-
-  const magnets = (workspaceId: string) =>
-    db.query<Record<string, unknown>>(
-      `SELECT * FROM "flow_definitions" WHERE "workspace_id" = $1 AND "slug" = 'request-quote'`,
-      [workspaceId],
-    );
-
-  it("seeds a workspace with no magnet, leaves a workspace's own row untouched, and adds nothing on re-run", async () => {
-    await db.query("BEGIN");
-    try {
-      await db.query(
-        `INSERT INTO "organizations" ("id", "name", "slug", "updated_at") VALUES ($1, 'O', $2, now())`,
-        [ORG, `o-8168-${Date.now()}`],
-      );
-      await db.query(
-        `INSERT INTO "workspaces" ("id", "organization_id", "name", "slug", "updated_at")
-         VALUES ($1, $3, 'New', 'new', now()), ($2, $3, 'Owns', 'owns', now())`,
-        [WS_NEW, WS_OWNS, ORG],
-      );
-      await db.query(
-        `INSERT INTO "flow_definitions" ("site_id", "workspace_id", "slug", "config", "kind", "title", "status", "updated_at")
-         VALUES ($1, $1, 'request-quote', '{"mine":true}', 'diagnostic', 'Theirs', 'live', now())`,
-        [WS_OWNS],
-      );
-      const before = (await magnets(WS_OWNS)).rows;
-
-      await db.query(block);
-
-      const seeded = (await magnets(WS_NEW)).rows;
-      expect(seeded).toHaveLength(1);
-      expect(seeded[0]).toMatchObject({
-        site_id: WS_NEW,
-        workspace_id: WS_NEW,
-        kind: "contact",
-        title: "Request a quote",
-        status: "draft",
-        customers_enabled: true,
-        config: requestQuoteFlowConfig,
-      });
-      expect((await magnets(WS_OWNS)).rows).toEqual(before);
-
-      const { rows: total } = await db.query<{ n: string }>(
-        `SELECT count(*)::text AS "n" FROM "flow_definitions" WHERE "slug" = 'request-quote'`,
-      );
-      await db.query(block);
-      const { rows: again } = await db.query<{ n: string }>(
-        `SELECT count(*)::text AS "n" FROM "flow_definitions" WHERE "slug" = 'request-quote'`,
-      );
-      expect(again[0]!.n).toBe(total[0]!.n);
-      expect((await magnets(WS_NEW)).rows).toEqual(seeded);
-      expect((await magnets(WS_OWNS)).rows).toEqual(before);
-    } finally {
-      await db.query("ROLLBACK");
-    }
-  });
-});

package/templates/database/__tests__/offerings-checkout-session.db.test.ts

@@ -1,270 +0,0 @@
-/**
- * @file offerings-checkout-session.db.test.ts
- *
- * LIVE-DATABASE proof of the Offerings Checkout session record's table (#8930,
- * spec docs/specs/8930-the-offerings-checkout-session-record-spec.md D1, D2,
- * AC-1, AC-2, AC-3; contract A11). Requires DATABASE_URL pointing at a Postgres
- * with the migrations applied — SKIPS when DATABASE_URL is unset (the repo
- * convention; the `apps/api Route Tests (Postgres)` workflow exercises it).
- *
- * Uses the `pg` driver directly, in ONE transaction that is rolled back, so no
- * row outlives the suite. Each refusal runs in its own savepoint and names the
- * constraint Postgres reports, so a refusal for the wrong reason fails.
- */
-import { idRegex } from "@working-theory/ids";
-import { parseLookupKey } from "@working-theory/validation";
-import { Client } from "pg";
-
-const describeDb = process.env.DATABASE_URL ? describe : describe.skip;
-
-const TABLE = "offerings_checkout_sessions";
-const ORG = "org_01920000-8930-7000-8000-0000000000a1";
-const WS = "wksp_01920000-8930-7000-8000-0000000000b1";
-
-/** The one valid row every refusal changes a single column of. */
-const VALID: Record<string, unknown> = {
-  session_id: "cs_test_a1",
-  workspace_id: WS,
-  organization_id: ORG,
-  price_id: "price_1Abc",
-  lookup_key: "growth_monthly",
-  mode: "test",
-};
-
-/** The eight CHECKs D2 names, and nothing else. */
-const CHECKS = [
-  "offerings_checkout_sessions_id_format",
-  "offerings_checkout_sessions_session_id_format",
-  "offerings_checkout_sessions_workspace_id_format",
-  "offerings_checkout_sessions_organization_id_format",
-  "offerings_checkout_sessions_price_id_format",
-  "offerings_checkout_sessions_lookup_key_format",
-  "offerings_checkout_sessions_mode_domain",
-  "offerings_checkout_sessions_session_mode_agree",
-];
-
-describeDb(
-  "the Offerings Checkout session record (#8930 D1, D2, live DB)",
-  () => {
-    let db: Client;
-
-    beforeAll(async () => {
-      db = new Client({ connectionString: process.env.DATABASE_URL });
-      await db.connect();
-      await db.query("BEGIN");
-    });
-
-    afterAll(async () => {
-      await db.query("ROLLBACK");
-      await db.end();
-    });
-
-    /** Run `run` inside a savepoint; resolve to the violated constraint's name, or null. */
-    const violation = async (
-      run: () => Promise<unknown>,
-    ): Promise<string | null> => {
-      await db.query("SAVEPOINT attempt");
-      try {
-        await run();
-        await db.query("ROLLBACK TO SAVEPOINT attempt");
-        return null;
-      } catch (err) {
-        await db.query("ROLLBACK TO SAVEPOINT attempt");
-        return (err as { constraint?: string }).constraint ?? String(err);
-      }
-    };
-
-    /** Insert one record: the valid row with `cols` over it. */
-    const insert = (cols: Record<string, unknown> = {}) => {
-      const all = { ...VALID, ...cols };
-      const names = Object.keys(all);
-      return db.query(
-        `INSERT INTO "${TABLE}" (${names.map((n) => `"${n}"`).join(", ")})
-       VALUES (${names.map((_, i) => `$${i + 1}`).join(", ")}) RETURNING "id"`,
-        names.map((n) => all[n]),
-      );
-    };
-
-    describe("AC-1 — exactly the record's columns", () => {
-      it("has the eight columns, each NOT NULL", async () => {
-        const { rows } = await db.query(
-          `SELECT column_name, is_nullable FROM information_schema.columns
-         WHERE table_schema = current_schema() AND table_name = $1 ORDER BY column_name`,
-          [TABLE],
-        );
-        expect(rows.map((r) => r.column_name)).toEqual([
-          "created_at",
-          "id",
-          "lookup_key",
-          "mode",
-          "organization_id",
-          "price_id",
-          "session_id",
-          "workspace_id",
-        ]);
-        expect(rows.filter((r) => r.is_nullable !== "NO")).toEqual([]);
-      });
-
-      it("carries exactly D2's eight CHECKs", async () => {
-        const { rows } = await db.query(
-          `SELECT conname FROM pg_constraint
-         WHERE conrelid = $1::regclass AND contype = 'c' ORDER BY conname`,
-          [TABLE],
-        );
-        expect(rows.map((r) => r.conname)).toEqual([...CHECKS].sort());
-      });
-
-      it("has one non-primary index: the unique session id key", async () => {
-        const { rows } = await db.query(
-          `SELECT i.relname AS name, x.indisunique AS unique FROM pg_index x
-         JOIN pg_class i ON i.oid = x.indexrelid
-         WHERE x.indrelid = $1::regclass AND NOT x.indisprimary`,
-          [TABLE],
-        );
-        expect(rows).toEqual([
-          { name: "offerings_checkout_sessions_session_id_key", unique: true },
-        ]);
-      });
-    });
-
-    describe("AC-2 — Postgres refuses each malformed row by the named constraint", () => {
-      it("accepts the valid row and mints a prefixed id", async () => {
-        await db.query("SAVEPOINT ok");
-        const { rows } = await insert();
-        expect(rows[0].id).toMatch(idRegex("offeringsCheckoutSession"));
-        await db.query("ROLLBACK TO SAVEPOINT ok");
-      });
-
-      it("accepts a live record of a live session", async () => {
-        expect(
-          await violation(() =>
-            insert({ session_id: "cs_live_a1", mode: "live" }),
-          ),
-        ).toBeNull();
-      });
-
-      it.each([
-        [
-          "a charge id",
-          { session_id: "ch_test_a1" },
-          "offerings_checkout_sessions_session_id_format",
-        ],
-        [
-          "a session id with no body",
-          { session_id: "cs_test_" },
-          "offerings_checkout_sessions_session_id_format",
-        ],
-        [
-          "a session id with a dash",
-          { session_id: "cs_test_a-1" },
-          "offerings_checkout_sessions_session_id_format",
-        ],
-        [
-          "a workspace id of another shape",
-          { workspace_id: "ws_1" },
-          "offerings_checkout_sessions_workspace_id_format",
-        ],
-        [
-          "an organization id of another shape",
-          { organization_id: "org_1" },
-          "offerings_checkout_sessions_organization_id_format",
-        ],
-        [
-          "an empty Price id",
-          { price_id: "" },
-          "offerings_checkout_sessions_price_id_format",
-        ],
-        [
-          "a Price id with a space",
-          { price_id: "price 1" },
-          "offerings_checkout_sessions_price_id_format",
-        ],
-        [
-          "an uppercase lookup key",
-          { lookup_key: "Growth_Monthly" },
-          "offerings_checkout_sessions_lookup_key_format",
-        ],
-        [
-          "a 41-character plan inside the column width",
-          { lookup_key: `${"a".repeat(41)}_once` },
-          "offerings_checkout_sessions_lookup_key_format",
-        ],
-        [
-          "a mode of prod",
-          { mode: "prod" },
-          "offerings_checkout_sessions_mode_domain",
-        ],
-        [
-          "a live record of a test session",
-          { mode: "live" },
-          "offerings_checkout_sessions_session_mode_agree",
-        ],
-        [
-          "a test record of a live session",
-          { session_id: "cs_live_a1" },
-          "offerings_checkout_sessions_session_mode_agree",
-        ],
-        [
-          "an id of another shape",
-          { id: "ocsess_1" },
-          "offerings_checkout_sessions_id_format",
-        ],
-      ])("refuses %s", async (_label, cols, constraint) => {
-        expect(await violation(() => insert(cols))).toBe(constraint);
-      });
-
-      it("refuses a second record of one session", async () => {
-        expect(
-          await violation(async () => {
-            await insert();
-            await insert({ price_id: "price_2Def" });
-          }),
-        ).toBe("offerings_checkout_sessions_session_id_key");
-      });
-    });
-
-    describe("AC-3 — the lookup-key CHECK accepts exactly what parseLookupKey accepts", () => {
-      const CORPUS = [
-        // Contract §3.7's worked examples.
-        "growth_monthly",
-        "growth_yearly",
-        "basic_once",
-        "samhenry-coaching_monthly",
-        "growth_quarterly",
-        "growth_pro_monthly",
-        "Growth_Monthly",
-        "wendi_retainer",
-        // The anchors, the plan's first character, and its length bound.
-        "-growth_monthly",
-        "growth-_once",
-        "growth_monthly ",
-        "growth_monthly\n",
-        "_monthly",
-        `${"a".repeat(40)}_yearly`,
-        `${"a".repeat(41)}_monthly`,
-        // 46 characters: inside VARCHAR(48), so only the CHECK can refuse it.
-        `${"a".repeat(41)}_once`,
-      ];
-
-      it("the corpus holds keys each side accepts and keys each side refuses", () => {
-        const accepted = CORPUS.filter((key) => parseLookupKey(key) !== null);
-        expect(accepted).toEqual([
-          "growth_monthly",
-          "growth_yearly",
-          "basic_once",
-          "samhenry-coaching_monthly",
-          "growth-_once",
-          `${"a".repeat(40)}_yearly`,
-        ]);
-      });
-
-      it.each(CORPUS.map((key) => [JSON.stringify(key), key]))(
-        "inserts %s if and only if the parser accepts it",
-        async (_label, key) => {
-          const refused = await violation(() => insert({ lookup_key: key }));
-          expect(refused === null).toBe(parseLookupKey(key) !== null);
-        },
-      );
-    });
-  },
-);