@workerstack/testing 0.0.0-stage → 0.31.0

package/dist/api/conformance/suites/tenant-scope.js

@@ -0,0 +1,125 @@
+import { messageOf } from "../../errors/message.js";
+import { run } from "../harness/counting.js";
+import { launch, reach } from "../harness/launch.js";
+import { PRINCIPALS, SECURITY } from "../matrix/principals.js";
+import { publicCatalog } from "./public-catalog.js";
+/** One principal per workspace, each with the token the catalog knows it by. */
+const CATALOG_PRINCIPALS = {
+    alpha: { scope: { workspace_id: "ws_a" }, tenant: "ws_a", token: "tok_alpha" },
+    beta: { scope: { workspace_id: "ws_b" }, tenant: "ws_b", token: "tok_beta" },
+};
+/** testing api run once against a fresh public catalog. */
+async function catalogRun(via) {
+    const hosted = await via.host(publicCatalog());
+    try {
+        return await run({
+            baseUrl: hosted.url,
+            principals: CATALOG_PRINCIPALS,
+            security: { bearer: { static: "{principal.token}" } },
+            seed: 42,
+            spec: `${hosted.url}/v1/openapi/spec`,
+            ...reach(hosted),
+        });
+    }
+    finally {
+        await hosted.close();
+    }
+}
+/* A check that must not apply to the catalog: skipped, not run, and no finding from any of `checks`. */
+function standsDown(result, check, checks) {
+    const hits = result.findings.filter((f) => checks.includes(f.check));
+    const skipped = result.checksSkipped.some((s) => s.check === check);
+    const ran = result.checksRun.includes(check);
+    const ok = hits.length === 0 && skipped && !ran;
+    return {
+        detail: ok
+            ? "check did not apply; no finding"
+            : `findings=${hits.map((f) => `${f.verdict}:${f.check}`).join(",") || "none"}; ` +
+                `ran=${String(ran)}; skipped=${String(skipped)}`,
+        ok,
+    };
+}
+/** The verdict `check` reaches against the reference with `defect` injected, tagged or not. */
+async function leakVerdict(via, leak) {
+    const backend = await launch({ backend: "memory", dialect: "postgrest", via }, { defects: [leak.defect], untagged: leak.untagged });
+    try {
+        const result = await run({
+            baseUrl: backend.url,
+            only: ["table"],
+            principals: PRINCIPALS,
+            security: SECURITY,
+            seed: 42,
+            spec: `${backend.url}/v1/openapi/spec`,
+            ...reach(backend),
+        });
+        return result.findings.find((f) => f.check === leak.check)?.verdict ?? null;
+    }
+    finally {
+        await backend.close();
+    }
+}
+function leakCase(name, why, leak) {
+    const want = leak.untagged ? "AMBIGUITY" : "SECURITY";
+    return {
+        name,
+        probe: async (via) => {
+            const verdict = await leakVerdict(via, leak);
+            return {
+                detail: verdict === want ? want : `expected ${want}, got ${verdict ?? "no finding"}`,
+                ok: verdict === want,
+            };
+        },
+        why,
+    };
+}
+const ITEM = "tenant.item-not-readable-cross-tenant";
+const FILTER = "tenant.filter-does-not-bypass-scope";
+const STATED = "x-tenant + 200 from the other principal is a stated-boundary breach";
+const INFERRED = "workspace_id / project_id still infers a tenant when x-tenant is stripped";
+/**
+ * A public catalog is unscoped. Two principals, create as A, GET or filter as B → 200 is the
+ * contract, and the isolation checks must not apply. The workspace-scoped widget fixture is
+ * unchanged: tag → SECURITY, heuristic → AMBIGUITY. Same split for item GET and for
+ * `filter=id.eq.<other tenant>`.
+ */
+const CASES = [
+    {
+        name: "public catalog 200 is not a finding",
+        probe: async (via) => standsDown(await catalogRun(via), ITEM, [ITEM, "tenant.denial-does-not-reveal-existence"]),
+        why: "no x-tenant and template_id is not a tenant name, so isolation does not apply",
+    },
+    /* @__PURE__ */ leakCase("tagged tenant leak is SECURITY", STATED, {
+        check: ITEM,
+        defect: "CROSS_TENANT_READ",
+        untagged: false,
+    }),
+    /* @__PURE__ */ leakCase("inferred tenant leak is AMBIGUITY", INFERRED, {
+        check: ITEM,
+        defect: "CROSS_TENANT_READ",
+        untagged: true,
+    }),
+    {
+        name: "public catalog filter 200 is not a finding",
+        probe: async (via) => standsDown(await catalogRun(via), FILTER, [FILTER]),
+        why: "no x-tenant and no tenant-named path param, so a 200 on id.eq.<other row> is the contract",
+    },
+    /* @__PURE__ */ leakCase("tagged tenant filter leak is SECURITY", "x-tenant + filter 200 of the other tenant's row is a stated-boundary breach", { check: FILTER, defect: "TENANT_LEAK_VIA_FILTER", untagged: false }),
+    /* @__PURE__ */ leakCase("inferred tenant filter leak is AMBIGUITY", INFERRED, {
+        check: FILTER,
+        defect: "TENANT_LEAK_VIA_FILTER",
+        untagged: true,
+    }),
+];
+export async function runTenantScopeSuite(via) {
+    const results = [];
+    for (const { name, why, probe } of CASES) {
+        try {
+            results.push({ ...(await probe(via)), name, why });
+        }
+        catch (error) {
+            results.push({ detail: messageOf(error), name, ok: false, why });
+        }
+    }
+    return results;
+}
+//# sourceMappingURL=tenant-scope.js.map

