@zudojs/testing 1.1.2 → 1.2.2

package/dist/httpTestClient/httpTestResponse/httpTestResponse.type.js

@@ -0,0 +1,5 @@
+/**
+ * @zudojs/testing — HTTP test client response type.
+ */
+export {};
+//# sourceMappingURL=httpTestResponse.type.js.map

package/dist/httpTestClient/httpTestResponse/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @zudojs/testing — HTTP test client responses.
+ *
+ * The response object the test client resolves with, and the expectations
+ * `.expect()` / `.expectJson()` / `.expectText()` run against it.
+ */
+export type { HttpTestRequestSummary, HttpTestResponse, } from "./httpTestResponse.type.js";
+export { createHttpTestResponse, previewBody, } from "./httpTestResponse.core.js";
+export { findPartialDifference } from "./httpTestResponse.match.js";
+export { expectHeader, expectJson, expectStatus, expectText, } from "./httpTestResponse.expect.js";
+export type { HttpTestExpectation } from "./httpTestResponse.expect.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/httpTestClient/httpTestResponse/index.js

@@ -0,0 +1,10 @@
+/**
+ * @zudojs/testing — HTTP test client responses.
+ *
+ * The response object the test client resolves with, and the expectations
+ * `.expect()` / `.expectJson()` / `.expectText()` run against it.
+ */
+export { createHttpTestResponse, previewBody, } from "./httpTestResponse.core.js";
+export { findPartialDifference } from "./httpTestResponse.match.js";
+export { expectHeader, expectJson, expectStatus, expectText, } from "./httpTestResponse.expect.js";
+//# sourceMappingURL=index.js.map

package/dist/httpTestClient/httpTestTransport/httpTestTransport.fetch.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @zudojs/testing — in-process fetch transport.
+ *
+ * Calls a web-standard `(Request) => Response` handler directly: no socket,
+ * no port. The handler receives an `AbortSignal` that fires on timeout.
+ */
+import type { FetchHandler, HttpTestTransport } from "./httpTestTransport.type.js";
+/**
+ * Transport that dispatches to a fetch handler in-process.
+ *
+ * @param handler - The web-standard handler.
+ * @param origin - Origin the request URL is resolved against.
+ */
+export declare function createFetchTransport(handler: FetchHandler, origin?: string): HttpTestTransport;
+//# sourceMappingURL=httpTestTransport.fetch.d.ts.map

package/dist/httpTestClient/httpTestTransport/httpTestTransport.fetch.js

@@ -0,0 +1,65 @@
+/**
+ * @zudojs/testing — in-process fetch transport.
+ *
+ * Calls a web-standard `(Request) => Response` handler directly: no socket,
+ * no port. The handler receives an `AbortSignal` that fires on timeout.
+ */
+import { NetworkError, TimeoutError, TimeoutOperation } from "@zudojs/errors";
+const NULL_BODY_STATUSES = new Set([101, 103, 204, 205, 304]);
+async function dispatch(handler, origin, raw, signal) {
+    const request = new Request(new URL(raw.target, origin), {
+        method: raw.method,
+        headers: raw.headers,
+        body: raw.body === undefined ? null : raw.body,
+        signal,
+    });
+    let response;
+    try {
+        response = await handler(request);
+    }
+    catch (error) {
+        throw new NetworkError(`${raw.method} ${raw.target} failed: the fetch handler threw instead of returning a Response.`, { cause: error, endpoint: request.url, method: raw.method });
+    }
+    if (!(response instanceof Response)) {
+        throw new NetworkError(`${raw.method} ${raw.target} failed: the fetch handler returned ${typeof response}, not a Response.`, { endpoint: request.url, method: raw.method });
+    }
+    const empty = raw.method === "HEAD" || NULL_BODY_STATUSES.has(response.status);
+    return {
+        status: response.status,
+        statusText: response.statusText,
+        headers: new Headers(response.headers),
+        body: empty
+            ? new Uint8Array()
+            : new Uint8Array(await response.arrayBuffer()),
+    };
+}
+/**
+ * Transport that dispatches to a fetch handler in-process.
+ *
+ * @param handler - The web-standard handler.
+ * @param origin - Origin the request URL is resolved against.
+ */
+export function createFetchTransport(handler, origin = "http://localhost") {
+    const send = (raw) => {
+        const controller = new AbortController();
+        const label = `${raw.method} ${raw.target}`;
+        let timer;
+        const timeout = new Promise((_, reject) => {
+            timer = setTimeout(() => {
+                const error = new TimeoutError(`${label} timed out after ${raw.timeoutMs} ms.`, {
+                    operation: TimeoutOperation.REQUEST,
+                    timeoutMs: raw.timeoutMs,
+                    target: label,
+                });
+                controller.abort(error);
+                reject(error);
+            }, raw.timeoutMs);
+        });
+        return Promise.race([
+            dispatch(handler, origin, raw, controller.signal),
+            timeout,
+        ]).finally(() => clearTimeout(timer));
+    };
+    return { origin, send, close: async () => undefined };
+}
+//# sourceMappingURL=httpTestTransport.fetch.js.map

