1tube 0.2.0 → 0.4.0

package/dist/test/api.d.ts

@@ -0,0 +1,76 @@
+/**
+ * The `1tube/test` contract every runner binding implements.
+ *
+ * Edge function tests import `test`, `describe`, hooks, `expect`, mocks and
+ * assertions from `1tube/test` instead of a specific runner, so the same
+ * files run under `bun test` today and under another runtime's runner
+ * (node:test, a workerd pool) later. Keep this surface to what every runner
+ * can express: no test context argument, no runner-specific options.
+ */
+import type { Mock } from "./expect.ts";
+export type TestFn = () => void | Promise<unknown>;
+export type HookFn = () => void | Promise<unknown>;
+export interface TestOptions {
+    /** Per-test timeout in milliseconds (runner default when omitted). */
+    timeout?: number;
+    /** Register but do not run. */
+    skip?: boolean;
+    /** Run only tests marked `only` (where the runner supports focusing). */
+    only?: boolean;
+}
+/** Row arguments for `.each`: array rows spread, anything else is one argument. */
+export type EachArgs<Row> = Row extends readonly unknown[] ? Row : [Row];
+export type RegisterTest = (name: string, fn: TestFn, options?: TestOptions) => void;
+export interface TestFunction extends RegisterTest {
+    skip: RegisterTest;
+    only: RegisterTest;
+    /** A placeholder for a test that is not written yet. */
+    todo(name: string): void;
+    /** Register normally when `condition` is truthy, else as skipped. */
+    if(condition: unknown): RegisterTest;
+    /** Register as skipped when `condition` is truthy. */
+    skipIf(condition: unknown): RegisterTest;
+    /**
+     * One test per row. The name supports printf placeholders (`%s %d %i %f
+     * %j %o %p %#`) and `$key` for object rows.
+     */
+    each<Row>(table: readonly Row[]): (name: string, fn: (...args: EachArgs<Row>) => void | Promise<unknown>, options?: TestOptions) => void;
+}
+export type RegisterSuite = (name: string, fn: () => void) => void;
+export interface DescribeFunction extends RegisterSuite {
+    skip: RegisterSuite;
+    only: RegisterSuite;
+    if(condition: unknown): RegisterSuite;
+    skipIf(condition: unknown): RegisterSuite;
+    each<Row>(table: readonly Row[]): (name: string, fn: (...args: EachArgs<Row>) => void) => void;
+}
+export type Hook = (fn: HookFn) => void;
+type AnyFn = (...args: any[]) => any;
+export interface MockFunction {
+    /** A mock function (records calls; optional implementation). */
+    <T extends AnyFn = AnyFn>(impl?: T): Mock<T>;
+    /**
+     * Replace a module for subsequently loaded importers. The specifier must
+     * be absolute — a shared helper can't know which file called it — so
+     * pass `import.meta.resolve("./dep.ts")` or a package name. The factory
+     * returns the module's exports (`default` for the default export).
+     */
+    module(specifier: string | URL, factory: () => Record<string, unknown>): void;
+    /** Restore every `spyOn` replacement. */
+    restore(): void;
+}
+/** Which runner the active binding drives. */
+export type TestRuntime = "bun" | "node";
+/** What a runner binding provides; `createTestApi` builds the rest. */
+export interface RunnerBase {
+    test(name: string, fn: TestFn, options: TestOptions): void;
+    todo(name: string): void;
+    describe(name: string, fn: () => void, mode: "run" | "skip" | "only"): void;
+    beforeAll: Hook;
+    afterAll: Hook;
+    beforeEach: Hook;
+    afterEach: Hook;
+    /** `specifier` is already checked to be absolute (path, file: URL or bare). */
+    mockModule(specifier: string, factory: () => Record<string, unknown>): void;
+}
+export {};

package/dist/test/api.js

@@ -0,0 +1,10 @@
+/**
+ * The `1tube/test` contract every runner binding implements.
+ *
+ * Edge function tests import `test`, `describe`, hooks, `expect`, mocks and
+ * assertions from `1tube/test` instead of a specific runner, so the same
+ * files run under `bun test` today and under another runtime's runner
+ * (node:test, a workerd pool) later. Keep this surface to what every runner
+ * can express: no test context argument, no runner-specific options.
+ */
+export {};

