1tube 0.3.0 → 0.4.0

package/dist/test/expect.js

@@ -0,0 +1,592 @@
+/**
+ * Runtime-agnostic `expect`, mock functions and spies for `1tube/test`.
+ *
+ * Pure TypeScript with no runtime imports — the same semantics under every
+ * runner. Matchers follow the jest conventions Bun's `bun:test` also uses
+ * (`toEqual` ignores `undefined` properties and object types,
+ * `toStrictEqual` does not, `toMatchObject` matches subsets, asymmetric
+ * matchers like `expect.objectContaining` nest anywhere), so tests written
+ * against `bun:test` port by changing the import line.
+ */
+import { AssertionError, format, formatDiff } from "./assert.js";
+// ---------------------------------------------------------------------------
+// Asymmetric matchers
+// ---------------------------------------------------------------------------
+const ASYMMETRIC = Symbol.for("1tube.test.asymmetricMatcher");
+function asymmetric(describe, match) {
+    return { [ASYMMETRIC]: true, asymmetricMatch: match, toString: () => describe };
+}
+function isAsymmetric(v) {
+    return typeof v === "object" && v !== null && v[ASYMMETRIC] === true;
+}
+// ---------------------------------------------------------------------------
+// Equality
+// ---------------------------------------------------------------------------
+const tag = (v) => Object.prototype.toString.call(v);
+function ownKeys(o, strict) {
+    const keys = [
+        ...Object.keys(o),
+        ...Object.getOwnPropertySymbols(o).filter((s) => Object.prototype.propertyIsEnumerable.call(o, s)),
+    ];
+    // Loose equality treats `{ a: undefined }` like `{}`.
+    return strict ? keys : keys.filter((k) => o[k] !== undefined);
+}
+/**
+ * jest-style deep equality. `strict` (toStrictEqual) additionally checks
+ * constructors, `undefined`-valued keys and array holes.
+ */
+export function deepEquals(a, b, strict = false) {
+    const seenA = [];
+    const seenB = [];
+    const eq = (x, y) => {
+        if (isAsymmetric(x))
+            return x.asymmetricMatch(y);
+        if (isAsymmetric(y))
+            return y.asymmetricMatch(x);
+        if (Object.is(x, y))
+            return true;
+        if (typeof x !== "object" || typeof y !== "object" || x === null || y === null)
+            return false;
+        const t = tag(x);
+        if (t !== tag(y))
+            return false;
+        if (strict && Object.getPrototypeOf(x) !== Object.getPrototypeOf(y))
+            return false;
+        // Cycles: a pair already being compared is assumed equal.
+        const i = seenA.indexOf(x);
+        if (i !== -1 && seenB[i] === y)
+            return true;
+        seenA.push(x);
+        seenB.push(y);
+        try {
+            if (x instanceof Date)
+                return Object.is(x.getTime(), y.getTime());
+            if (x instanceof RegExp)
+                return x.source === y.source && x.flags === y.flags;
+            if (typeof URL !== "undefined" && x instanceof URL)
+                return x.href === y.href;
+            if (x instanceof Number || x instanceof String || x instanceof Boolean) {
+                return Object.is(x.valueOf(), y.valueOf());
+            }
+            if (x instanceof Error) {
+                const ye = y;
+                if (x.name !== ye.name || x.message !== ye.message)
+                    return false;
+            }
+            if (x instanceof ArrayBuffer)
+                return eq(new Uint8Array(x), new Uint8Array(y));
+            if (ArrayBuffer.isView(x) && !(x instanceof DataView)) {
+                const xa = x;
+                const ya = y;
+                if (xa.length !== ya.length)
+                    return false;
+                for (let k = 0; k < xa.length; k++)
+                    if (!Object.is(xa[k], ya[k]))
+                        return false;
+                return true;
+            }
+            if (x instanceof Map) {
+                const ym = y;
+                if (x.size !== ym.size)
+                    return false;
+                outer: for (const [k, v] of x) {
+                    if (ym.has(k)) {
+                        if (!eq(v, ym.get(k)))
+                            return false;
+                        continue;
+                    }
+                    for (const [k2, v2] of ym)
+                        if (eq(k, k2) && eq(v, v2))
+                            continue outer;
+                    return false;
+                }
+                return true;
+            }
+            if (x instanceof Set) {
+                const ys = y;
+                if (x.size !== ys.size)
+                    return false;
+                outer: for (const v of x) {
+                    if (ys.has(v))
+                        continue;
+                    for (const v2 of ys)
+                        if (eq(v, v2))
+                            continue outer;
+                    return false;
+                }
+                return true;
+            }
+            if (Array.isArray(x)) {
+                const ya = y;
+                if (x.length !== ya.length)
+                    return false;
+                for (let k = 0; k < x.length; k++) {
+                    if (strict && (k in x) !== (k in ya))
+                        return false;
+                    if (!eq(x[k], ya[k]))
+                        return false;
+                }
+                // Extra non-index properties on arrays still count.
+            }
+            const xk = ownKeys(x, strict).filter((k) => !(Array.isArray(x) && typeof k === "string" && /^\d+$/.test(k)));
+            const yk = ownKeys(y, strict).filter((k) => !(Array.isArray(y) && typeof k === "string" && /^\d+$/.test(k)));
+            if (xk.length !== yk.length)
+                return false;
+            const rec = (o, k) => o[k];
+            for (const k of xk) {
+                if (strict && !Object.prototype.hasOwnProperty.call(y, k))
+                    return false;
+                if (!eq(rec(x, k), rec(y, k)))
+                    return false;
+            }
+            return true;
+        }
+        finally {
+            seenA.pop();
+            seenB.pop();
+        }
+    };
+    return eq(a, b);
+}
+/** `actual` contains `expected` recursively (toMatchObject semantics). */
+function subsetEquals(actual, expected) {
+    if (isAsymmetric(expected))
+        return expected.asymmetricMatch(actual);
+    if (Array.isArray(expected)) {
+        return Array.isArray(actual) && actual.length === expected.length &&
+            expected.every((e, i) => subsetEquals(actual[i], e));
+    }
+    if (typeof expected === "object" && expected !== null && tag(expected) === "[object Object]") {
+        if (typeof actual !== "object" || actual === null)
+            return false;
+        return ownKeys(expected, true).every((k) => k in actual &&
+            subsetEquals(actual[k], expected[k]));
+    }
+    return deepEquals(actual, expected);
+}
+const MOCK = Symbol.for("1tube.test.mock");
+const spies = new Set();
+/** Create a mock function, optionally wrapping an implementation. */
+export function createMock(impl, restore) {
+    let defaultImpl = impl;
+    const once = [];
+    let name = impl?.name || "mock";
+    const state = { calls: [], results: [], instances: [], lastCall: undefined };
+    const fn = function (...args) {
+        state.calls.push(args);
+        state.lastCall = args;
+        state.instances.push(this);
+        const result = { type: "incomplete", value: undefined };
+        state.results.push(result);
+        const current = once.shift() ?? defaultImpl;
+        try {
+            const value = current ? (new.target ? Reflect.construct(current, args, new.target) : current.apply(this, args)) : undefined;
+            Object.assign(result, { type: "return", value });
+            return value;
+        }
+        catch (err) {
+            Object.assign(result, { type: "throw", value: err });
+            throw err;
+        }
+    };
+    const self = fn;
+    Object.defineProperty(fn, "mock", { value: state, enumerable: false });
+    Object.defineProperty(fn, MOCK, { value: true });
+    Object.assign(self, {
+        mockImplementation: (f) => ((defaultImpl = f), fn),
+        mockImplementationOnce: (f) => (once.push(f), fn),
+        mockReturnValue: (v) => ((defaultImpl = () => v), fn),
+        mockReturnValueOnce: (v) => (once.push(() => v), fn),
+        mockResolvedValue: (v) => ((defaultImpl = () => Promise.resolve(v)), fn),
+        mockResolvedValueOnce: (v) => (once.push(() => Promise.resolve(v)), fn),
+        mockRejectedValue: (v) => ((defaultImpl = () => Promise.reject(v)), fn),
+        mockRejectedValueOnce: (v) => (once.push(() => Promise.reject(v)), fn),
+        mockName: (n) => ((name = n), fn),
+        getMockName: () => name,
+        mockClear: () => {
+            state.calls.length = 0;
+            state.results.length = 0;
+            state.instances.length = 0;
+            state.lastCall = undefined;
+            return fn;
+        },
+        mockReset: () => {
+            self.mockClear();
+            defaultImpl = undefined;
+            once.length = 0;
+            return fn;
+        },
+        mockRestore: () => {
+            self.mockReset();
+            restore?.();
+            spies.delete(fn);
+        },
+    });
+    return fn;
+}
+export function isMock(v) {
+    return typeof v === "function" && v[MOCK] === true;
+}
+/** Replace `obj[key]` with a mock that calls through to the original. */
+export function spyOn(obj, key) {
+    const original = obj[key];
+    if (typeof original !== "function")
+        throw new TypeError(`spyOn: ${String(key)} is not a function`);
+    const hadOwn = Object.prototype.hasOwnProperty.call(obj, key);
+    const spy = createMock(original, () => {
+        if (hadOwn)
+            obj[key] = original;
+        else
+            delete obj[key];
+    });
+    obj[key] = spy;
+    spies.add(spy);
+    return spy;
+}
+/** Restore every active spy (`mock.restore()`). */
+export function restoreAllMocks() {
+    for (const spy of [...spies])
+        spy.mockRestore();
+}
+const show = (v) => (isAsymmetric(v) ? v.toString() : format(v));
+const closeTo = (actual, expected, digits) => (actual === Infinity && expected === Infinity) || (actual === -Infinity && expected === -Infinity) ||
+    Math.abs(expected - actual) < 10 ** -digits / 2;
+function getPath(obj, path) {
+    const parts = typeof path === "string"
+        ? path.replace(/\[(\d+)\]/g, ".$1").split(".").filter((p) => p !== "")
+        : [...path];
+    let cur = obj;
+    for (const p of parts) {
+        if (cur === null || cur === undefined)
+            return { found: false, value: undefined };
+        const box = Object(cur);
+        if (!(p in box))
+            return { found: false, value: undefined };
+        cur = box[p];
+    }
+    return { found: true, value: cur };
+}
+function throwMatches(err, expected) {
+    if (expected === undefined)
+        return true;
+    const message = err instanceof Error ? err.message : String(err);
+    if (typeof expected === "string")
+        return message.includes(expected);
+    if (expected instanceof RegExp)
+        return expected.test(message);
+    if (isAsymmetric(expected))
+        return expected.asymmetricMatch(err);
+    if (expected instanceof Error)
+        return message === expected.message;
+    if (typeof expected === "function")
+        return err instanceof expected;
+    return false;
+}
+function requireMock(v, matcher) {
+    if (!isMock(v))
+        throw new AssertionError(`${matcher}: received value must be a mock function (from mock() or spyOn())`);
+    return v;
+}
+const lengthOf = (v) => v !== null && v !== undefined && typeof v.length === "number"
+    ? v.length
+    : undefined;
+/** Evaluate one matcher against `actual`. `thrown` carries `.rejects`. */
+function evaluate(name, actual, args) {
+    const [expected] = args;
+    const recv = `Received: ${show(actual)}`;
+    const simple = (pass, what) => ({
+        pass,
+        message: (neg) => `expect(received).${neg ? "not." : ""}${name}(${args.map(show).join(", ")})\n\n${what ? `${what}\n` : ""}${recv}`,
+    });
+    switch (name) {
+        case "toBe": {
+            const pass = Object.is(actual, expected);
+            return {
+                pass,
+                message: (neg) => neg
+                    ? `expect(received).not.toBe(expected)\n\nExpected: not ${show(expected)}`
+                    : deepEquals(actual, expected, true)
+                        ? `expect(received).toBe(expected)\n\nValues have the same structure but are not the same reference\n\nReceived: ${show(actual)}`
+                        : `expect(received).toBe(expected)\n\nExpected: ${show(expected)}\n${recv}`,
+            };
+        }
+        case "toEqual":
+        case "toStrictEqual": {
+            const pass = deepEquals(actual, expected, name === "toStrictEqual");
+            return {
+                pass,
+                message: (neg) => neg
+                    ? `expect(received).not.${name}(expected)\n\nExpected: not ${show(expected)}`
+                    : `expect(received).${name}(expected)\n\n- Received\n+ Expected\n\n${formatDiff(actual, expected)}`,
+            };
+        }
+        case "toMatchObject": {
+            const pass = typeof actual === "object" && actual !== null && subsetEquals(actual, expected);
+            return {
+                pass,
+                message: (neg) => neg
+                    ? `expect(received).not.toMatchObject(expected)\n\nExpected: not ${show(expected)}\n${recv}`
+                    : `expect(received).toMatchObject(expected)\n\n- Received\n+ Expected\n\n${formatDiff(actual, expected)}`,
+            };
+        }
+        case "toBeNull":
+            return simple(actual === null, "");
+        case "toBeUndefined":
+            return simple(actual === undefined, "");
+        case "toBeDefined":
+            return simple(actual !== undefined, "");
+        case "toBeTruthy":
+            return simple(!!actual, "");
+        case "toBeFalsy":
+            return simple(!actual, "");
+        case "toBeNaN":
+            return simple(typeof actual === "number" && Number.isNaN(actual), "");
+        case "toBeTypeOf":
+            return simple(typeof actual === expected, `Received type: ${typeof actual}`);
+        case "toBeInstanceOf":
+            return simple(typeof expected === "function" && actual instanceof expected, `Expected constructor: ${expected?.name ?? String(expected)}`);
+        case "toBeGreaterThan":
+            return simple(actual > expected, "");
+        case "toBeGreaterThanOrEqual":
+            return simple(actual >= expected, "");
+        case "toBeLessThan":
+            return simple(actual < expected, "");
+        case "toBeLessThanOrEqual":
+            return simple(actual <= expected, "");
+        case "toBeCloseTo": {
+            const digits = args[1] ?? 2;
+            return simple(typeof actual === "number" && closeTo(actual, expected, digits), `Expected precision: ${digits}\nExpected difference: < ${10 ** -digits / 2}\nReceived difference: ${Math.abs(expected - actual)}`);
+        }
+        case "toBeOneOf":
+            return simple(expected.some((v) => deepEquals(actual, v)), "");
+        case "toContain": {
+            let pass = false;
+            if (typeof actual === "string")
+                pass = actual.includes(String(expected));
+            else if (actual && typeof actual[Symbol.iterator] === "function") {
+                for (const item of actual) {
+                    if (item === expected || Object.is(item, expected)) {
+                        pass = true;
+                        break;
+                    }
+                }
+            }
+            return simple(pass, "");
+        }
+        case "toContainEqual": {
+            let pass = false;
+            if (actual && typeof actual[Symbol.iterator] === "function") {
+                for (const item of actual) {
+                    if (deepEquals(item, expected)) {
+                        pass = true;
+                        break;
+                    }
+                }
+            }
+            return simple(pass, "");
+        }
+        case "toInclude":
+            return simple(typeof actual === "string" && actual.includes(expected), "");
+        case "toStartWith":
+            return simple(typeof actual === "string" && actual.startsWith(expected), "");
+        case "toEndWith":
+            return simple(typeof actual === "string" && actual.endsWith(expected), "");
+        case "toMatch":
+            return simple(typeof actual === "string" &&
+                (typeof expected === "string" ? actual.includes(expected) : (expected.lastIndex = 0, expected.test(actual))), "");
+        case "toHaveLength": {
+            const len = lengthOf(actual);
+            return simple(len === expected, `Received length: ${len}`);
+        }
+        case "toHaveProperty": {
+            const { found, value } = getPath(actual, expected);
+            const pass = found && (args.length < 2 || deepEquals(value, args[1]));
+            return simple(pass, found ? `Received value: ${show(value)}` : "Property not found");
+        }
+        case "toBeEmpty": {
+            let pass = false;
+            if (typeof actual === "string" || Array.isArray(actual))
+                pass = actual.length === 0;
+            else if (actual instanceof Map || actual instanceof Set)
+                pass = actual.size === 0;
+            else if (actual && typeof actual === "object")
+                pass = Object.keys(actual).length === 0;
+            return simple(pass, "");
+        }
+        case "toHaveBeenCalled": {
+            const m = requireMock(actual, name);
+            return simple(m.mock.calls.length > 0, `Number of calls: ${m.mock.calls.length}`);
+        }
+        case "toHaveBeenCalledTimes": {
+            const m = requireMock(actual, name);
+            return simple(m.mock.calls.length === expected, `Number of calls: ${m.mock.calls.length}`);
+        }
+        case "toHaveBeenCalledWith": {
+            const m = requireMock(actual, name);
+            return simple(m.mock.calls.some((c) => deepEquals(c, args)), `Calls:\n${m.mock.calls.map((c) => `  ${show(c)}`).join("\n") || "  (none)"}`);
+        }
+        case "toHaveBeenLastCalledWith": {
+            const m = requireMock(actual, name);
+            return simple(m.mock.lastCall !== undefined && deepEquals(m.mock.lastCall, args), `Last call: ${show(m.mock.lastCall)}`);
+        }
+        case "toHaveBeenNthCalledWith": {
+            const m = requireMock(actual, name);
+            const call = m.mock.calls[expected - 1];
+            return simple(call !== undefined && deepEquals(call, args.slice(1)), `Call ${expected}: ${show(call)}`);
+        }
+        case "toHaveReturned": {
+            const m = requireMock(actual, name);
+            return simple(m.mock.results.some((r) => r.type === "return"), "");
+        }
+        case "toHaveReturnedTimes": {
+            const m = requireMock(actual, name);
+            return simple(m.mock.results.filter((r) => r.type === "return").length === expected, "");
+        }
+        case "toHaveReturnedWith": {
+            const m = requireMock(actual, name);
+            return simple(m.mock.results.some((r) => r.type === "return" && deepEquals(r.value, expected)), "");
+        }
+    }
+    throw new TypeError(`expect: unknown matcher ${name}`);
+}
+const MATCHERS = [
+    "toBe", "toEqual", "toStrictEqual", "toMatchObject", "toBeNull", "toBeUndefined", "toBeDefined",
+    "toBeTruthy", "toBeFalsy", "toBeNaN", "toBeTypeOf", "toBeInstanceOf", "toBeGreaterThan",
+    "toBeGreaterThanOrEqual", "toBeLessThan", "toBeLessThanOrEqual", "toBeCloseTo", "toBeOneOf",
+    "toContain", "toContainEqual", "toInclude", "toStartWith", "toEndWith", "toMatch", "toHaveLength",
+    "toHaveProperty", "toBeEmpty", "toHaveBeenCalled", "toHaveBeenCalledTimes", "toHaveBeenCalledWith",
+    "toHaveBeenLastCalledWith", "toHaveBeenNthCalledWith", "toHaveReturned", "toHaveReturnedTimes",
+    "toHaveReturnedWith",
+];
+function fail(outcome, negated, message) {
+    const text = outcome.message(negated);
+    throw new AssertionError(message ? `${message}\n\n${text}` : text);
+}
+/** Matchers for a synchronous value, or (mode) for a promise's settlement. */
+function matchers(actual, negated, mode, message) {
+    const out = {};
+    const check = (name, value, args) => {
+        const outcome = evaluate(name, value, args);
+        if (outcome.pass === negated)
+            fail(outcome, negated, message);
+    };
+    const names = mode === "sync" ? MATCHERS : [...MATCHERS, "toThrow", "toThrowError"];
+    for (const name of names) {
+        out[name] = (...args) => {
+            if (mode === "sync")
+                return check(name, actual, args);
+            return (async () => {
+                let fulfilled;
+                let value;
+                try {
+                    value = await (typeof actual === "function" ? actual() : actual);
+                    fulfilled = true;
+                }
+                catch (err) {
+                    value = err;
+                    fulfilled = false;
+                }
+                if (mode === "rejects" && fulfilled) {
+                    throw new AssertionError(`expect(received).rejects.${name}()\n\nReceived promise resolved instead of rejected\nResolved to value: ${show(value)}`);
+                }
+                if (mode === "resolves" && !fulfilled) {
+                    throw new AssertionError(`expect(received).resolves.${name}()\n\nReceived promise rejected instead of resolved\nRejected to value: ${show(value)}`);
+                }
+                // `.rejects.toThrow(x)` matches the reason itself.
+                if (mode === "rejects" && (name === "toThrow" || name === "toThrowError")) {
+                    const pass = throwMatches(value, args[0]);
+                    if (pass === negated) {
+                        fail({ pass, message: (neg) => `expect(received).rejects.${neg ? "not." : ""}${name}(${args.map(show).join(", ")})\n\nReceived: ${show(value)}` }, negated, message);
+                    }
+                    return;
+                }
+                if (name === "toThrow" || name === "toThrowError") {
+                    throw new AssertionError(`expect(received).resolves.${name}() is not supported; use .rejects.${name}()`);
+                }
+                check(name, value, args);
+            })();
+        };
+    }
+    for (const name of ["toThrow", "toThrowError"]) {
+        if (mode !== "sync")
+            continue;
+        out[name] = (expected) => {
+            if (typeof actual !== "function")
+                throw new AssertionError(`expect(received).${name}()\n\nReceived value must be a function`);
+            let threw = false;
+            let error;
+            try {
+                actual();
+            }
+            catch (err) {
+                threw = true;
+                error = err;
+            }
+            const pass = threw && throwMatches(error, expected);
+            if (pass === negated) {
+                fail({
+                    pass,
+                    message: (neg) => `expect(received).${neg ? "not." : ""}${name}(${expected === undefined ? "" : show(expected)})\n\n${threw ? `Thrown: ${show(error)}` : "Received function did not throw"}`,
+                }, negated, message);
+            }
+        };
+    }
+    Object.defineProperty(out, "not", { get: () => matchers(actual, !negated, mode, message) });
+    return out;
+}
+export const expect = Object.assign((actual, message) => {
+    const base = matchers(actual, false, "sync", message);
+    Object.defineProperty(base, "resolves", { get: () => matchers(actual, false, "resolves", message) });
+    Object.defineProperty(base, "rejects", { get: () => matchers(actual, false, "rejects", message) });
+    return base;
+}, {
+    anything: () => asymmetric("Anything", (o) => o !== null && o !== undefined),
+    any: (ctor) => asymmetric(`Any<${ctor?.name}>`, (o) => {
+        if (ctor === String)
+            return typeof o === "string" || o instanceof String;
+        if (ctor === Number)
+            return typeof o === "number" || o instanceof Number;
+        if (ctor === Boolean)
+            return typeof o === "boolean" || o instanceof Boolean;
+        if (ctor === BigInt)
+            return typeof o === "bigint";
+        if (ctor === Symbol)
+            return typeof o === "symbol";
+        if (ctor === Function)
+            return typeof o === "function";
+        if (ctor === Object)
+            return typeof o === "object" && o !== null;
+        return typeof ctor === "function" && o instanceof ctor;
+    }),
+    objectContaining: (obj) => objectContaining(obj, false),
+    arrayContaining: (items) => arrayContaining(items, false),
+    stringContaining: (s) => stringContaining(s, false),
+    stringMatching: (p) => stringMatching(p, false),
+    closeTo: (n, digits = 2) => asymmetric(`NumberCloseTo ${n} (${digits} digits)`, (o) => typeof o === "number" && closeTo(o, n, digits)),
+    not: {
+        objectContaining: (obj) => objectContaining(obj, true),
+        arrayContaining: (items) => arrayContaining(items, true),
+        stringContaining: (s) => stringContaining(s, true),
+        stringMatching: (p) => stringMatching(p, true),
+    },
+});
+function objectContaining(obj, invert) {
+    return asymmetric(`${invert ? "Not" : ""}ObjectContaining ${format(obj)}`, (o) => {
+        const pass = typeof o === "object" && o !== null &&
+            ownKeys(obj, true).every((k) => k in o && deepEquals(o[k], obj[k]));
+        return pass !== invert;
+    });
+}
+function arrayContaining(items, invert) {
+    return asymmetric(`${invert ? "Not" : ""}ArrayContaining ${format(items)}`, (o) => {
+        const pass = Array.isArray(o) && items.every((i) => o.some((x) => deepEquals(x, i)));
+        return pass !== invert;
+    });
+}
+function stringContaining(s, invert) {
+    return asymmetric(`${invert ? "Not" : ""}StringContaining ${JSON.stringify(s)}`, (o) => (typeof o === "string" && o.includes(s)) !== invert);
+}
+function stringMatching(p, invert) {
+    const re = typeof p === "string" ? new RegExp(p) : p;
+    return asymmetric(`${invert ? "Not" : ""}StringMatching ${re}`, (o) => (typeof o === "string" && ((re.lastIndex = 0), re.test(o))) !== invert);
+}