package/dist/httpTestClient/httpTestTransport/httpTestTransport.node.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @zudojs/testing — Node transport.
+ *
+ * Sends requests over a real socket with `node:http`/`node:https`. Each
+ * request uses its own connection (`agent: false`), so closing the server
+ * never waits on a pooled keep-alive socket.
+ */
+import type { HttpTestTransport, RawHttpRequest, RawHttpResponse } from "./httpTestTransport.type.js";
+/**
+ * Sends one request to `origin` and resolves with the complete response.
+ *
+ * Rejects with a `TimeoutError` when no complete response arrives within
+ * `request.timeoutMs`, and with a `NetworkError` when the connection fails.
+ */
+export declare function sendNodeRequest(origin: string, request: RawHttpRequest): Promise<RawHttpResponse>;
+/** A transport that talks to an already-listening origin and owns nothing. */
+export declare function createOriginTransport(origin: string, close?: () => Promise<void>): HttpTestTransport;
+//# sourceMappingURL=httpTestTransport.node.d.ts.map

package/dist/httpTestClient/httpTestTransport/httpTestTransport.node.js

@@ -0,0 +1,94 @@
+/**
+ * @zudojs/testing — Node transport.
+ *
+ * Sends requests over a real socket with `node:http`/`node:https`. Each
+ * request uses its own connection (`agent: false`), so closing the server
+ * never waits on a pooled keep-alive socket.
+ */
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import { NetworkError, TimeoutError, TimeoutOperation } from "@zudojs/errors";
+function toOutgoingHeaders(headers) {
+    const outgoing = {};
+    headers.forEach((value, name) => {
+        outgoing[name] = value;
+    });
+    return outgoing;
+}
+function toHeaders(message) {
+    const headers = new Headers();
+    const raw = message.rawHeaders;
+    for (let index = 0; index + 1 < raw.length; index += 2) {
+        headers.append(raw[index], raw[index + 1]);
+    }
+    return headers;
+}
+function collect(message) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        message.on("data", (chunk) => chunks.push(chunk));
+        message.on("error", reject);
+        message.on("end", () => {
+            resolve({
+                status: message.statusCode ?? 0,
+                statusText: message.statusMessage ?? "",
+                headers: toHeaders(message),
+                body: new Uint8Array(Buffer.concat(chunks)),
+            });
+        });
+    });
+}
+/**
+ * Sends one request to `origin` and resolves with the complete response.
+ *
+ * Rejects with a `TimeoutError` when no complete response arrives within
+ * `request.timeoutMs`, and with a `NetworkError` when the connection fails.
+ */
+export function sendNodeRequest(origin, request) {
+    const url = new URL(request.target, origin);
+    const send = url.protocol === "https:" ? httpsRequest : httpRequest;
+    const label = `${request.method} ${request.target}`;
+    return new Promise((resolve, reject) => {
+        const headers = toOutgoingHeaders(request.headers);
+        if (request.body !== undefined && headers["content-length"] === undefined) {
+            headers["content-length"] = String(request.body.byteLength);
+        }
+        const outgoing = send(url, {
+            method: request.method,
+            headers,
+            agent: false,
+        });
+        const timer = setTimeout(() => {
+            outgoing.destroy(new TimeoutError(`${label} timed out after ${request.timeoutMs} ms.`, {
+                operation: TimeoutOperation.REQUEST,
+                timeoutMs: request.timeoutMs,
+                target: label,
+            }));
+        }, request.timeoutMs);
+        outgoing.on("response", (message) => {
+            collect(message)
+                .then(resolve, reject)
+                .finally(() => clearTimeout(timer));
+        });
+        outgoing.on("error", (error) => {
+            clearTimeout(timer);
+            reject(error instanceof TimeoutError
+                ? error
+                : new NetworkError(`${label} failed: ${error.message}`, {
+                    cause: error,
+                    endpoint: url.href,
+                    method: request.method,
+                }));
+        });
+        outgoing.end(request.body === undefined ? undefined : Buffer.from(request.body));
+    });
+}
+/** A transport that talks to an already-listening origin and owns nothing. */
+export function createOriginTransport(origin, close = async () => undefined) {
+    return {
+        origin,
+        send: (request) => sendNodeRequest(origin, request),
+        close,
+    };
+}
+//# sourceMappingURL=httpTestTransport.node.js.map