package/dist/test/assert.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Runtime-agnostic assertions for `1tube/test`.
+ *
+ * Pure TypeScript with no runtime imports, so the same assertions run under
+ * `bun test`, `node --test`, or a workerd test pool. The surface follows the
+ * familiar `assertX(actual, expected, msg?)` shape (the one Supabase-style
+ * edge function tests are written against), so test files only change their
+ * import line when moving between runners.
+ */
+export declare class AssertionError extends Error {
+    name: string;
+    constructor(message: string);
+}
+type AnyConstructor = abstract new (...args: never[]) => unknown;
+type ErrorClass<E extends Error = Error> = abstract new (...args: never[]) => E;
+/** Readable, deterministic rendering of a value for failure messages. */
+export declare function format(value: unknown): string;
+/** Line-level diff of two formatted values (`-` actual, `+` expected). */
+export declare function formatDiff(actual: unknown, expected: unknown): string;
+/**
+ * Deep structural equality: same constructor, same own enumerable keys
+ * (strings and symbols), recursively equal values. `NaN` equals `NaN`;
+ * `0` and `-0` differ. Maps and Sets compare by content, order-insensitive.
+ */
+export declare function equal(a: unknown, b: unknown): boolean;
+/** Assert that `expr` is truthy. */
+export declare function assert(expr: unknown, msg?: string): asserts expr;
+/** Assert that `expr` is falsy. */
+export declare function assertFalse(expr: unknown, msg?: string): void;
+/** Deep equality (see {@link equal}). */
+export declare function assertEquals<T>(actual: T, expected: T, msg?: string): void;
+export declare function assertNotEquals<T>(actual: T, expected: T, msg?: string): void;
+/** Identity (`Object.is`). */
+export declare function assertStrictEquals<T>(actual: unknown, expected: T, msg?: string): asserts actual is T;
+export declare function assertNotStrictEquals<T>(actual: T, expected: T, msg?: string): void;
+/** |actual - expected| <= tolerance (default 1e-7). */
+export declare function assertAlmostEquals(actual: number, expected: number, tolerance?: number, msg?: string): void;
+/** Not `null` and not `undefined`. */
+export declare function assertExists<T>(actual: T, msg?: string): asserts actual is NonNullable<T>;
+export declare function assertInstanceOf<T extends AnyConstructor>(actual: unknown, expectedType: T, msg?: string): asserts actual is InstanceType<T>;
+export declare function assertNotInstanceOf<T extends AnyConstructor>(actual: unknown, unexpectedType: T, msg?: string): void;
+export declare function assertStringIncludes(actual: string, expected: string, msg?: string): void;
+export declare function assertMatch(actual: string, expected: RegExp, msg?: string): void;
+export declare function assertNotMatch(actual: string, expected: RegExp, msg?: string): void;
+/** Every element of `expected` is deep-equal to some element of `actual`. */
+export declare function assertArrayIncludes<T>(actual: ArrayLike<T>, expected: ArrayLike<T>, msg?: string): void;
+/** `actual` contains (recursively) every key/value of `expected`. */
+export declare function assertObjectMatch(actual: Record<PropertyKey, unknown>, expected: Record<PropertyKey, unknown>, msg?: string): void;
+export declare function assertGreater<T>(actual: T, expected: T, msg?: string): void;
+export declare function assertGreaterOrEqual<T>(actual: T, expected: T, msg?: string): void;
+export declare function assertLess<T>(actual: T, expected: T, msg?: string): void;
+export declare function assertLessOrEqual<T>(actual: T, expected: T, msg?: string): void;
+/** Assert `fn` throws; returns the thrown value. */
+export declare function assertThrows(fn: () => unknown, msg?: string): unknown;
+export declare function assertThrows<E extends Error = Error>(fn: () => unknown, ErrorClass: ErrorClass<E>, msgIncludes?: string, msg?: string): E;
+/** Assert the promise (or `fn()`'s promise) rejects; resolves to the reason. */
+export declare function assertRejects(fn: (() => PromiseLike<unknown>) | PromiseLike<unknown>, msg?: string): Promise<unknown>;
+export declare function assertRejects<E extends Error = Error>(fn: (() => PromiseLike<unknown>) | PromiseLike<unknown>, ErrorClass: ErrorClass<E>, msgIncludes?: string, msg?: string): Promise<E>;
+/** Unconditionally fail. */
+export declare function fail(msg?: string): never;
+export declare function unreachable(msg?: string): never;
+export declare function unimplemented(msg?: string): never;
+export {};

package/dist/test/assert.js