package/dist/test/node.d.ts

@@ -3,13 +3,10 @@
  * standard `node:test` runner, which Node runs natively and other runtimes
  * implement for compatibility.
  */
-import type { DescribeFunction, Hook, TestFunction, TestRuntime } from "./api.ts";
+import type { TestRuntime } from "./api.ts";
 export * from "./assert.ts";
+export { createMock, deepEquals, expect, isMock, spyOn } from "./expect.ts";
 export type * from "./api.ts";
+export type { Assertion, AsymmetricMatcher, Expect, Matchers, Mock, MockResult, MockState } from "./expect.ts";
 export declare const runtime: TestRuntime;
-export declare const test: TestFunction;
-export declare const describe: DescribeFunction;
-export declare const beforeAll: Hook;
-export declare const afterAll: Hook;
-export declare const beforeEach: Hook;
-export declare const afterEach: Hook;
+export declare const test: import("./api.ts").TestFunction, it: import("./api.ts").TestFunction, describe: import("./api.ts").DescribeFunction, beforeAll: import("./api.ts").Hook, afterAll: import("./api.ts").Hook, beforeEach: import("./api.ts").Hook, afterEach: import("./api.ts").Hook, mock: import("./api.ts").MockFunction;

package/dist/test/node.js

@@ -4,26 +4,36 @@
  * implement for compatibility.
  */
 import * as node from "node:test";