package/dist/httpTestClient/httpTestTransport/httpTestTransport.server.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @zudojs/testing — ephemeral Node servers.
+ *
+ * Starts a Node server on `127.0.0.1:0` (the OS picks a free port) and closes
+ * it again, including any open connections, when the client is closed.
+ */
+import type { Server as NetServer } from "node:net";
+import type { HttpTestTransport, NodeRequestListener } from "./httpTestTransport.type.js";
+/**
+ * Builds a requestable origin from a bound address. A wildcard bind
+ * (`0.0.0.0`, `::`) is reached through loopback.
+ */
+export declare function formatOrigin(host: string, port: number, secure?: boolean): string;
+/**
+ * Transport for a Node server. A server that is already listening is used
+ * where it is and left running; one that is not is started on an ephemeral
+ * port, unref'd so a forgotten `close()` cannot hold the process open, and
+ * closed by the transport.
+ */
+export declare function createNodeServerTransport(server: NetServer): Promise<HttpTestTransport>;
+/** Transport for a bare `(req, res)` listener, served on an ephemeral port. */
+export declare function createListenerTransport(listener: NodeRequestListener): Promise<HttpTestTransport>;
+//# sourceMappingURL=httpTestTransport.server.d.ts.map

package/dist/httpTestClient/httpTestTransport/httpTestTransport.server.js