package/dist/api/conformance/tasks.d.ts

@@ -0,0 +1,70 @@
+import type { DefectName } from "../reference/defects/table.ts";
+import { type Requests } from "./harness/counting.ts";
+import { type ShapeCase } from "./shapes.ts";
+import type { Via } from "./harness/launch.ts";
+import type { ParserResult } from "./harness/result.ts";
+import { type CaseResult } from "./matrix/cases.ts";
+import type { Backend } from "./matrix/engines.ts";
+export type ConformanceTask = {
+    kind: "baselines";
+    backend: Backend;
+    dialect: string;
+} | {
+    kind: "defects";
+    backend: Backend;
+    dialect: string;
+    defects: DefectName[];
+} | {
+    kind: "shape-reference";
+} | {
+    kind: "shape";
+    name: string;
+    reference: string[] | null;
+} | {
+    kind: "recall";
+    shape: string;
+    defects: DefectName[];
+} | {
+    kind: "scope";
+    defects: string[];
+    known: Record<string, string[]>;
+};
+/** What a worker held after a task, in bytes. */
+export interface MemoryUse {
+    rss: number;
+    heapUsed: number;
+}
+export type ConformanceAnswer = ({
+    kind: "cases";
+    cases: ShapeCase[];
+} | {
+    kind: "leg";
+    results: CaseResult[];
+} | {
+    kind: "results";
+    results: ParserResult[];
+} | {
+    kind: "reference";
+    checks: string[] | null;
+}) & {
+    memory: MemoryUse;
+    requests: Requests;
+};
+/** The answer a task gets. */
+export type AnswerFor<T extends ConformanceTask> = Extract<ConformanceAnswer, {
+    kind: T extends {
+        kind: "shape" | "recall";
+    } ? "cases" : T extends {
+        kind: "scope";
+    } ? "results" : T extends {
+        kind: "shape-reference";
+    } ? "reference" : "leg";
+}>;
+/**
+ * Runs a task, then measures what the process holds. With `TESTING_API_HEAP_SNAPSHOTS` set to a folder,
+ * a heap snapshot is written there after each task: what a leg left behind is in the next one.
+ * `via` says how the reference is reached: the gate's workers reach it behind a socket. Every request
+ * the task sends through it is counted.
+ */
+export declare function runTask(task: ConformanceTask, sequence: number, via: Via): Promise<ConformanceAnswer>;
+//# sourceMappingURL=tasks.d.ts.map

package/dist/api/conformance/tasks.js