@@ -0,0 +1,430 @@
+/**
+ * Runtime-agnostic assertions for `1tube/test`.
+ *
+ * Pure TypeScript with no runtime imports, so the same assertions run under
+ * `bun test`, `node --test`, or a workerd test pool. The surface follows the
+ * familiar `assertX(actual, expected, msg?)` shape (the one Supabase-style
+ * edge function tests are written against), so test files only change their
+ * import line when moving between runners.
+ */
+export class AssertionError extends Error {
+    name = "AssertionError";
+    constructor(message) {
+        super(message);
+    }
+}
+// ---------------------------------------------------------------------------
+// Formatting
+// ---------------------------------------------------------------------------
+/** Readable, deterministic rendering of a value for failure messages. */
+export function format(value) {
+    const seen = new WeakSet();
+    const indent = (s) => s.replace(/\n/g, "\n  ");
+    const render = (v) => {
+        switch (typeof v) {
+            case "string":
+                return JSON.stringify(v);
+            case "bigint":
+                return `${v}n`;
+            case "symbol":
+            case "undefined":
+            case "boolean":
+                return String(v);
+            case "number":
+                return Object.is(v, -0) ? "-0" : String(v);
+            case "function":
+                return `[Function: ${v.name || "anonymous"}]`;
+        }
+        if (v === null)
+            return "null";
+        const obj = v;
+        if (seen.has(obj))
+            return "[Circular]";
+        if (obj instanceof Date)
+            return `Date(${Number.isNaN(obj.getTime()) ? "Invalid" : obj.toISOString()})`;
+        if (obj instanceof RegExp)
+            return String(obj);
+        if (obj instanceof Error)
+            return `${obj.name}: ${obj.message}`;
+        if (typeof URL !== "undefined" && obj instanceof URL)
+            return `URL(${obj.href})`;
+        seen.add(obj);
+        try {
+            if (Array.isArray(obj)) {
+                if (obj.length === 0)
+                    return "[]";
+                return `[\n  ${obj.map((x) => indent(render(x))).join(",\n  ")},\n]`;
+            }
+            if (ArrayBuffer.isView(obj) && !(obj instanceof DataView)) {
+                const items = Array.from(obj, (x) => render(x));
+                return `${obj.constructor.name}(${items.length}) [${items.join(", ")}]`;
+            }
+            if (obj instanceof Map) {
+                if (obj.size === 0)
+                    return "Map(0) {}";
+                const rows = [...obj].map(([k, x]) => `${indent(render(k))} => ${indent(render(x))}`);
+                return `Map(${obj.size}) {\n  ${rows.join(",\n  ")},\n}`;
+            }
+            if (obj instanceof Set) {
+                if (obj.size === 0)
+                    return "Set(0) {}";
+                return `Set(${obj.size}) {\n  ${[...obj].map((x) => indent(render(x))).join(",\n  ")},\n}`;
+            }
+            const keys = [
+                ...Object.keys(obj),
+                ...Object.getOwnPropertySymbols(obj).filter((s) => Object.prototype.propertyIsEnumerable.call(obj, s)),
+            ];
+            const proto = Object.getPrototypeOf(obj);
+            const tag = proto === null
+                ? "[Object: null prototype] "
+                : proto !== Object.prototype && proto?.constructor?.name
+                    ? `${proto.constructor.name} `
+                    : "";
+            if (keys.length === 0)
+                return `${tag}{}`;
+            const rows = keys.map((k) => {
+                const name = typeof k === "symbol"
+                    ? `[${String(k)}]`
+                    : /^[A-Za-z_$][\w$]*$/.test(k)
+                        ? k
+                        : JSON.stringify(k);
+                return `${name}: ${indent(render(obj[k]))}`;
+            });
+            return `${tag}{\n  ${rows.join(",\n  ")},\n}`;
+        }
+        finally {
+            seen.delete(obj);
+        }
+    };
+    return render(value);
+}
+/** Line-level diff of two formatted values (`-` actual, `+` expected). */
+export function formatDiff(actual, expected) {
+    const a = format(actual).split("\n");
+    const b = format(expected).split("\n");
+    // LCS over lines: values printed for assertion failures are small.
+    const lcs = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
+    for (let i = a.length - 1; i >= 0; i--) {
+        for (let j = b.length - 1; j >= 0; j--) {
+            lcs[i][j] = a[i] === b[j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+        }
+    }
+    const out = [];
+    let i = 0;
+    let j = 0;
+    while (i < a.length || j < b.length) {
+        if (i < a.length && j < b.length && a[i] === b[j]) {
+            out.push(`    ${a[i]}`);
+            i++;
+            j++;
+        }
+        else if (j < b.length && (i >= a.length || lcs[i][j + 1] >= lcs[i + 1][j])) {
+            out.push(`+   ${b[j++]}`);
+        }
+        else {
+            out.push(`-   ${a[i++]}`);
+        }
+    }
+    return out.join("\n");
+}
+const suffix = (msg) => (msg ? `: ${msg}` : "");
+// ---------------------------------------------------------------------------
+// Equality
+// ---------------------------------------------------------------------------
+/**
+ * Deep structural equality: same constructor, same own enumerable keys
+ * (strings and symbols), recursively equal values. `NaN` equals `NaN`;
+ * `0` and `-0` differ. Maps and Sets compare by content, order-insensitive.
+ */
+export function equal(a, b) {
+    const seen = new Map();
+    const eq = (x, y) => {
+        if (Object.is(x, y))
+            return true;
+        if (typeof x !== "object" || typeof y !== "object" || x === null || y === null) {
+            return false;
+        }
+        if (seen.get(x) === y)
+            return true;
+        if (Object.getPrototypeOf(x) !== Object.getPrototypeOf(y))
+            return false;
+        seen.set(x, y);
+        if (x instanceof Date)
+            return Object.is(x.getTime(), y.getTime());
+        if (x instanceof RegExp)
+            return String(x) === String(y);
+        if (typeof URL !== "undefined" && x instanceof URL)
+            return x.href === y.href;
+        if (x instanceof WeakMap || x instanceof WeakSet || x instanceof WeakRef) {
+            throw new TypeError("cannot compare WeakMap, WeakSet or WeakRef instances");
+        }
+        if (x instanceof Number || x instanceof String || x instanceof Boolean) {
+            if (!Object.is(x.valueOf(), y.valueOf()))
+                return false;
+        }
+        if (x instanceof ArrayBuffer) {
+            return eq(new Uint8Array(x), new Uint8Array(y));
+        }
+        if (x instanceof DataView) {
+            return eq(new Uint8Array(x.buffer, x.byteOffset, x.byteLength), new Uint8Array(y.buffer, y.byteOffset, y.byteLength));
+        }
+        if (ArrayBuffer.isView(x)) {
+            const xa = x;
+            const ya = y;
+            if (xa.length !== ya.length)
+                return false;
+            for (let i = 0; i < xa.length; i++)
+                if (!Object.is(xa[i], ya[i]))
+                    return false;
+            return true;
+        }
+        if (x instanceof Map) {
+            const ym = y;
+            if (x.size !== ym.size)
+                return false;
+            const unmatched = [...ym];
+            for (const [k, v] of x) {
+                const idx = unmatched.findIndex(([k2, v2]) => eq(k, k2) && eq(v, v2));
+                if (idx === -1)
+                    return false;
+                unmatched.splice(idx, 1);
+            }
+            return true;
+        }
+        if (x instanceof Set) {
+            const ys = y;
+            if (x.size !== ys.size)
+                return false;
+            const unmatched = [...ys];
+            for (const v of x) {
+                const idx = unmatched.findIndex((v2) => eq(v, v2));
+                if (idx === -1)
+                    return false;
+                unmatched.splice(idx, 1);
+            }
+            return true;
+        }
+        if (x instanceof Error) {
+            const ye = y;
+            if (x.name !== ye.name || x.message !== ye.message)
+                return false;
+        }
+        const keysOf = (o) => [
+            ...Object.keys(o),
+            ...Object.getOwnPropertySymbols(o).filter((s) => Object.prototype.propertyIsEnumerable.call(o, s)),
+        ];
+        const xk = keysOf(x);
+        const yk = keysOf(y);
+        if (xk.length !== yk.length)
+            return false;
+        const rec = (o, k) => o[k];
+        for (const k of xk) {
+            if (!Object.prototype.hasOwnProperty.call(y, k))
+                return false;
+            if (!eq(rec(x, k), rec(y, k)))
+                return false;
+        }
+        return true;
+    };
+    return eq(a, b);
+}
+// ---------------------------------------------------------------------------
+// Assertions
+// ---------------------------------------------------------------------------
+/** Assert that `expr` is truthy. */
+export function assert(expr, msg = "") {
+    if (!expr)
+        throw new AssertionError(msg || "Expected value to be truthy");
+}
+/** Assert that `expr` is falsy. */
+export function assertFalse(expr, msg = "") {
+    if (expr)
+        throw new AssertionError(msg || `Expected value to be falsy, got ${format(expr)}`);
+}
+/** Deep equality (see {@link equal}). */
+export function assertEquals(actual, expected, msg) {
+    if (equal(actual, expected))
+        return;
+    throw new AssertionError(`Values are not equal${suffix(msg)}\n\n    [Diff] Actual / Expected\n\n${formatDiff(actual, expected)}\n`);
+}
+export function assertNotEquals(actual, expected, msg) {
+    if (!equal(actual, expected))
+        return;
+    throw new AssertionError(`Expected actual: ${format(actual)} not to be: ${format(expected)}${suffix(msg)}`);
+}
+/** Identity (`Object.is`). */
+export function assertStrictEquals(actual, expected, msg) {
+    if (Object.is(actual, expected))
+        return;
+    const sameRendering = format(actual) === format(expected);
+    throw new AssertionError(sameRendering
+        ? `Values have the same structure but are not reference-equal${suffix(msg)}\n\n    ${format(actual).replace(/\n/g, "\n    ")}\n`
+        : `Values are not strictly equal${suffix(msg)}\n\n    [Diff] Actual / Expected\n\n${formatDiff(actual, expected)}\n`);
+}
+export function assertNotStrictEquals(actual, expected, msg) {
+    if (!Object.is(actual, expected))
+        return;
+    throw new AssertionError(`Expected "actual" to not be strictly equal to: ${format(expected)}${suffix(msg)}`);
+}
+/** |actual - expected| <= tolerance (default 1e-7). */
+export function assertAlmostEquals(actual, expected, tolerance = 1e-7, msg) {
+    if (Object.is(actual, expected))
+        return;
+    const delta = Math.abs(expected - actual);
+    if (delta <= tolerance)
+        return;
+    throw new AssertionError(`Expected actual: "${actual}" to be close to "${expected}": delta "${delta}" is greater than "${tolerance}"${suffix(msg)}`);
+}
+/** Not `null` and not `undefined`. */
+export function assertExists(actual, msg) {
+    if (actual === undefined || actual === null) {
+        throw new AssertionError(msg || `Expected actual: "${actual}" to not be null or undefined`);
+    }
+}
+export function assertInstanceOf(actual, expectedType, msg) {
+    if (actual instanceof expectedType)
+        return;
+    const got = actual === null
+        ? "null"
+        : typeof actual === "object"
+            ? (Object.getPrototypeOf(actual)?.constructor?.name ?? "Object")
+            : typeof actual;
+    throw new AssertionError(`Expected object to be an instance of "${expectedType.name}" but was "${got}"${suffix(msg)}`);
+}
+export function assertNotInstanceOf(actual, unexpectedType, msg) {
+    if (!(actual instanceof unexpectedType))
+        return;
+    throw new AssertionError(`Expected object to not be an instance of "${unexpectedType.name}"${suffix(msg)}`);
+}
+export function assertStringIncludes(actual, expected, msg) {
+    if (typeof actual === "string" && actual.includes(expected))
+        return;
+    throw new AssertionError(msg || `Expected actual: ${format(actual)} to contain: ${format(expected)}`);
+}
+export function assertMatch(actual, expected, msg) {
+    expected.lastIndex = 0;
+    if (expected.test(actual))
+        return;
+    throw new AssertionError(msg || `Expected actual: ${format(actual)} to match: ${expected}`);
+}
+export function assertNotMatch(actual, expected, msg) {
+    expected.lastIndex = 0;
+    if (!expected.test(actual))
+        return;
+    throw new AssertionError(msg || `Expected actual: ${format(actual)} to not match: ${expected}`);
+}
+/** Every element of `expected` is deep-equal to some element of `actual`. */
+export function assertArrayIncludes(actual, expected, msg) {
+    const missing = [];
+    for (const e of Array.from(expected)) {
+        if (!Array.from(actual).some((a) => equal(a, e)))
+            missing.push(e);
+    }
+    if (missing.length === 0)
+        return;
+    throw new AssertionError(msg || `Expected actual: ${format(actual)} to include: ${format(expected)}\nmissing: ${format(missing)}`);
+}
+/** `actual` contains (recursively) every key/value of `expected`. */
+export function assertObjectMatch(actual, expected, msg) {
+    const pick = (a, e) => {
+        if (Array.isArray(e) && Array.isArray(a))
+            return a.map((x, i) => (i < e.length ? pick(x, e[i]) : x));
+        if (e && typeof e === "object" && a && typeof a === "object" && !(e instanceof Date) && !(e instanceof RegExp)) {
+            const out = {};
+            for (const k of Reflect.ownKeys(e)) {
+                if (k in a)
+                    out[k] = pick(a[k], e[k]);
+            }
+            return out;
+        }
+        return a;
+    };
+    assertEquals(pick(actual, expected), expected, msg);
+}
+export function assertGreater(actual, expected, msg) {
+    if (actual > expected)
+        return;
+    throw new AssertionError(msg || `Expect ${format(actual)} > ${format(expected)}`);
+}
+export function assertGreaterOrEqual(actual, expected, msg) {
+    if (actual >= expected)
+        return;
+    throw new AssertionError(msg || `Expect ${format(actual)} >= ${format(expected)}`);
+}
+export function assertLess(actual, expected, msg) {
+    if (actual < expected)
+        return;
+    throw new AssertionError(msg || `Expect ${format(actual)} < ${format(expected)}`);
+}
+export function assertLessOrEqual(actual, expected, msg) {
+    if (actual <= expected)
+        return;
+    throw new AssertionError(msg || `Expect ${format(actual)} <= ${format(expected)}`);
+}
+function checkError(err, ErrorClass, msgIncludes, msg) {
+    if (!ErrorClass)
+        return;
+    if (!(err instanceof ErrorClass)) {
+        throw new AssertionError(`Expected error to be instance of "${ErrorClass.name}", but was "${err instanceof Error ? err.constructor.name : typeof err}"${suffix(msg)}`);
+    }
+    if (msgIncludes !== undefined && !String(err.message).includes(msgIncludes)) {
+        throw new AssertionError(`Expected error message to include ${format(msgIncludes)}, but got ${format(err.message)}${suffix(msg)}`);
+    }
+}
+export function assertThrows(fn, classOrMsg, msgIncludes, msg) {
+    const ErrorClass = typeof classOrMsg === "function" ? classOrMsg : undefined;
+    if (typeof classOrMsg === "string")
+        msg = classOrMsg;
+    let thrown = false;
+    let error;
+    try {
+        fn();
+    }
+    catch (err) {
+        thrown = true;
+        error = err;
+    }
+    if (!thrown)
+        throw new AssertionError(`Expected function to throw${suffix(msg)}`);
+    checkError(error, ErrorClass, msgIncludes, msg);
+    return error;
+}
+export async function assertRejects(fn, classOrMsg, msgIncludes, msg) {
+    const ErrorClass = typeof classOrMsg === "function" ? classOrMsg : undefined;
+    if (typeof classOrMsg === "string")
+        msg = classOrMsg;
+    let p;
+    try {
+        p = typeof fn === "function" ? fn() : fn;
+    }
+    catch {
+        // A synchronous throw is not a rejection (an async function never does this).
+        throw new AssertionError(`Function throws when expected to reject${suffix(msg)}`);
+    }
+    if (!p || typeof p.then !== "function") {
+        throw new AssertionError(`Function returns a non-promise when expected to reject${suffix(msg)}`);
+    }
+    let rejected = false;
+    let error;
+    try {
+        await p;
+    }
+    catch (err) {
+        rejected = true;
+        error = err;
+    }
+    if (!rejected)
+        throw new AssertionError(`Expected function to reject${suffix(msg)}`);
+    checkError(error, ErrorClass, msgIncludes, msg);
+    return error;
+}
+/** Unconditionally fail. */
+export function fail(msg) {
+    throw new AssertionError(`Failed assertion${suffix(msg)}`);
+}
+export function unreachable(msg) {
+    throw new AssertionError(msg ?? "Unreachable");
+}
+export function unimplemented(msg) {
+    throw new AssertionError(msg ?? "Unimplemented");
+}

package/dist/test/core.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Builds the full `1tube/test` surface from a runner's minimal base, so
+ * `.each`, `.if`/`.skipIf`, `it`, mocks and title formatting behave the
+ * same on every runner.
+ */
+import type { DescribeFunction, Hook, MockFunction, RunnerBase, TestFunction } from "./api.ts";
+export interface TestApi {
+    test: TestFunction;
+    it: TestFunction;
+    describe: DescribeFunction;
+    beforeAll: Hook;
+    afterAll: Hook;
+    beforeEach: Hook;
+    afterEach: Hook;
+    mock: MockFunction;
+}
+/** jest-style `.each` titles: printf placeholders, or `$path` for object rows. */
+export declare function formatTitle(title: string, args: unknown[], index: number): string;
+export declare function createTestApi(base: RunnerBase): TestApi;