@@ -0,0 +1,76 @@
+/**
+ * @zudojs/testing — ephemeral Node servers.
+ *
+ * Starts a Node server on `127.0.0.1:0` (the OS picks a free port) and closes
+ * it again, including any open connections, when the client is closed.
+ */
+import { createServer } from "node:http";
+import { createOriginTransport } from "./httpTestTransport.node.js";
+function originOf(server, secure) {
+    const address = server.address();
+    if (address === null || typeof address === "string") {
+        throw new TypeError("createHttpTestClient needs a TCP server; a pipe or unix socket address cannot be requested.");
+    }
+    return formatOrigin(address.address, address.port, secure);
+}
+/**
+ * Builds a requestable origin from a bound address. A wildcard bind
+ * (`0.0.0.0`, `::`) is reached through loopback.
+ */
+export function formatOrigin(host, port, secure = false) {
+    const reachable = host === "0.0.0.0" || host === ""
+        ? "127.0.0.1"
+        : host === "::"
+            ? "::1"
+            : host;
+    const bracketed = reachable.includes(":") ? `[${reachable}]` : reachable;
+    return `${secure ? "https" : "http"}://${bracketed}:${port}`;
+}
+function isTlsServer(server) {
+    return typeof server.addContext === "function";
+}
+function closeNetServer(server) {
+    return new Promise((resolve, reject) => {
+        server.close((error) => (error ? reject(error) : resolve()));
+        server.closeAllConnections?.();
+    });
+}
+function listenEphemeral(server) {
+    return new Promise((resolve, reject) => {
+        const onError = (error) => reject(error);
+        server.once("error", onError);
+        server.listen(0, "127.0.0.1", () => {
+            server.off("error", onError);
+            resolve();
+        });
+    });
+}
+/**
+ * Transport for a Node server. A server that is already listening is used
+ * where it is and left running; one that is not is started on an ephemeral
+ * port, unref'd so a forgotten `close()` cannot hold the process open, and
+ * closed by the transport.
+ */
+export async function createNodeServerTransport(server) {
+    const secure = isTlsServer(server);
+    if (server.listening) {
+        return createOriginTransport(originOf(server, secure));
+    }
+    await listenEphemeral(server);
+    server.unref();
+    return createOriginTransport(originOf(server, secure), () => closeNetServer(server));
+}
+/** Transport for a bare `(req, res)` listener, served on an ephemeral port. */
+export function createListenerTransport(listener) {
+    return createNodeServerTransport(createServer((request, response) => {
+        Promise.resolve()
+            .then(() => listener(request, response))
+            .catch(() => {
+            if (!response.headersSent) {
+                response.statusCode = 500;
+            }
+            response.end();
+        });
+    }));
+}
+//# sourceMappingURL=httpTestTransport.server.js.map

package/dist/httpTestClient/httpTestTransport/httpTestTransport.type.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @zudojs/testing — HTTP test transport types.
+ *
+ * A transport turns one fully-built request into the bytes the app answered
+ * with. Every target kind (URL, Node server, request listener, fetch handler,
+ * `@zudojs/http` server/router/adapter) is reduced to one of these.
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+/** A request as it goes on the wire. */
+export interface RawHttpRequest {
+    readonly method: string;
+    /** Origin-relative target: path plus query string. */
+    readonly target: string;
+    readonly headers: Headers;
+    readonly body: Uint8Array | undefined;
+    readonly timeoutMs: number;
+}
+/** A response as it came off the wire. */
+export interface RawHttpResponse {
+    readonly status: number;
+    readonly statusText: string;
+    readonly headers: Headers;
+    readonly body: Uint8Array;
+}
+/** Sends requests to one target and releases what it opened. */
+export interface HttpTestTransport {
+    /** Where requests go, e.g. `http://127.0.0.1:41234`. */
+    readonly origin: string;
+    /**
+     * Path prepended to every target before it is sent (`/api` for a base URL
+     * of `http://host/api`); the cookie jar scopes cookies by the prefixed
+     * path, which is the one the server saw. Absent when there is none.
+     */
+    readonly pathPrefix?: string;
+    readonly send: (request: RawHttpRequest) => Promise<RawHttpResponse>;
+    readonly close: () => Promise<void>;
+}
+/** A web-standard handler: `Request` in, `Response` out. */
+export type FetchHandler = (request: Request) => Response | Promise<Response>;
+/** An object exposing a web-standard `fetch` method (Hono, Bun-style apps). */
+export interface FetchApplication {
+    readonly fetch: FetchHandler;
+}
+/** A Node `http.createServer` request listener. */
+export type NodeRequestListener = (request: IncomingMessage, response: ServerResponse) => void | Promise<void>;
+//# sourceMappingURL=httpTestTransport.type.d.ts.map

package/dist/httpTestClient/httpTestTransport/httpTestTransport.type.js

@@ -0,0 +1,9 @@
+/**
+ * @zudojs/testing — HTTP test transport types.
+ *
+ * A transport turns one fully-built request into the bytes the app answered
+ * with. Every target kind (URL, Node server, request listener, fetch handler,
+ * `@zudojs/http` server/router/adapter) is reduced to one of these.
+ */
+export {};
+//# sourceMappingURL=httpTestTransport.type.js.map

