@zudojs/testing 0.1.0 → 1.0.0

package/dist/spyLogger/spyLogger.recording.js

@@ -0,0 +1,89 @@
+/**
+ * @zudojs/testing — Recording logger construction.
+ *
+ * Split from the factory so a derived logger — `child()` or `withContext()` —
+ * is built the same way as its parent and shares the same recording.
+ *
+ * @module spyLogger/spyLogger.recording
+ */
+import { deepMatches, mergeContext, mergeLoggerContext, } from "./spyLogger.context.js";
+/** Numeric level for each method, ascending in verbosity. */
+export const LEVELS = {
+    fatal: 0,
+    error: 1,
+    warn: 2,
+    info: 3,
+    debug: 4,
+    trace: 5,
+};
+/** Builds a logger over an existing recording. */
+export function createRecordingLogger(recorder, derived, initialLevel, initiallyEnabled) {
+    let level = initialLevel;
+    let enabled = initiallyEnabled;
+    /** Records a call, honouring the configured level and enabled state. */
+    const record = (method, callLevel, message, metadata) => {
+        if (!enabled)
+            return;
+        if (callLevel > level)
+            return;
+        recorder.calls.push({
+            method,
+            level: callLevel,
+            message,
+            metadata: mergeContext(derived.context, metadata),
+            timestamp: new Date(),
+        });
+    };
+    const at = (method) => (message, metadata) => {
+        record(method, LEVELS[method], message, metadata);
+    };
+    return {
+        get name() {
+            return derived.name;
+        },
+        get level() {
+            return level;
+        },
+        get enabled() {
+            return enabled;
+        },
+        get calls() {
+            return [...recorder.calls];
+        },
+        fatal: at("fatal"),
+        error: at("error"),
+        warn: at("warn"),
+        info: at("info"),
+        debug: at("debug"),
+        trace: at("trace"),
+        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),
+        withContext: (context) => createRecordingLogger(recorder, {
+            name: derived.name,
+            context: mergeLoggerContext(derived.context, context),
+        }, level, enabled),
+        setLevel: (newLevel) => {
+            level = newLevel;
+        },
+        enable: () => {
+            enabled = true;
+        },
+        disable: () => {
+            enabled = false;
+        },
+        flush: async () => { },
+        close: async () => { },
+        clear: () => {
+            recorder.calls.length = 0;
+        },
+        findByMethod: (method) => recorder.calls.filter((call) => call.method === method),
+        findByMessage: (substring) => recorder.calls.filter((call) => call.message.includes(substring)),
+        findByMetadata: (key, value) => recorder.calls.filter((call) => call.metadata !== undefined && deepMatches(call.metadata[key], value)),
+    };
+}
+//# sourceMappingURL=spyLogger.recording.js.map

package/dist/testApplication/testApplication.core.js