+import { createTestApi } from "./core.js";
 export * from "./assert.js";
+export { createMock, deepEquals, expect, isMock, spyOn } from "./expect.js";
 export const runtime = "node";
 // node:test passes a context (and a `done` callback to 2-arity functions);
 // the 1tube contract has neither, so wrap to keep the arity at zero.
-const register = (name, fn, options) => node.test(name, { timeout: options.timeout, skip: options.skip, only: options.only }, async () => {
+const wrap = (fn) => async () => {
     await fn();
-});
-export const test = Object.assign((name, fn, options = {}) => void register(name, fn, options), {
-    skip: (name, fn, options = {}) => void register(name, fn, { ...options, skip: true }),
-    only: (name, fn, options = {}) => void register(name, fn, { ...options, only: true }),
+};
+export const { test, it, describe, beforeAll, afterAll, beforeEach, afterEach, mock } = createTestApi({
+    test: (name, fn, { timeout, skip, only }) => void node.test(name, { timeout, skip, only }, wrap(fn)),
     todo: (name) => void node.test(name, { todo: true }),
+    describe: (name, fn, mode) => void node.describe(name, { skip: mode === "skip", only: mode === "only" }, fn),
+    beforeAll: (fn) => node.before(wrap(fn)),
+    afterAll: (fn) => node.after(wrap(fn)),
+    beforeEach: (fn) => node.beforeEach(wrap(fn)),
+    afterEach: (fn) => node.afterEach(wrap(fn)),
+    mockModule: (specifier, factory) => {
+        const moduleMock = node.mock.module;
+        if (typeof moduleMock !== "function") {
+            throw new Error("mock.module on node:test needs `node --test --experimental-test-module-mocks`");
+        }
+        const exports = factory();
+        if (exports && typeof exports.then === "function") {
+            throw new Error("mock.module on node:test needs a synchronous factory");
+        }
+        const { default: defaultExport, ...namedExports } = exports;
+        moduleMock.call(node.mock, specifier, {
+            namedExports,
+            ...("default" in exports ? { defaultExport } : {}),
+        });
+    },
 });
-export const describe = Object.assign((name, fn) => void node.describe(name, fn), {
-    skip: (name, fn) => void node.describe(name, { skip: true }, fn),
-    only: (name, fn) => void node.describe(name, { only: true }, fn),
-});
-const hook = (register) => (fn) => register(async () => {
-    await fn();
-});
-export const beforeAll = hook((fn) => node.before(fn));
-export const afterAll = hook((fn) => node.after(fn));
-export const beforeEach = hook((fn) => node.beforeEach(fn));
-export const afterEach = hook((fn) => node.afterEach(fn));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "1tube",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "private": false,
   "description": "Self-hosted Supabase Edge Functions gateway on Bun, plus an ESLint plugin for consumers",
   "license": "MIT",