package/dist/httpTestClient/httpTestTransport/httpTestTransport.zudo.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @zudojs/testing — `@zudojs/http` transport.
+ *
+ * `@zudojs/http` has no `handle(Request) => Response` entry point, so its
+ * targets are served on an ephemeral port through a real `NodeHttpAdapter`:
+ * requests pass the adapter's request guard, body limits, handler and default
+ * error mapping exactly as in production. A server or adapter that is already
+ * running is used where it listens and left running.
+ */
+import { NodeHttpAdapter } from "@zudojs/http";
+import type { HttpHandler, HttpMiddlewarePipeline, HttpRouter, HttpServer, NodeAdapterOptions } from "@zudojs/http";
+import type { HttpTestTransport } from "./httpTestTransport.type.js";
+/** Adapter settings for the `NodeHttpAdapter` the client creates. */
+export type HttpTestAdapterOptions = Omit<NodeAdapterOptions, "handler" | "host" | "port" | "server">;
+/** Transport for a `NodeHttpAdapter`. */
+export declare function createAdapterTransport(adapter: NodeHttpAdapter): Promise<HttpTestTransport>;
+/** Transport for an `HttpServer`. */
+export declare function createHttpServerTransport(server: HttpServer): Promise<HttpTestTransport>;
+/** Transport for an `HttpHandler`, served by a fresh `NodeHttpAdapter`. */
+export declare function createHandlerTransport(handler: HttpHandler, options?: HttpTestAdapterOptions): Promise<HttpTestTransport>;
+/** Transport for an `HttpRouter`. */
+export declare function createRouterTransport(router: HttpRouter, options?: HttpTestAdapterOptions): Promise<HttpTestTransport>;
+/** Transport for an `HttpMiddlewarePipeline`. */
+export declare function createPipelineTransport(pipeline: HttpMiddlewarePipeline, options?: HttpTestAdapterOptions): Promise<HttpTestTransport>;
+//# sourceMappingURL=httpTestTransport.zudo.d.ts.map

package/dist/httpTestClient/httpTestTransport/httpTestTransport.zudo.js

@@ -0,0 +1,71 @@
+/**
+ * @zudojs/testing — `@zudojs/http` transport.
+ *
+ * `@zudojs/http` has no `handle(Request) => Response` entry point, so its
+ * targets are served on an ephemeral port through a real `NodeHttpAdapter`:
+ * requests pass the adapter's request guard, body limits, handler and default
+ * error mapping exactly as in production. A server or adapter that is already
+ * running is used where it listens and left running.
+ */
+import { createServer } from "node:http";
+import { NodeHttpAdapter, createResponseContext } from "@zudojs/http";
+import { createOriginTransport } from "./httpTestTransport.node.js";
+import { createNodeServerTransport, formatOrigin, } from "./httpTestTransport.server.js";
+/** Serves a (not listening) Node adapter on an ephemeral port. */
+function bridge(adapter) {
+    return createNodeServerTransport(createServer((request, response) => {
+        adapter.handle({ request, response }).catch(() => {
+            if (!response.writableEnded) {
+                response.destroy();
+            }
+        });
+    }));
+}
+function listeningOrigin(address) {
+    return address?.port === undefined
+        ? undefined
+        : formatOrigin(address.host ?? "127.0.0.1", address.port);
+}
+/** Transport for a `NodeHttpAdapter`. */
+export function createAdapterTransport(adapter) {
+    const origin = adapter.isStarted
+        ? listeningOrigin(adapter.address)
+        : undefined;
+    return origin
+        ? Promise.resolve(createOriginTransport(origin))
+        : bridge(adapter);
+}
+/** Transport for an `HttpServer`. */
+export async function createHttpServerTransport(server) {
+    const running = server.isRunning
+        ? listeningOrigin(server.address)
+        : undefined;
+    if (running) {
+        return createOriginTransport(running);
+    }
+    if (server.adapter instanceof NodeHttpAdapter) {
+        return bridge(server.adapter);
+    }
+    await server.start();
+    const origin = listeningOrigin(server.address);
+    if (!origin) {
+        await server.stop();
+        throw new TypeError(`createHttpTestClient started HttpServer "${server.name}" but its adapter "${server.adapter.name}" reports no TCP address to send requests to.`);
+    }
+    return createOriginTransport(origin, async () => {
+        await server.stop({ force: true });
+    });
+}
+/** Transport for an `HttpHandler`, served by a fresh `NodeHttpAdapter`. */
+export function createHandlerTransport(handler, options = {}) {
+    return bridge(new NodeHttpAdapter({ ...options, handler }));
+}
+/** Transport for an `HttpRouter`. */
+export function createRouterTransport(router, options = {}) {
+    return createHandlerTransport(async (request) => (await router.dispatch(request)).response, options);
+}
+/** Transport for an `HttpMiddlewarePipeline`. */
+export function createPipelineTransport(pipeline, options = {}) {
+    return createHandlerTransport((request) => pipeline.execute(request, createResponseContext()), options);
+}
+//# sourceMappingURL=httpTestTransport.zudo.js.map