@@ -30,12 +30,15 @@ export function createTestApplication(options = {}) {
     const logger = options.logger ?? createLogger({ name });
     const clock = options.clock ?? createTestClock();
     const cleanup = options.cleanup ?? createCleanupManager();
-    cleanup.register(async () => {
-        container.dispose();
-    }, "container-dispose");
+    // Cleanups run in reverse registration order, so the logger is registered
+    // first and therefore closed last: anything that logs while the container
+    // disposes still has somewhere to write.
     cleanup.register(async () => {
         await logger.close();
     }, "logger-close");
+    cleanup.register(async () => {
+        await container.dispose();
+    }, "container-dispose");
     const dispose = async () => {
         await cleanup.dispose();
     };

package/dist/testClock/testClock.core.js

@@ -23,12 +23,29 @@
  * ```
  */
 export function createTestClock(initialTime) {
-    let currentTime = initialTime ? new Date(initialTime).getTime() : Date.now();
+    /**
+     * Resolve a caller-supplied instant.
+     *
+     * Tested against `undefined`, not truthiness: epoch 0 is the natural choice
+     * for a deterministic test, and treating it as "not supplied" silently
+     * handed back the real clock in the one place determinism was requested.
+     */
+    const toTimestamp = (value) => {
+        const timestamp = new Date(value).getTime();
+        if (Number.isNaN(timestamp)) {
+            throw new TypeError(`Invalid test clock time: ${JSON.stringify(value)} is not a valid date.`);
+        }
+        return timestamp;
+    };
+    let currentTime = initialTime === undefined ? Date.now() : toTimestamp(initialTime);
     const now = () => new Date(currentTime);
     const set = (date) => {
-        currentTime = new Date(date).getTime();
+        currentTime = toTimestamp(date);
     };
     const advance = (ms) => {
+        if (!Number.isFinite(ms)) {
+            throw new TypeError(`Cannot advance the clock by ${String(ms)}.`);
+        }
         currentTime += ms;
     };
     const add = (duration) => {

package/dist/testContext/testContext.recorder.core.js

@@ -10,7 +10,7 @@ export function createLogRecorder() {
     const entries = [];
     return {
         get entries() {
-            return entries;
+            return [...entries];
         },
         record: (level, message, metadata) => {
             entries.push({
@@ -34,7 +34,7 @@ export function createEventRecorder() {
     const entries = [];
     return {
         get entries() {
-            return entries;
+            return [...entries];
         },
         record: (type, payload) => {
             entries.push({
@@ -56,7 +56,7 @@ export function createMessageRecorder() {
     const entries = [];
     return {
         get entries() {
-            return entries;
+            return [...entries];
         },
         record: (type, payload) => {
             entries.push({

package/dist/testEventBus/testEventBus.core.js

@@ -4,6 +4,7 @@
  * Wraps the real EventBus with recording and assertion support.
  */
 import { EventBus } from "@zudojs/events";
+import { randomUUID } from "node:crypto";
 /**
  * Creates a test event bus with recording.
  *
@@ -28,7 +29,7 @@ export function createTestEventBus(options = {}) {
     bus.start();
     const publish = async (input) => {
         const event = {
-            id: `evt_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            id: `evt_${randomUUID()}`,
             type: input.type,
             payload: input.payload,
             timestamp: new Date(),
@@ -51,7 +52,9 @@ export function createTestEventBus(options = {}) {
     };
     return {
         bus,
-        published,
+        get published() {
+            return [...published];
+        },
         publish,
         findByType,
         clear,

package/dist/testMessageBus/testMessageBus.core.js

@@ -4,6 +4,7 @@
  * Wraps the real MessageBus with recording and assertion support.
  */
 import { createMessageBus } from "@zudojs/messaging";
+import { randomUUID } from "node:crypto";
 /**
  * Creates a test message bus with recording.
  *
@@ -28,7 +29,7 @@ export function createTestMessageBus(options = {}) {
     const dispatched = [];
     const send = async (input, dispatchOptions) => {
         const message = {
-            id: `msg_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            id: `msg_${randomUUID()}`,
             type: input.type,
             payload: input.payload,
             timestamp: new Date(),
@@ -51,7 +52,9 @@ export function createTestMessageBus(options = {}) {
     };
     return {
         bus,
-        dispatched,
+        get dispatched() {
+            return [...dispatched];
+        },
         send,
         findByType,
         clear,

package/dist/testQueue/testQueue.core.js

@@ -25,7 +25,9 @@ export function createTestQueue(name, options) {
     };
     return {
         queue,
-        jobs: recordedJobs,
+        get jobs() {
+            return [...recordedJobs];
+        },
         add,
         findByName,
         getStats,

package/dist/testSerialization/serializationAssertions.core.js

@@ -4,6 +4,7 @@
  * Helpers for testing serialization round-trips and type preservation.
  */
 import { JSONSerializer } from "@zudojs/serialization";
+import { findDifference } from "../assertions/deepEqual.core.js";
 const defaultSerializer = new JSONSerializer();
 /**
  * Assert that a value round-trips through serialization correctly.
@@ -19,8 +20,15 @@ export function assertSerializesCorrectly(value, options) {
     const restored = serializer.deserialize(json, {
         preserveTypes: options?.preserveTypes,
     });
-    if (JSON.stringify(restored) !== JSON.stringify(value)) {
-        throw new Error(`Serialization round-trip failed: expected ${JSON.stringify(value)}, got ${JSON.stringify(restored)}`);
+    /*
+     * Compared structurally, not by JSON string. `JSON.stringify` renders a Map
+     * or a Set as `{}`, so a round trip that silently dropped one compared equal
+     * to the original and this assertion passed — precisely the failure it exists
+     * to catch.
+     */
+    const difference = findDifference(restored, value, "value");
+    if (difference) {
+        throw new Error(`Serialization round-trip failed at ${difference.path}: ${difference.reason}.`);
     }
 }
 /**
@@ -43,8 +51,9 @@ export function assertDeserializesTo(json, expected, options) {
     const actual = serializer.deserialize(json, {
         preserveTypes: options?.preserveTypes,
     });
-    if (JSON.stringify(actual) !== JSON.stringify(expected)) {
-        throw new Error(`Expected deserialized value ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+    const difference = findDifference(actual, expected, "value");
+    if (difference) {
+        throw new Error(`Deserialized value mismatch at ${difference.path}: ${difference.reason}.`);
     }
 }
 /**

package/dist/testStorage/testStorageMemory.core.d.ts

@@ -12,19 +12,27 @@
  */
 export declare class InMemoryTestStorage {
     private readonly store;
-    /** Get a value by key. */
+    /** Drops the entry when its TTL has passed. Returns the live entry. */
+    private live;
+    /**
+     * Get a value by key.
+     *
+     * Returns null for a miss. Use {@link has} to tell a miss apart from a
+     * stored `null` — caching a negative result is exactly the case a cache
+     * test needs to distinguish.
+     */
     get<T = unknown>(key: string): T | null;
     /** Set a value with optional TTL in milliseconds. */
     set(key: string, value: unknown, ttlMs?: number): void;
     /** Delete a value by key. Returns true if deleted. */
     delete(key: string): boolean;
-    /** Check if a key exists and is not expired. */
+    /** Check if a key exists and is not expired, whatever its value. */
     has(key: string): boolean;
     /** Clear all entries. */
     clear(): void;
-    /** Get all keys. */
+    /** Get all live keys, excluding expired entries. */
     keys(): string[];
-    /** Get the number of entries. */
+    /** Get the number of live entries. */
     get size(): number;
 }
 //# sourceMappingURL=testStorageMemory.core.d.ts.map

package/dist/testStorage/testStorageMemory.core.js

@@ -12,16 +12,29 @@
  */
 export class InMemoryTestStorage {
     store = new Map();
-    /** Get a value by key. */
-    get(key) {
+    /** Drops the entry when its TTL has passed. Returns the live entry. */
+    live(key) {
         const entry = this.store.get(key);
         if (!entry)
-            return null;
-        if (entry.expiresAt && entry.expiresAt < new Date()) {
+            return undefined;
+        if (entry.expiresAt && entry.expiresAt.getTime() <= Date.now()) {
             this.store.delete(key);
-            return null;
+            return undefined;
         }
-        return entry.value;
+        return entry;
+    }
+    /**
+     * Get a value by key.
+     *
+     * Returns null for a miss. Use {@link has} to tell a miss apart from a
+     * stored `null` — caching a negative result is exactly the case a cache
+     * test needs to distinguish.
+     */
+    get(key) {
+        const entry = this.live(key);
+        if (!entry)
+            return null;
+        return (entry.value ?? null);
     }
     /** Set a value with optional TTL in milliseconds. */
     set(key, value, ttlMs) {
@@ -32,21 +45,21 @@ export class InMemoryTestStorage {
     delete(key) {
         return this.store.delete(key);
     }
-    /** Check if a key exists and is not expired. */
+    /** Check if a key exists and is not expired, whatever its value. */
     has(key) {
-        return this.get(key) !== null;
+        return this.live(key) !== undefined;
     }
     /** Clear all entries. */
     clear() {
         this.store.clear();
     }
-    /** Get all keys. */
+    /** Get all live keys, excluding expired entries. */
     keys() {
-        return [...this.store.keys()];
+        return [...this.store.keys()].filter((key) => this.live(key) !== undefined);
     }
-    /** Get the number of entries. */
+    /** Get the number of live entries. */
     get size() {
-        return this.store.size;
+        return this.keys().length;
     }
 }
 //# sourceMappingURL=testStorageMemory.core.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zudojs/testing",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "description": "Test helpers, fixtures, mocks, and utilities for testing Zudojs applications.",
   "type": "module",
   "main": "./dist/index.js",
@@ -13,33 +13,30 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "!dist/**/*.map",
+    "!dist/**/*.tsbuildinfo",
+    "!dist/.tsbuildinfo"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "clean": "rm -rf dist",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "../../node_modules/.bin/vitest run"
-  },
   "dependencies": {
-    "@zudojs/config": "0.1.0",
-    "@zudojs/constants": "0.1.0",
-    "@zudojs/container": "0.1.0",
-    "@zudojs/errors": "0.1.0",
-    "@zudojs/events": "0.1.0",
-    "@zudojs/http": "0.1.0",
-    "@zudojs/logger": "0.1.0",
-    "@zudojs/messaging": "0.1.0",
-    "@zudojs/middleware": "0.1.0",
-    "@zudojs/queue": "0.1.0",
-    "@zudojs/security": "0.1.0",
-    "@zudojs/serialization": "0.1.0",
-    "@zudojs/storage": "0.1.0",
-    "@zudojs/types": "0.1.0",
-    "@zudojs/validation": "0.1.0"
+    "@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/types": "1.0.0",
+    "@zudojs/validation": "1.0.0"
   },
   "devDependencies": {
-    "typescript": "^7.0.2",
+    "typescript": "7.0.2",
     "vitest": "^4.1.11"
   },
   "engines": {
@@ -57,8 +54,18 @@
     "vitest"
   ],
   "homepage": "https://github.com/oyinlola-tech/zudo#readme",
+  "bugs": {
+    "url": "https://github.com/oyinlola-tech/zudo/issues"
+  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/oyinlola-tech/zudo"
+    "url": "https://github.com/oyinlola-tech/zudo",
+    "directory": "packages/testing"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.test.json --noEmit",
+    "test": "../../node_modules/.bin/vitest run"
   }
-}
+}