@@ -0,0 +1,53 @@
+/*
+ * The conformance pool's protocol: a task is a slice of a leg, small enough that the pool can
+ * spread a long leg across its workers, and its answer is plain data the parent assembles and
+ * prints in order. Every answer says how much memory its worker held after the task, and how many
+ * requests the task sent, by source.
+ */
+import { writeHeapSnapshot } from "node:v8";
+import { join } from "node:path";
+import { counting } from "./harness/counting.js";
+import { runScopeSuite } from "./scope.js";
+import { judgeShape, recallBehind, shapeReference, shapeTarget } from "./shapes.js";
+import { judgeDefect, portableResult, runBaselines } from "./matrix/cases.js";
+async function answered(task, via) {
+    const shapes = shapeTarget("memory", via);
+    switch (task.kind) {
+        case "baselines": {
+            const results = await runBaselines({ backend: task.backend, dialect: task.dialect, via });
+            return { kind: "leg", results: results.map(portableResult) };
+        }
+        case "defects": {
+            const results = [];
+            for (const defect of task.defects) {
+                const target = { backend: task.backend, dialect: task.dialect, via };
+                results.push(portableResult(await judgeDefect(defect, target)));
+            }
+            return { kind: "leg", results };
+        }
+        case "shape-reference":
+            return { checks: await shapeReference(shapes), kind: "reference" };
+        case "shape":
+            return { cases: [await judgeShape(shapes, task.name, task.reference)], kind: "cases" };
+        case "recall":
+            return { cases: await recallBehind(shapes, task.shape, task.defects), kind: "cases" };
+        case "scope":
+            return { kind: "results", results: await runScopeSuite(via, task.defects, task.known) };
+    }
+}
+/**
+ * Runs a task, then measures what the process holds. With `TESTING_API_HEAP_SNAPSHOTS` set to a folder,
+ * a heap snapshot is written there after each task: what a leg left behind is in the next one.
+ * `via` says how the reference is reached: the gate's workers reach it behind a socket. Every request
+ * the task sends through it is counted.
+ */
+export async function runTask(task, sequence, via) {
+    const counted = counting(via);
+    const answer = await answered(task, counted.via);
+    const dir = process.env["TESTING_API_HEAP_SNAPSHOTS"];
+    if (dir !== undefined && dir !== "")
+        writeHeapSnapshot(join(dir, `${process.pid}-${String(sequence).padStart(4, "0")}-${task.kind}.heapsnapshot`));
+    const { heapUsed, rss } = process.memoryUsage();
+    return { ...answer, memory: { heapUsed, rss }, requests: counted.requests() };
+}
+//# sourceMappingURL=tasks.js.map

package/dist/api/conformance/unique/backend.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The backend behind the unique suite: widgets under one org, which enforces the document's
+ * `x-unique` sets the way a case asks — a 409, an insert anyway, a gate, a plan limit, or a 409
+ * whose body drifts from the document.
+ */
+import type { Handle } from "../../reference/http/node.ts";
+import type { RunResult } from "../../runtime/run/types.ts";
+import { type Via } from "../harness/launch.ts";
+import { type SpecOptions } from "./spec.ts";
+/** How a duplicate create is answered. */
+export type DuplicateMode = "409" | "201" | "per-set" | "gate-403" | "402" | "409-drift";
+export interface HarnessOptions {
+    spec: SpecOptions;
+    /** The first create is refused as a duplicate. */
+    seedConflict?: boolean;
+    /** A widget is listed before the API tester creates any. */
+    listSeeded?: boolean;
+    duplicate?: DuplicateMode;
+    /** How a colliding update is answered: refused with a 409 (the default), or applied. */
+    updateDuplicate?: "409" | "201" | "ok";
+}
+/** A write as the backend received it. */
+export interface Post {
+    headers: Readonly<Record<string, string>>;
+    body: unknown;
+}
+interface Row {
+    email: string;
+    id: string;
+    name: string;
+    slug: string;
+}
+/** A row about to be written: its values, and its own id when it already exists. */
+export interface Candidate {
+    values: Record<string, unknown>;
+    id?: string;
+}
+/** The first set the candidate collides on with a row other than itself, or null. */
+export declare function conflict(sets: string[][], existing: Row[], candidate: Candidate): string[] | null;
+/** A fresh backend for `options`, and every write it is sent. */
+export declare function widgetBackend(options: HarnessOptions): {
+    handle: Handle;
+    posts: Post[];
+};
+/** What one run against the harness saw. */
+export interface Outcome {
+    result: Pick<RunResult, "checksRun" | "entitiesTested" | "findings">;
+    posts: Post[];
+}
+/** testing api run once, on the widget entity alone, against a fresh harness reached through `via`. */
+export declare function against(via: Via, options: HarnessOptions): Promise<Outcome>;
+export {};
+//# sourceMappingURL=backend.d.ts.map

package/dist/api/conformance/unique/backend.js