package/dist/httpTestClient/httpTestTransport/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @zudojs/testing — HTTP test transports.
+ *
+ * Each target kind the test client accepts is reduced to a transport that
+ * sends one request and releases whatever it opened on `close()`: a socket
+ * transport for URLs, Node servers and `@zudojs/http` apps, and an in-process
+ * transport for web-standard fetch handlers.
+ */
+export type { FetchApplication, FetchHandler, HttpTestTransport, NodeRequestListener, RawHttpRequest, RawHttpResponse, } from "./httpTestTransport.type.js";
+export { createOriginTransport, sendNodeRequest, } from "./httpTestTransport.node.js";
+export { createListenerTransport, createNodeServerTransport, formatOrigin, } from "./httpTestTransport.server.js";
+export { createFetchTransport } from "./httpTestTransport.fetch.js";
+export { createAdapterTransport, createHandlerTransport, createHttpServerTransport, createPipelineTransport, createRouterTransport, } from "./httpTestTransport.zudo.js";
+export type { HttpTestAdapterOptions } from "./httpTestTransport.zudo.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/httpTestClient/httpTestTransport/index.js

@@ -0,0 +1,13 @@
+/**
+ * @zudojs/testing — HTTP test transports.
+ *
+ * Each target kind the test client accepts is reduced to a transport that
+ * sends one request and releases whatever it opened on `close()`: a socket
+ * transport for URLs, Node servers and `@zudojs/http` apps, and an in-process
+ * transport for web-standard fetch handlers.
+ */
+export { createOriginTransport, sendNodeRequest, } from "./httpTestTransport.node.js";
+export { createListenerTransport, createNodeServerTransport, formatOrigin, } from "./httpTestTransport.server.js";
+export { createFetchTransport } from "./httpTestTransport.fetch.js";
+export { createAdapterTransport, createHandlerTransport, createHttpServerTransport, createPipelineTransport, createRouterTransport, } from "./httpTestTransport.zudo.js";
+//# sourceMappingURL=index.js.map

package/dist/httpTestClient/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @zudojs/testing — HTTP test client.
+ *
+ * `createHttpTestClient(target)` drives a real app over HTTP, supertest
+ * style: fluent requests, a cookie jar that persists across requests, and
+ * chained expectations with readable failures. Targets can be a base URL, a
+ * Node server or listener, a fetch handler, or an `@zudojs/http` server,
+ * adapter, router, pipeline or handler.
+ */
+export { createHttpTestClient } from "./httpTestClient.factory.js";
+export { createHttpTestCookieJar } from "./httpTestClient.cookieJar.js";
+export type { HttpTestCookieJar } from "./httpTestClient.cookieJar.js";
+export type { HttpTestClient, HttpTestClientOptions, HttpTestTarget, HttpTestTargetKind, } from "./httpTestClient.type.js";
+export type { HttpTestBody, HttpTestQuery, HttpTestQueryValue, HttpTestRequest, } from "./httpTestRequest/index.js";
+export { findPartialDifference } from "./httpTestResponse/index.js";
+export type { HttpTestExpectation, HttpTestRequestSummary, HttpTestResponse, } from "./httpTestResponse/index.js";
+export type { FetchApplication, FetchHandler, HttpTestAdapterOptions, NodeRequestListener, } from "./httpTestTransport/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/httpTestClient/index.js

