@zudojs/testing 1.0.0 → 1.1.0

package/README.md

@@ -66,8 +66,14 @@ assertResponseBody(response, { id: "u_1", roles: new Set(["admin"]) });
 - `cleanup.dispose()` rejects with an `AggregateError` when any cleanup fails,
   after running them all.
 - `mockResolvedValue` and `mockRejectedValue` return promises; `results` stays
-  aligned index-for-index with `calls`.
+  aligned index-for-index with `calls`, even when the implementation throws
+  (the slot holds `undefined` and the thrown value lands in `errors`).
 - Spies forward their receiver, so a method reading `this` still works.
+- `assertThrows` is for synchronous code. Handing it an async function throws
+  "use assertRejects" instead of a misleading "did not throw", and the
+  rejection is handled rather than leaked.
+- `findByMetadata` and the structural assertions compare `Set` members and
+  `Map` keys by value, so `new Set([{ id: 1 }])` matches `new Set([{ id: 1 }])`.
 
 ## Use Cases
 

package/dist/assertions/deepEqual.core.js

@@ -87,11 +87,18 @@ function diff(actual, expected, path, seen) {
                 reason: `expected ${expected.size} entries, received ${actual.size}`,
             };
         }
+        // Keys are matched by identity first and structurally second, so a
+        // Map keyed by objects compares by value like everything else here.
+        const unmatched = [...actual.keys()];
         for (const [key, value] of expected) {
-            if (!actual.has(key)) {
+            const actualKey = actual.has(key)
+                ? key
+                : findStructuralMatch(unmatched, key, seen);
+            if (actualKey === NO_MATCH) {
                 return { path, reason: `missing key ${describeValue(key)}` };
             }
-            const found = diff(actual.get(key), value, `${path}[${describeValue(key)}]`, seen);
+            unmatched.splice(unmatched.indexOf(actualKey), 1);
+            const found = diff(actual.get(actualKey), value, `${path}[${describeValue(key)}]`, seen);
             if (found)
                 return found;
         }
@@ -104,10 +111,18 @@ function diff(actual, expected, path, seen) {
                 reason: `expected ${expected.size} items, received ${actual.size}`,
             };
         }
+        // `Set.has` is identity-based, so two Sets holding equal but distinct
+        // objects compared unequal. Each expected entry is matched against a
+        // still-unmatched actual entry structurally instead.
+        const unmatched = [...actual];
         for (const entry of expected) {
-            if (!actual.has(entry)) {
+            const match = actual.has(entry)
+                ? entry
+                : findStructuralMatch(unmatched, entry, seen);
+            if (match === NO_MATCH) {
                 return { path, reason: `missing item ${describeValue(entry)}` };
             }
+            unmatched.splice(unmatched.indexOf(match), 1);
         }
         return undefined;
     }
@@ -146,6 +161,21 @@ function diff(actual, expected, path, seen) {
     }
     return undefined;
 }