@@ -0,0 +1,152 @@
+/**
+ * The backend behind the unique suite: widgets under one org, which enforces the document's
+ * `x-unique` sets the way a case asks — a 409, an insert anyway, a gate, a plan limit, or a 409
+ * whose body drifts from the document.
+ */
+import { bearer } from "../../reference/http/access.js";
+import { run } from "../harness/counting.js";
+import { readUnique } from "../../spec/extensions/unique.js";
+import { reach } from "../harness/launch.js";
+import { answer, guarded, readJson } from "../harness/serve.js";
+import { widgetSpec } from "./spec.js";
+const COLLECTION = "/v1/orgs/org_1/widgets";
+const ITEM = /^\/v1\/orgs\/org_1\/widgets\/[^/]+$/;
+const conflicted = () => answer(409, { error_key: "conflict", status: 409 });
+const notFound = () => answer(404, { error_key: "not_found" });
+/** The first set the candidate collides on with a row other than itself, or null. */
+export function conflict(sets, existing, candidate) {
+    const { values: incoming, id: exceptId } = candidate;
+    for (const set of sets) {
+        const hit = existing.find((row) => row.id !== exceptId &&
+            set.every((col) => incoming[col] !== undefined && String(row[col]) === String(incoming[col])));
+        if (hit !== undefined)
+            return set;
+    }
+    return null;
+}
+/** What a duplicate create gets, per mode; null inserts it anyway. */
+const ON_DUPLICATE = {
+    "201": () => null,
+    "402": () => answer(402, { error_key: "payment_required" }),
+    "409": conflicted,
+    "409-drift": () => answer(409, { oops: true }),
+    "gate-403": (state) => answer(403, {
+        error_key: "forbidden",
+        vars: { feature: state.options.spec.featureGate ?? "widgets", type: "feature_gate" },
+    }),
+    "per-set": (_, colliding) => (colliding.includes("name") || colliding.includes("email") ? conflicted() : null),
+};
+async function received(state, request) {
+    const body = ((await readJson(request)) ?? {});
+    state.posts.push({ body, headers: { ...request.headers } });
+    return body;
+}
+function text(value, fallback) {
+    return typeof value === "string" ? value : fallback;
+}
+async function create(state, request) {
+    const body = await received(state, request);
+    if (state.options.seedConflict === true && state.posts.length === 1)
+        return conflicted();
+    const colliding = conflict(state.sets, [...state.rows.values()], { values: body });
+    const refused = colliding === null ? null : ON_DUPLICATE[state.options.duplicate ?? "409"](state, colliding);
+    if (refused !== null)
+        return refused;
+    state.seq += 1;
+    const id = `w_${String(state.seq)}`;
+    const row = {
+        email: text(body["email"], `${id}@example.test`),
+        id,
+        name: text(body["name"], id),
+        slug: text(body["slug"], id),
+    };
+    state.rows.set(id, row);
+    return answer(201, row);
+}
+async function update(state, id, request) {
+    const row = state.rows.get(id);
+    if (row === undefined)
+        return notFound();
+    const body = await received(state, request);
+    const colliding = conflict(state.sets, [...state.rows.values()], { id, values: { ...row, ...body } });
+    if (colliding !== null && (state.options.updateDuplicate ?? "409") === "409")
+        return conflicted();
+    row.email = text(body["email"], row.email);
+    row.name = text(body["name"], row.name);
+    row.slug = text(body["slug"], row.slug);
+    return answer(200, row);
+}
+/** What each method does to one widget; any other method finds nothing. */
+const ON_ITEM = {
+    DELETE: (state, id) => {
+        state.rows.delete(id);
+        return answer(204);
+    },
+    GET: (state, id) => {
+        const row = state.rows.get(id);
+        return row === undefined ? notFound() : answer(200, row);
+    },
+    PATCH: update,
+};
+function route(state, request) {
+    const { pathname } = request.url;
+    if (pathname === "/v1/openapi/spec" && request.method === "GET")
+        return answer(200, state.spec);
+    if (bearer(request) === undefined)
+        return answer(401, { error_key: "unauthorized" });
+    if (pathname === COLLECTION && request.method === "GET")
+        return answer(200, { widgets: [...state.rows.values()] });
+    if (pathname === COLLECTION && request.method === "POST")
+        return create(state, request);
+    const onItem = ITEM.test(pathname) ? ON_ITEM[request.method] : undefined;
+    if (onItem === undefined)
+        return notFound();
+    return onItem(state, decodeURIComponent(pathname.slice(COLLECTION.length + 1)), request);
+}
+/** A fresh backend for `options`, and every write it is sent. */
+export function widgetBackend(options) {
+    const tag = options.spec.omitTag === true ? null : (options.spec.tag ?? [["name"]]);
+    const state = {
+        options,
+        posts: [],
+        rows: new Map(),
+        seq: 0,
+        sets: tag === null ? [] : (readUnique({ "x-unique": tag }) ?? []),
+        spec: widgetSpec(options.spec),
+    };
+    if (options.listSeeded === true) {
+        state.rows.set("w_existing", {
+            email: "seed@example.test",
+            id: "w_existing",
+            name: "Existing Widget",
+            slug: "existing",
+        });
+    }
+    return {
+        handle: guarded(async (request) => route(state, request), answer(500, { error_key: "internal" })),
+        posts: state.posts,
+    };
+}
+const PRINCIPALS = { alpha: { scope: { org_id: "org_1" }, tenant: "org_1" } };
+const SECURITY = { bearer: { static: "tok_alpha" } };
+/** testing api run once, on the widget entity alone, against a fresh harness reached through `via`. */
+export async function against(via, options) {
+    const { handle, posts } = widgetBackend(options);
+    const hosted = await via.host(handle);
+    try {
+        const result = await run({
+            baseUrl: hosted.url,
+            only: ["widget"],
+            principals: PRINCIPALS,
+            security: SECURITY,
+            seed: 1,
+            spec: `${hosted.url}/v1/openapi/spec`,
+            ...reach(hosted),
+        });
+        return { posts, result };
+    }
+    finally {
+        await hosted.close();
+    }
+}
+//# sourceMappingURL=backend.js.map