@@ -0,0 +1,13 @@
+/**
+ * @zudojs/testing — HTTP test client.
+ *
+ * `createHttpTestClient(target)` drives a real app over HTTP, supertest
+ * style: fluent requests, a cookie jar that persists across requests, and
+ * chained expectations with readable failures. Targets can be a base URL, a
+ * Node server or listener, a fetch handler, or an `@zudojs/http` server,
+ * adapter, router, pipeline or handler.
+ */
+export { createHttpTestClient } from "./httpTestClient.factory.js";
+export { createHttpTestCookieJar } from "./httpTestClient.cookieJar.js";
+export { findPartialDifference } from "./httpTestResponse/index.js";
+//# sourceMappingURL=index.js.map

package/dist/httpTesting/httpRequest/httpRequest.builder.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @zudojs/testing — HTTP request builder for testing.
+ *
+ * Provides a fluent API for constructing test HTTP requests.
+ */
+import type { HTTPRequestBuilder } from "./httpRequest.type.js";
+/**
+ * Creates a new HTTP request builder.
+ *
+ * @returns An HTTPRequestBuilder instance.
+ */
+export declare function createTestHTTPRequest(): HTTPRequestBuilder;
+//# sourceMappingURL=httpRequest.builder.d.ts.map

package/dist/httpTesting/httpRequest/httpRequest.builder.js

@@ -0,0 +1,64 @@
+/**
+ * @zudojs/testing — HTTP request builder for testing.
+ *
+ * Provides a fluent API for constructing test HTTP requests.
+ */
+/**
+ * Creates a new HTTP request builder.
+ *
+ * @returns An HTTPRequestBuilder instance.
+ */
+export function createTestHTTPRequest() {
+    let method = "GET";
+    let path = "/";
+    const headers = new Headers();
+    const query = {};
+    const params = {};
+    let body = undefined;
+    const target = (verb) => (p) => {
+        method = verb;
+        path = p;
+        return builder;
+    };
+    const builder = {
+        GET: target("GET"),
+        POST: target("POST"),
+        PUT: target("PUT"),
+        PATCH: target("PATCH"),
+        DELETE: target("DELETE"),
+        HEAD: target("HEAD"),
+        OPTIONS: target("OPTIONS"),
+        withHeader: (key, value) => {
+            headers.set(key, value);
+            return builder;
+        },
+        withHeaders: (h) => {
+            new Headers(h).forEach((value, key) => {
+                headers.set(key, value);
+            });
+            return builder;
+        },
+        withQuery: (q) => {
+            Object.assign(query, q);
+            return builder;
+        },
+        withParam: (key, value) => {
+            params[key] = value;
+            return builder;
+        },
+        withBody: (b) => {
+            body = b;
+            return builder;
+        },
+        build: () => ({
+            method,
+            path,
+            headers: new Headers(headers),
+            query: { ...query },
+            body,
+            params: { ...params },
+        }),
+    };
+    return builder;
+}
+//# sourceMappingURL=httpRequest.builder.js.map

package/dist/httpTesting/httpRequest/httpRequest.factory.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @zudojs/testing — one-call HTTP request factory.
+ */
+import type { HTTPMethod, HTTPRequestOptions, TestHTTPRequest } from "./httpRequest.type.js";
+/**
+ * Creates a simple test HTTP request without the builder pattern.
+ *
+ * `query` and `params` are copied, so mutating the object passed in after the
+ * call does not change the request (the builder already behaved this way).
+ *
+ * @param method - HTTP method.
+ * @param path - Request path.
+ * @param options - Optional headers, query, params, and body.
+ * @returns A TestHTTPRequest instance.
+ */
+export declare function createHTTPRequest(method: HTTPMethod, path: string, options?: HTTPRequestOptions): TestHTTPRequest;
+//# sourceMappingURL=httpRequest.factory.d.ts.map