@zudojs/testing 0.1.0 → 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zudojs Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,35 +1,83 @@
 # @zudojs/testing
 
-Test helpers, fixtures, mocks, and utilities for testing Zudojs applications.
+Test helpers, fixtures, mocks, and assertions for Zudojs applications.
 
 ## Installation
 
 ```bash
-npm install @zudojs/testing
+npm install --save-dev @zudojs/testing
 ```
 
 ## Quick Start
 
 ```typescript
-import { createMockContainer, createTestLogger } from "@zudojs/testing";
+import {
+  createCleanupManager,
+  createMockFn,
+  createSpyLogger,
+  createTestClock,
+  createTestContainer,
+} from "@zudojs/testing";
 
-const container = createMockContainer();
-container.register("database", mockDatabase);
+const container = createTestContainer({
+  overrides: [{ token: databaseToken, useValue: fakeDatabase }],
+});
 
-const logger = createTestLogger();
+const logger = createSpyLogger("test");
+const clock = createTestClock(0); // pinned to the epoch
+const cleanup = createCleanupManager();
+
+const findUser = createMockFn<[string], Promise<User>>();
+findUser.mockResolvedValue({ id: "u_1" });
+
+clock.advance(60_000);
+cleanup.register(() => container.dispose(), "container");
+
+// Rejects with an AggregateError if any cleanup fails.
+await cleanup.dispose();
+```
+
+Assertions compare structurally, so they can actually fail:
+
+```typescript
+import { assertResponseStatus, assertResponseBody } from "@zudojs/testing";
+
+assertResponseStatus(response, 201);
+assertResponseBody(response, { id: "u_1", roles: new Set(["admin"]) });
 ```
 
 ## Features
 
-- Mock container for testing
-- Test fixtures and factories
-- In-memory adapters for testing
-- Test logger with assertions
-- Snapshot testing utilities
+- Test container, config, clock, and application context
+- Spy logger that records child and context loggers too
+- Mock functions, spies, and stubs
+- Recording event bus, message bus, and queue
+- HTTP request/response builders
+- Structural assertions for responses, events, errors, and serialization
+- Cleanup manager that reports what failed
+
+## Safety Notes
+
+- Assertions compare structurally, not by `JSON.stringify`. `Map`, `Set`,
+  `Date`, `BigInt`, `undefined` values and key order are all handled, and a
+  circular value reports a mismatch instead of throwing a `TypeError`.
+- `createStub()` answers `then` with `undefined`, so awaiting a stub — or
+  returning one from an async factory — resolves rather than hanging.
+- `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`, 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
 
-- Unit testing Zudojs components
-- Integration testing
-- Mocking dependencies
-- Test fixtures
+- Unit and integration testing
+- Dependency injection in tests
+- Deterministic time and randomness
+- Asserting on events, messages, and HTTP responses

package/dist/assertions/deepEqual.core.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @zudojs/testing — Structural equality for assertions.
+ *
+ * Assertions previously compared `JSON.stringify(actual) !== JSON.stringify(expected)`,
+ * which is not equality in either direction. `Map`, `Set`, functions and
+ * `undefined` values all stringify to nothing, so structurally different
+ * values compared equal and an assertion could not fail; key order is
+ * significant, so equal values compared different; and circular or `BigInt`
+ * input threw a `TypeError` out of the assertion itself.
+ *
+ * @module assertions/deepEqual
+ */
+import type { Difference } from "./deepEqual.describe.js";
+/**
+ * Find the first structural difference between two values.
+ *
+ * @param actual - The observed value.
+ * @param expected - The value it should equal.
+ * @param rootPath - Label for the root in the reported path.
+ * @returns The first difference, or undefined when the values are equal.
+ */
+export declare function findDifference(actual: unknown, expected: unknown, rootPath?: string): Difference | undefined;
+/** Whether two values are structurally equal. */
+export declare function deepEqual(actual: unknown, expected: unknown): boolean;
+//# sourceMappingURL=deepEqual.core.d.ts.map

package/dist/assertions/deepEqual.core.js