+const NO_MATCH = Symbol("deepEqual.noMatch");
+/**
+ * Finds a candidate structurally equal to `expected`. Each probe walks a
+ * copy of `seen`: the cycle guard records a pair as "assumed equal" before
+ * comparing it, and a probe that fails must not leave that assumption
+ * behind for the next candidate.
+ */
+function findStructuralMatch(candidates, expected, seen) {
+    for (const candidate of candidates) {
+        if (diff(candidate, expected, "", new Map(seen)) === undefined) {
+            return candidate;
+        }
+    }
+    return NO_MATCH;
+}
 /**
  * Find the first structural difference between two values.
  *

package/dist/assertions/errorAssertions.core.js

@@ -13,8 +13,9 @@ import { describeValue } from "./deepEqual.describe.js";
  * @returns The thrown error.
  */
 export function assertThrows(fn, expectedMessage) {
+    let returned;
     try {
-        fn();
+        returned = fn();
     }
     catch (error) {
         if (expectedMessage !== undefined) {
@@ -25,8 +26,21 @@ export function assertThrows(fn, expectedMessage) {
         }
         return error instanceof Error ? error : new Error(String(error));
     }
+    if (isThenable(returned)) {
+        // An async function never throws synchronously; its failure is a
+        // rejection. Reporting "did not throw" was misleading, and the
+        // rejected promise nobody awaited surfaced as an unhandled rejection
+        // blamed on whichever test happened to be running.
+        void returned.then(undefined, () => undefined);
+        throw new Error("assertThrows received a function that returned a promise; use assertRejects for async functions.");
+    }
     throw new Error("Expected function to throw, but it did not.");
 }
+function isThenable(value) {
+    return (value !== null &&
+        (typeof value === "object" || typeof value === "function") &&
+        typeof value.then === "function");
+}
 /**
  * Asserts that an async function rejects.
  *

package/dist/cleanupManager/cleanupManager.core.js

@@ -15,6 +15,7 @@ export function createCleanupManager(options = {}) {
     const entries = [];
     let nextId = 0;
     let disposed = false;
+    let inFlight;
     const register = (fn, label = `cleanup-${nextId}`) => {
         if (disposed) {
             throw new Error("Cannot register cleanup after manager has been disposed.");
@@ -25,11 +26,7 @@ export function createCleanupManager(options = {}) {
             fn,
         });
     };
-    const dispose = async () => {
-        if (disposed) {
-            return;
-        }
-        disposed = true;
+    const runCleanups = async () => {
         const errors = [];
         const reversed = [...entries].reverse();
         for (const entry of reversed) {
@@ -49,6 +46,23 @@ export function createCleanupManager(options = {}) {
                 .join(", ")}`);
         }
     };
+    /**
+     * Runs the cleanups once. A second call made while the first is still
+     * running shares its promise, so nobody is told "disposed" before the
+     * resources are actually released; a call after completion resolves
+     * immediately.
+     */
+    const dispose = () => {
+        if (inFlight)
+            return inFlight;
+        if (disposed)
+            return Promise.resolve();
+        disposed = true;
+        inFlight = runCleanups().finally(() => {
+            inFlight = undefined;
+        });
+        return inFlight;
+    };
     return {
         get disposed() {
             return disposed;

package/dist/mocking/mockFn.core.d.ts

@@ -9,8 +9,14 @@
 export interface MockFn<TArgs extends readonly unknown[] = unknown[], TResult = unknown> {
     (...args: TArgs): TResult;
     readonly calls: readonly TArgs[];
-    /** Result of each call, aligned index-for-index with {@link calls}. */
+    /**
+     * Result of each call, aligned index-for-index with {@link calls}. A
+     * call whose implementation threw occupies its slot with `undefined`;
+     * the thrown value is in {@link errors}.
+     */
     readonly results: readonly TResult[];
+    /** Values thrown by the implementation, in call order. */
+    readonly errors: readonly unknown[];
     readonly invoked: boolean;
     readonly callCount: number;
     mockReturnValue: (value: TResult) => void;

package/dist/mocking/mockFn.core.js

@@ -23,6 +23,7 @@
 export function createMockFn(defaultReturnValue) {
     const calls = [];
     const results = [];
+    const errors = [];
     const initialMode = arguments.length > 0
         ? { kind: "value", value: defaultReturnValue }
         : { kind: "none" };
@@ -50,7 +51,17 @@ export function createMockFn(defaultReturnValue) {
     };
     const mock = ((...args) => {
         calls.push(args);
-        const result = produce(args);
+        let result;
+        try {
+            result = produce(args);
+        }
+        catch (error) {
+            // Keep `results` aligned with `calls` even when the implementation
+            // throws; otherwise every later result shifts one index left.
+            results.push(undefined);
+            errors.push(error);
+            throw error;
+        }
         results.push(result);
         return result;
     });
@@ -62,6 +73,10 @@ export function createMockFn(defaultReturnValue) {
         get: () => results,
         enumerable: true,
     });
+    Object.defineProperty(mock, "errors", {
+        get: () => errors,
+        enumerable: true,
+    });
     Object.defineProperty(mock, "invoked", {
         get: () => calls.length > 0,
         enumerable: true,
@@ -85,11 +100,13 @@ export function createMockFn(defaultReturnValue) {
     mock.mockReset = () => {
         calls.length = 0;
         results.length = 0;
+        errors.length = 0;
         mode = initialMode;
     };
     mock.mockClear = () => {
         calls.length = 0;
         results.length = 0;
+        errors.length = 0;
     };
     return mock;
 }

package/dist/spyLogger/spyLogger.context.d.ts

@@ -14,6 +14,14 @@ export declare function mergeLoggerContext(base: LoggerContext | undefined, next
  * top level, the way a real transport would render it.
  */
 export declare function mergeContext(context: LoggerContext | undefined, metadata: LogMetadata | undefined): LogMetadata | undefined;
-/** Structural comparison, so object metadata can actually be matched. */
+/**
+ * Structural comparison, so object metadata can actually be matched.
+ *
+ * Uses the same walker as the assertions. The previous
+ * `JSON.stringify` comparison matched any two `Map`s or `Set`s (both
+ * render as `{}`), dropped `undefined` values, and treated key order as
+ * significant, so `findByMetadata` could both match what it should not
+ * and miss what it should find.
+ */
 export declare function deepMatches(actual: unknown, expected: unknown): boolean;
 //# sourceMappingURL=spyLogger.context.d.ts.map

package/dist/spyLogger/spyLogger.context.js

@@ -3,6 +3,7 @@
  *
  * @module spyLogger/spyLogger.context
  */
+import { deepEqual } from "../assertions/deepEqual.core.js";
 /** Merges two logger contexts, preserving the nested shape. */
 export function mergeLoggerContext(base, next) {
     if (!base)
@@ -28,14 +29,16 @@ export function mergeContext(context, metadata) {
         ...metadata,
     };
 }
-/** Structural comparison, so object metadata can actually be matched. */
+/**
+ * Structural comparison, so object metadata can actually be matched.
+ *
+ * Uses the same walker as the assertions. The previous
+ * `JSON.stringify` comparison matched any two `Map`s or `Set`s (both
+ * render as `{}`), dropped `undefined` values, and treated key order as
+ * significant, so `findByMetadata` could both match what it should not
+ * and miss what it should find.
+ */
 export function deepMatches(actual, expected) {
-    if (Object.is(actual, expected))
-        return true;
-    if (typeof actual !== "object" || typeof expected !== "object")
-        return false;
-    if (actual === null || expected === null)
-        return false;
-    return JSON.stringify(actual) === JSON.stringify(expected);
+    return deepEqual(actual, expected);
 }
 //# sourceMappingURL=spyLogger.context.js.map

package/dist/spyLogger/spyLogger.recording.js

@@ -59,10 +59,21 @@ export function createRecordingLogger(recorder, derived, initialLevel, initially
         log: (logLevel, message, options) => {
             record("log", logLevel, message, options?.metadata);
         },
-        child: (options) => createRecordingLogger(recorder, {
-            name: `${derived.name}.${options?.name ?? "child"}`,
-            ...(derived.context ? { context: derived.context } : {}),
-        }, level, enabled),
+        // A real child logger merges `options.metadata` into every entry it
+        // writes and may lower its own level; the spy mirrors both so a test
+        // can assert on `logger.child({ metadata: { module } })` output.
+        child: (options) => {
+            const context = options?.metadata
+                ? mergeLoggerContext(derived.context, {
+                    identifiers: {},
+                    metadata: options.metadata,
+                })
+                : derived.context;
+            return createRecordingLogger(recorder, {
+                name: `${derived.name}.${options?.name ?? "child"}`,
+                ...(context ? { context } : {}),
+            }, options?.level ?? level, enabled);
+        },
         withContext: (context) => createRecordingLogger(recorder, {
             name: derived.name,
             context: mergeLoggerContext(derived.context, context),

package/dist/testClock/testClock.core.js

@@ -53,6 +53,11 @@ export function createTestClock(initialTime) {
             (duration.minutes ?? 0) * 60_000 +
             (duration.hours ?? 0) * 3_600_000 +
             (duration.days ?? 0) * 86_400_000;
+        // Validated like `advance`: a NaN or Infinity component silently turned
+        // the clock into `Invalid Date` and every later assertion on it lied.
+        if (!Number.isFinite(ms)) {
+            throw new TypeError(`Cannot add ${JSON.stringify(duration)} to the clock: the duration is not finite.`);
+        }
         currentTime += ms;
     };
     const reset = () => {

package/dist/testSerialization/serializationAssertions.core.js

@@ -5,6 +5,7 @@
  */
 import { JSONSerializer } from "@zudojs/serialization";
 import { findDifference } from "../assertions/deepEqual.core.js";
+import { describeValue } from "../assertions/deepEqual.describe.js";
 const defaultSerializer = new JSONSerializer();
 /**
  * Assert that a value round-trips through serialization correctly.
@@ -66,7 +67,11 @@ export function assertTypePreservesRoundTrip(value, checker, description) {
     const json = serializer.serialize(value, { preserveTypes: true });
     const restored = serializer.deserialize(json, { preserveTypes: true });
     if (!checker(restored)) {
-        throw new Error(`Type preservation failed for ${description}: ${JSON.stringify(value)} → ${JSON.stringify(restored)}`);
+        // Rendered with `describeValue`, not `JSON.stringify`: the values this
+        // helper exists for (BigInt, Map, Set, circular graphs) are exactly the
+        // ones `JSON.stringify` refuses, so the failure used to surface as a
+        // TypeError from the message itself rather than as the assertion.
+        throw new Error(`Type preservation failed for ${description}: ${describeValue(value)} → ${describeValue(restored)}`);
     }
 }
 //# sourceMappingURL=serializationAssertions.core.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zudojs/testing",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Test helpers, fixtures, mocks, and utilities for testing Zudojs applications.",
   "type": "module",
   "main": "./dist/index.js",
@@ -19,21 +19,21 @@
     "!dist/.tsbuildinfo"
   ],
   "dependencies": {
-    "@zudojs/config": "1.0.0",
-    "@zudojs/constants": "1.0.0",
-    "@zudojs/container": "1.0.0",
-    "@zudojs/errors": "1.0.0",
-    "@zudojs/events": "1.0.0",
-    "@zudojs/http": "1.0.0",
-    "@zudojs/logger": "1.0.0",
-    "@zudojs/messaging": "1.0.0",
-    "@zudojs/middleware": "1.0.0",
-    "@zudojs/queue": "1.0.0",
-    "@zudojs/security": "1.0.0",
-    "@zudojs/serialization": "1.0.0",
-    "@zudojs/storage": "1.0.0",
+    "@zudojs/config": "1.0.1",
+    "@zudojs/constants": "1.0.1",
+    "@zudojs/container": "1.1.0",
+    "@zudojs/errors": "1.0.1",
+    "@zudojs/events": "1.0.1",
+    "@zudojs/http": "1.1.0",
+    "@zudojs/logger": "1.1.0",
+    "@zudojs/messaging": "1.0.1",
+    "@zudojs/middleware": "1.0.1",
+    "@zudojs/queue": "1.1.0",
+    "@zudojs/security": "1.0.1",
+    "@zudojs/serialization": "1.0.1",
+    "@zudojs/storage": "1.1.0",
     "@zudojs/types": "1.0.0",
-    "@zudojs/validation": "1.0.0"
+    "@zudojs/validation": "1.0.1"
   },
   "devDependencies": {
     "typescript": "7.0.2",
@@ -43,6 +43,10 @@
     "node": ">=24.0.0"
   },
   "license": "MIT",
+  "author": {
+    "name": "Oluwayemi Oyinlola",
+    "url": "https://github.com/oyinlola-tech"
+  },
   "publishConfig": {
     "access": "public"
   },