package/dist/api/conformance/unique/cases.d.ts

@@ -0,0 +1,22 @@
+/** The unique suite's runs: each case is a harness, and what the API tester should have made of it. */
+import type { Via } from "../harness/launch.ts";
+import type { ParserResult } from "../harness/result.ts";
+import { type HarnessOptions, type Outcome } from "./backend.ts";
+import * as judge from "./judges.ts";
+/** One result a run is judged for. */
+interface Judged {
+    name: string;
+    why: string;
+    judge: (outcome: Outcome) => judge.Verdict;
+}
+/** One run, and every result it is judged for. */
+export interface UniqueCase {
+    options: HarnessOptions;
+    judged: readonly Judged[];
+}
+/** Every run, in the order the suite reports them. */
+export declare const UNIQUE_CASES: readonly UniqueCase[];
+/** One case run through `via`, judged; a run that fails fails every result it was judged for. */
+export declare function runCase(via: Via, { judged, options }: UniqueCase): Promise<ParserResult[]>;
+export {};
+//# sourceMappingURL=cases.d.ts.map

package/dist/api/conformance/unique/cases.js

@@ -0,0 +1,201 @@
+/** The unique suite's runs: each case is a harness, and what the API tester should have made of it. */
+import { messageOf } from "../../errors/message.js";
+import { against } from "./backend.js";
+import * as judge from "./judges.js";
+/** Every run, in the order the suite reports them. */
+export const UNIQUE_CASES = [
+    {
+        judged: [
+            {
+                judge: judge.untaggedNotProbed,
+                name: "missing tag does not run unique checks",
+                why: "do not infer uniqueness",
+            },
+        ],
+        options: { spec: { omitTag: true } },
+    },
+    {
+        judged: [
+            {
+                judge: judge.duplicateRefused,
+                name: "409 duplicate create is not BACKEND_BUG",
+                why: "the backend matched the document",
+            },
+        ],
+        options: { duplicate: "409", spec: {}, updateDuplicate: "409" },
+    },
+    {
+        judged: [
+            {
+                judge: judge.duplicateInserted,
+                name: "201 duplicate create is BACKEND_BUG",
+                why: "a unique constraint that inserts is a backend bug",
+            },
+        ],
+        options: { duplicate: "201", spec: {}, updateDuplicate: "ok" },
+    },
+    {
+        judged: [
+            { judge: judge.listKept, name: "list does not grow on 409", why: "cardinality is part of the unique pass" },
+        ],
+        options: { duplicate: "409", spec: {} },
+    },
+    {
+        judged: [
+            { judge: judge.oneSetInserted, name: "one 2xx set fails the check (not OR'd)", why: "probe each set separately" },
+        ],
+        options: { duplicate: "per-set", spec: { tag: [["name"], ["slug"]] }, updateDuplicate: "ok" },
+    },
+    {
+        judged: [
+            {
+                judge: judge.createNotProbed,
+                name: "generated-only unique set is skipped",
+                why: "a set with no body columns is not a fail",
+            },
+        ],
+        options: { spec: { generated: ["id"], omitTag: false, tag: [["id"]] } },
+    },
+    {
+        judged: [
+            {
+                judge: judge.updateNotProbed,
+                name: "all-x-immutable update set is skipped",
+                why: "immutable unique columns are not a unique PATCH probe",
+            },
+        ],
+        options: {
+            spec: {
+                generated: ["id", "workspace_id"],
+                immutable: ["workspace_id"],
+                tag: [["workspace_id"]],
+                updateBody: ["workspace_id", "name"],
+            },
+            updateDuplicate: "ok",
+        },
+    },
+    {
+        judged: [{ judge: judge.updateRefused, name: "colliding PATCH 409 passes", why: "same scoring as create" }],
+        options: { duplicate: "409", spec: {}, updateDuplicate: "409" },
+    },
+    {
+        judged: [
+            {
+                judge: judge.updateApplied,
+                name: "colliding PATCH 2xx is BACKEND_BUG",
+                why: "update unique is the same class as create",
+            },
+        ],
+        options: { duplicate: "409", spec: {}, updateDuplicate: "201" },
+    },
+    {
+        judged: [
+            { judge: judge.freshKey, name: "unique probe does not reuse Idempotency-Key", why: "omit or send a fresh key" },
+        ],
+        options: { duplicate: "409", spec: { idempotencyRequired: true } },
+    },
+    {
+        judged: [
+            {
+                judge: judge.driftReported,
+                name: "409 schema drift still reports",
+                why: "coverage is not a free pass for an undeclared body",
+            },
+        ],
+        options: { duplicate: "409-drift", spec: {}, updateDuplicate: "ok" },
+    },
+    {
+        judged: [
+            {
+                judge: judge.coverageNotPass,
+                name: "feature-gate 403 on the probe is coverage, not a unique pass",
+                why: "do not score a documented 403 as 409",
+            },
+        ],
+        options: { duplicate: "gate-403", spec: { featureGate: "widgets" }, updateDuplicate: "ok" },
+    },
+    {
+        judged: [
+            {
+                judge: judge.coverageNotPass,
+                name: "402 on the probe is coverage, not a unique pass",
+                why: "plan limit is not a unique 409",
+            },
+        ],
+        options: { duplicate: "402", spec: {}, updateDuplicate: "ok" },
+    },
+    {
+        judged: [
+            {
+                judge: judge.seedAdopted,
+                name: "tagged seed 409 + nonempty list adopts",
+                why: "world.seed is COVERAGE_GAP naming x-unique, not BLOCKED",
+            },
+            {
+                judge: judge.probedAfterAdopt,
+                name: "unique check still runs after unique-409 adopt",
+                why: "do not stand unique probes down with write-path skips",
+            },
+            {
+                judge: judge.seedNotEvidence,
+                name: "seed 409 is not the unique check passing",
+                why: "that check is the explicit second POST",
+            },
+        ],
+        options: { duplicate: "409", listSeeded: true, seedConflict: true, spec: {}, updateDuplicate: "ok" },
+    },
+    {
+        judged: [{ judge: judge.seedBlocked, name: "tagged seed 409 + empty list is BLOCKED", why: "could not seed" }],
+        options: { seedConflict: true, spec: {} },
+    },
+    {
+        judged: [
+            {
+                judge: judge.seedBlocked,
+                name: "untagged seed 409 is still a seed failure",
+                why: "do not treat every 409 as unique",
+            },
+            {
+                judge: judge.untaggedNotAdopted,
+                name: "untagged 409 does not adopt as x-unique",
+                why: "no tag, no unique adopt",
+            },
+        ],
+        options: { seedConflict: true, spec: { omitTag: true } },
+    },
+    {
+        judged: [
+            {
+                judge: judge.distinctInserted,
+                name: "409 duplicate and 201 distinct passes",
+                why: "the cohort still inserts distinct unique values",
+            },
+        ],
+        options: { duplicate: "409", spec: {} },
+    },
+    {
+        judged: [
+            {
+                judge: judge.noneProbed,
+                name: "explicit empty x-unique does not run the check",
+                why: "[] after filter is none",
+            },
+        ],
+        options: { spec: { tag: [] } },
+    },
+];
+/** One case run through `via`, judged; a run that fails fails every result it was judged for. */
+export async function runCase(via, { judged, options }) {
+    try {
+        const outcome = await against(via, options);
+        return judged.map((one) => {
+            const { detail, ok } = one.judge(outcome);
+            return { detail, name: one.name, ok, why: one.why };
+        });
+    }
+    catch (error) {
+        const detail = messageOf(error);
+        return judged.map(({ name, why }) => ({ detail, name, ok: false, why }));
+    }
+}
+//# sourceMappingURL=cases.js.map