@@ -0,0 +1,194 @@
+/**
+ * @zudojs/testing — Structural equality for assertions.
+ *
+ * Assertions previously compared `JSON.stringify(actual) !== JSON.stringify(expected)`,
+ * which is not equality in either direction. `Map`, `Set`, functions and
+ * `undefined` values all stringify to nothing, so structurally different
+ * values compared equal and an assertion could not fail; key order is
+ * significant, so equal values compared different; and circular or `BigInt`
+ * input threw a `TypeError` out of the assertion itself.
+ *
+ * @module assertions/deepEqual
+ */
+import { describeValue } from "./deepEqual.describe.js";
+/** The constructor-level kind of a value, used to reject cross-type matches. */
+function kindOf(value) {
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return "array";
+    if (value instanceof Date)
+        return "date";
+    if (value instanceof RegExp)
+        return "regexp";
+    if (value instanceof Map)
+        return "map";
+    if (value instanceof Set)
+        return "set";
+    if (ArrayBuffer.isView(value))
+        return "typedarray";
+    return typeof value;
+}
+/** Finds the first structural difference between two values. */
+function diff(actual, expected, path, seen) {
+    if (Object.is(actual, expected))
+        return undefined;
+    const actualKind = kindOf(actual);
+    const expectedKind = kindOf(expected);
+    if (actualKind !== expectedKind) {
+        return {
+            path,
+            reason: `expected ${expectedKind}, received ${actualKind}`,
+        };
+    }
+    if (actual instanceof Date && expected instanceof Date) {
+        return actual.getTime() === expected.getTime()
+            ? undefined
+            : {
+                path,
+                reason: `expected ${describeValue(expected)}, received ${describeValue(actual)}`,
+            };
+    }
+    if (actual instanceof RegExp && expected instanceof RegExp) {
+        return String(actual) === String(expected)
+            ? undefined
+            : { path, reason: `expected ${expected}, received ${actual}` };
+    }
+    if (typeof actual !== "object" || actual === null) {
+        return {
+            path,
+            reason: `expected ${describeValue(expected)}, received ${describeValue(actual)}`,
+        };
+    }
+    // Guard against cycles: a pair already being compared is assumed equal
+    // until proven otherwise elsewhere in the walk.
+    const previous = seen.get(actual);
+    if (previous === expected)
+        return undefined;
+    seen.set(actual, expected);
+    if (Array.isArray(actual) && Array.isArray(expected)) {
+        if (actual.length !== expected.length) {
+            return {
+                path,
+                reason: `expected length ${expected.length}, received ${actual.length}`,
+            };
+        }
+        for (let index = 0; index < actual.length; index++) {
+            const found = diff(actual[index], expected[index], `${path}[${index}]`, seen);
+            if (found)
+                return found;
+        }
+        return undefined;
+    }
+    if (actual instanceof Map && expected instanceof Map) {
+        if (actual.size !== expected.size) {
+            return {
+                path,
+                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) {
+            const actualKey = actual.has(key)
+                ? key
+                : findStructuralMatch(unmatched, key, seen);
+            if (actualKey === NO_MATCH) {
+                return { path, reason: `missing key ${describeValue(key)}` };
+            }
+            unmatched.splice(unmatched.indexOf(actualKey), 1);
+            const found = diff(actual.get(actualKey), value, `${path}[${describeValue(key)}]`, seen);
+            if (found)
+                return found;
+        }
+        return undefined;
+    }
+    if (actual instanceof Set && expected instanceof Set) {
+        if (actual.size !== expected.size) {
+            return {
+                path,
+                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) {
+            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;
+    }
+    if (ArrayBuffer.isView(actual) && ArrayBuffer.isView(expected)) {
+        const a = new Uint8Array(actual.buffer, actual.byteOffset, actual.byteLength);
+        const b = new Uint8Array(expected.buffer, expected.byteOffset, expected.byteLength);
+        if (a.length !== b.length) {
+            return {
+                path,
+                reason: `expected ${b.length} bytes, received ${a.length}`,
+            };
+        }
+        for (let index = 0; index < a.length; index++) {
+            if (a[index] !== b[index]) {
+                return { path, reason: `bytes differ at offset ${index}` };
+            }
+        }
+        return undefined;
+    }
+    const actualKeys = Object.keys(actual).sort();
+    const expectedKeys = Object.keys(expected).sort();
+    for (const key of expectedKeys) {
+        if (!actualKeys.includes(key)) {
+            return { path: `${path}.${key}`, reason: "missing from received value" };
+        }
+    }
+    for (const key of actualKeys) {
+        if (!expectedKeys.includes(key)) {
+            return { path: `${path}.${key}`, reason: "unexpected in received value" };
+        }
+    }
+    for (const key of expectedKeys) {
+        const found = diff(actual[key], expected[key], `${path}.${key}`, seen);
+        if (found)
+            return found;
+    }
+    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.
+ *
+ * @param actual - The observed value.
+ * @param expected - The value it should equal.
+ * @param rootPath - Label for the root in the reported path.
+ * @returns The first difference, or undefined when the values are equal.
+ */
+export function findDifference(actual, expected, rootPath = "value") {
+    return diff(actual, expected, rootPath, new Map());
+}
+/** Whether two values are structurally equal. */
+export function deepEqual(actual, expected) {
+    return findDifference(actual, expected) === undefined;
+}
+//# sourceMappingURL=deepEqual.core.js.map

package/dist/assertions/deepEqual.describe.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @zudojs/testing — Rendering values for assertion messages.
+ *
+ * Assertion failures name the path and the difference, so both sides have to
+ * render without throwing — including the circular and BigInt values that
+ * `JSON.stringify` refuses.
+ *
+ * @module assertions/deepEqual.describe
+ */
+/** Where two values first differed. */
+export interface Difference {
+    /** Dotted path to the differing node. */
+    readonly path: string;
+    /** Human-readable description of the mismatch. */
+    readonly reason: string;
+}
+/** Renders a value for an assertion message without throwing. */
+export declare function describeValue(value: unknown, depth?: number): string;
+//# sourceMappingURL=deepEqual.describe.d.ts.map

package/dist/assertions/deepEqual.describe.js

@@ -0,0 +1,59 @@
+/**
+ * @zudojs/testing — Rendering values for assertion messages.
+ *
+ * Assertion failures name the path and the difference, so both sides have to
+ * render without throwing — including the circular and BigInt values that
+ * `JSON.stringify` refuses.
+ *
+ * @module assertions/deepEqual.describe
+ */
+/** Renders a value for an assertion message without throwing. */
+export function describeValue(value, depth = 0) {
+    if (value === null)
+        return "null";
+    if (value === undefined)
+        return "undefined";
+    switch (typeof value) {
+        case "string":
+            return JSON.stringify(value);
+        case "bigint":
+            return `${value}n`;
+        case "number":
+        case "boolean":
+            return String(value);
+        case "symbol":
+            return value.toString();
+        case "function":
+            return `[Function ${value.name || "anonymous"}]`;
+    }
+    if (depth > 2)
+        return "…";
+    if (value instanceof Date)
+        return `Date(${value.toISOString()})`;
+    if (value instanceof RegExp)
+        return String(value);
+    if (value instanceof Map) {
+        return `Map(${value.size}) {${[...value]
+            .slice(0, 4)
+            .map(([k, v]) => ` ${describeValue(k, depth + 1)} => ${describeValue(v, depth + 1)}`)
+            .join(",")} }`;
+    }
+    if (value instanceof Set) {
+        return `Set(${value.size}) {${[...value]
+            .slice(0, 4)
+            .map((entry) => ` ${describeValue(entry, depth + 1)}`)
+            .join(",")} }`;
+    }
+    if (Array.isArray(value)) {
+        return `[${value
+            .slice(0, 6)
+            .map((entry) => describeValue(entry, depth + 1))
+            .join(", ")}${value.length > 6 ? ", …" : ""}]`;
+    }
+    const keys = Object.keys(value);
+    return `{${keys
+        .slice(0, 6)
+        .map((key) => ` ${key}: ${describeValue(value[key], depth + 1)}`)
+        .join(",")}${keys.length > 6 ? ", …" : ""} }`;
+}
+//# sourceMappingURL=deepEqual.describe.js.map

package/dist/assertions/errorAssertions.core.d.ts

@@ -34,4 +34,8 @@ export declare function assertErrorCode(error: unknown, code: string): void;
  * @param value - Expected metadata value.
  */
 export declare function assertErrorMetadata(error: unknown, key: string, value: unknown): void;
+/**
+ * Asserts that an error is an instance of a specific class.
+ */
+export declare function assertErrorType<T extends Error>(error: unknown, type: new (...args: never[]) => T): asserts error is T;
 //# sourceMappingURL=errorAssertions.core.d.ts.map

package/dist/assertions/errorAssertions.core.js

@@ -3,6 +3,8 @@
  *
  * Assert errors, error types, and error messages.
  */
+import { findDifference } from "./deepEqual.core.js";
+import { describeValue } from "./deepEqual.describe.js";
 /**
  * Asserts that a function throws an error.
  *
@@ -11,8 +13,9 @@
  * @returns The thrown error.
  */
 export function assertThrows(fn, expectedMessage) {
+    let returned;
     try {
-        fn();
+        returned = fn();
     }
     catch (error) {
         if (expectedMessage !== undefined) {
@@ -23,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.
  *
@@ -75,8 +91,17 @@ export function assertErrorMetadata(error, key, value) {
     }
     const baseError = error;
     const actual = baseError.metadata?.[key];
-    if (actual !== value) {
-        throw new Error(`Expected error metadata "${key}" to be "${value}", got "${actual}".`);
+    const difference = findDifference(actual, value, `metadata.${key}`);
+    if (difference) {
+        throw new Error(`Expected error metadata "${key}" to be ${describeValue(value)}, got ${describeValue(actual)}.`);
+    }
+}
+/**
+ * Asserts that an error is an instance of a specific class.
+ */
+export function assertErrorType(error, type) {
+    if (!(error instanceof type)) {
+        throw new Error(`Expected error to be a ${type.name}, got ${error instanceof Error ? error.constructor.name : typeof error}.`);
     }
 }
 //# sourceMappingURL=errorAssertions.core.js.map

package/dist/assertions/eventAssertions.core.d.ts

@@ -41,4 +41,16 @@ export declare function assertEventPublished<TPayload>(events: readonly Recorded
  * @param type - Expected message type.
  */
 export declare function assertMessageDispatched<TPayload>(messages: readonly RecordedMessage<TPayload>[], type: string): void;
+/**
+ * Asserts that no event of a given type was published.
+ *
+ * The negative counterpart matters as much as the positive one: "this request
+ * must not emit a refund event" is a real assertion, and without this helper
+ * it gets written as a hand-rolled `.some()` that is easy to invert.
+ */
+export declare function assertEventNotPublished<TPayload>(events: readonly RecordedEvent<TPayload>[], type: string): void;
+/**
+ * Asserts that no message of a given type was dispatched.
+ */
+export declare function assertMessageNotDispatched<TPayload>(messages: readonly RecordedMessage<TPayload>[], type: string): void;
 //# sourceMappingURL=eventAssertions.core.d.ts.map

package/dist/assertions/eventAssertions.core.js

@@ -3,6 +3,7 @@
  *
  * Assert events, event types, and event payloads.
  */
+import { findDifference } from "./deepEqual.core.js";
 /**
  * Asserts that an event has a specific type.
  *
@@ -21,10 +22,9 @@ export function assertEventType(event, type) {
  * @param expected - Expected payload.
  */
 export function assertEventPayload(event, expected) {
-    const actual = JSON.stringify(event.payload);
-    const expectedJson = JSON.stringify(expected);
-    if (actual !== expectedJson) {
-        throw new Error(`Expected event payload ${expectedJson}, got ${actual}.`);
+    const difference = findDifference(event.payload, expected, "payload");
+    if (difference) {
+        throw new Error(`Event payload mismatch at ${difference.path}: ${difference.reason}.`);
     }
 }
 /**
@@ -60,4 +60,26 @@ export function assertMessageDispatched(messages, type) {
         throw new Error(`Expected message "${type}" to be dispatched, but it was not found.`);
     }
 }
+/**
+ * Asserts that no event of a given type was published.
+ *
+ * The negative counterpart matters as much as the positive one: "this request
+ * must not emit a refund event" is a real assertion, and without this helper
+ * it gets written as a hand-rolled `.some()` that is easy to invert.
+ */
+export function assertEventNotPublished(events, type) {
+    const found = events.filter((e) => e.event.type === type);
+    if (found.length > 0) {
+        throw new Error(`Expected event "${type}" not to be published, but it was published ${found.length} time(s).`);
+    }
+}
+/**
+ * Asserts that no message of a given type was dispatched.
+ */
+export function assertMessageNotDispatched(messages, type) {
+    const found = messages.filter((m) => m.message.type === type);
+    if (found.length > 0) {
+        throw new Error(`Expected message "${type}" not to be dispatched, but it was dispatched ${found.length} time(s).`);
+    }
+}
 //# sourceMappingURL=eventAssertions.core.js.map

package/dist/assertions/httpAssertions.core.d.ts

@@ -21,12 +21,23 @@ export declare function assertResponseStatus(response: TestHTTPResponse, expecte
  */
 export declare function assertResponseHeader(response: TestHTTPResponse, header: string, value: string): void;
 /**
- * Asserts that a response body matches expected JSON.
+ * Asserts that a response body matches the expected value.
+ *
+ * Compares structurally rather than by serializing both sides: `Map`, `Set`,
+ * `undefined` values and functions all disappear under `JSON.stringify`, so a
+ * serialized comparison passes on values that are not equal at all.
  *
  * @param response - The test response.
  * @param expected - Expected body.
  */
 export declare function assertResponseBody(response: TestHTTPResponse, expected: unknown): void;
+/**
+ * Asserts that a response body contains at least the expected properties.
+ *
+ * @param response - The test response.
+ * @param expected - Properties the body must contain.
+ */
+export declare function assertResponseBodyContains(response: TestHTTPResponse, expected: Readonly<Record<string, unknown>>): void;
 /**
  * Asserts that a response is 200 OK.
  */

package/dist/assertions/httpAssertions.core.js

@@ -3,6 +3,8 @@
  *
  * Assert HTTP responses, status codes, headers, and bodies.
  */
+import { findDifference } from "./deepEqual.core.js";
+import { describeValue } from "./deepEqual.describe.js";
 /**
  * Asserts that a response has a specific status code.
  *
@@ -28,17 +30,37 @@ export function assertResponseHeader(response, header, value) {
     }
 }
 /**
- * Asserts that a response body matches expected JSON.
+ * Asserts that a response body matches the expected value.
+ *
+ * Compares structurally rather than by serializing both sides: `Map`, `Set`,
+ * `undefined` values and functions all disappear under `JSON.stringify`, so a
+ * serialized comparison passes on values that are not equal at all.
  *
  * @param response - The test response.
  * @param expected - Expected body.
  */
 export function assertResponseBody(response, expected) {
-    const actual = response.body;
-    const actualJson = JSON.stringify(actual);
-    const expectedJson = JSON.stringify(expected);
-    if (actualJson !== expectedJson) {
-        throw new Error(`Expected body ${expectedJson}, got ${actualJson}.`);
+    const difference = findDifference(response.body, expected, "body");
+    if (difference) {
+        throw new Error(`Response body mismatch at ${difference.path}: ${difference.reason}.`);
+    }
+}
+/**
+ * Asserts that a response body contains at least the expected properties.
+ *
+ * @param response - The test response.
+ * @param expected - Properties the body must contain.
+ */
+export function assertResponseBodyContains(response, expected) {
+    const body = response.body;
+    if (typeof body !== "object" || body === null) {
+        throw new Error(`Expected an object body, got ${describeValue(body)}.`);
+    }
+    for (const [key, value] of Object.entries(expected)) {
+        const difference = findDifference(body[key], value, `body.${key}`);
+        if (difference) {
+            throw new Error(`Response body mismatch at ${difference.path}: ${difference.reason}.`);
+        }
     }
 }
 /**

package/dist/assertions/index.d.ts

@@ -1,9 +1,10 @@
 /**
- * Assertion helpers.
- *
- * HTTP, error, and event assertion utilities.
+ * @zudojs/testing — Assertions Barrel
  */
-export { assertResponseStatus, assertResponseHeader, assertResponseBody, assertOK, assertCreated, assertNoContent, assertBadRequest, assertNotFound, assertServerError, } from "./httpAssertions.core.js";
-export { assertThrows, assertRejects, assertErrorCode, assertErrorMetadata, } from "./errorAssertions.core.js";
-export { assertEventType, assertEventPayload, assertRecordedEventType, assertEventPublished, assertMessageDispatched, } from "./eventAssertions.core.js";
+export { assertBadRequest, assertCreated, assertNoContent, assertNotFound, assertOK, assertResponseBody, assertResponseBodyContains, assertResponseHeader, assertResponseStatus, assertServerError, } from "./httpAssertions.core.js";
+export { assertEventNotPublished, assertEventPayload, assertEventPublished, assertEventType, assertMessageDispatched, assertMessageNotDispatched, assertRecordedEventType, } from "./eventAssertions.core.js";
+export { assertErrorCode, assertErrorMetadata, assertErrorType, assertRejects, assertThrows, } from "./errorAssertions.core.js";
+export { deepEqual, findDifference } from "./deepEqual.core.js";
+export { describeValue } from "./deepEqual.describe.js";
+export type { Difference } from "./deepEqual.describe.js";
 //# sourceMappingURL=index.d.ts.map