@zudojs/testing 1.1.2 → 1.2.2

package/README.md

@@ -52,12 +52,139 @@ assertResponseStatus(response, 201);
 assertResponseBody(response, { id: "u_1", roles: new Set(["admin"]) });
 ```
 
+## Testing an HTTP app
+
+`createHttpTestClient(target)` sends real HTTP requests to your app and
+checks the answers, supertest style.
+
+```typescript
+import { createRouter, createResponseContext } from "@zudojs/http";
+import { createCleanupManager, createHttpTestClient } from "@zudojs/testing";
+
+const router = createRouter();
+router.get("/users/:id", (ctx) =>
+  createResponseContext().json({ id: ctx.params.id }),
+);
+
+const cleanup = createCleanupManager();
+const client = createHttpTestClient(router, { cleanup });
+
+const response = await client
+  .get("/users/7")
+  .query({ expand: "roles" })
+  .auth("token-123")
+  .expect(200)
+  .expect("content-type", /json/)
+  .expectJson({ id: "7" });
+
+response.json<{ id: string }>(); // typed body
+
+await cleanup.dispose(); // closes the server the client started
+```
+
+What you can point it at:
+
+| Target | How it is reached |
+| --- | --- |
+| `"http://127.0.0.1:3000/api"` | Over the network; a path prefix applies to every request. |
+| Node `http.Server` | Started on `127.0.0.1:0` if it is not listening, closed by `close()`. A listening server is used where it is and left running. |
+| `(req, res) => void` | Wrapped in a Node server on an ephemeral port. |
+| `(request: Request) => Response`, `{ fetch }` | Called in-process, no port. The request's `signal` aborts on timeout. |
+| `HttpServer`, `NodeHttpAdapter`, `HttpRouter`, `HttpMiddlewarePipeline` from `@zudojs/http` | Served through a real `NodeHttpAdapter` on an ephemeral port, so the request guard, body limits and error mapping behave as in production. A running `HttpServer` is used where it listens. |
+| An `@zudojs/http` `HttpHandler` | Same, with `{ kind: "zudo" }` (a one-argument function is otherwise taken to be a fetch handler). |
+
+- **Requests**: `.get/.post/.put/.patch/.delete/.head/.options(path)` or
+  `.request(method, path)`; `.set(name, value)` or `.set({...})`,
+  `.query({...})`, `.send(body)` (objects as JSON, strings as text, bytes as
+  octet-stream, `URLSearchParams` as a form), `.auth(token)` or
+  `.auth(user, password)`, `.timeout(ms)`. A request is sent once, when it is
+  first awaited. Redirects are not followed.
+- **Built requests**: `client.request(createTestHTTPRequest().PUT("/users/:id").withParam("id", "7").build())`
+  sends a builder request, with `:params` substituted.
+- **Expectations**: `.expect(status)`, `.expect(header, "value" | /re/)`,
+  `.expect((response) => ...)`, `.expectJson(partial)` (extra object keys are
+  allowed; arrays must match in length) and `.expectText("..." | /re/)`.
+  Failures are `AssertionError`s naming the request and previewing the body,
+  with a stack pointing at the `.expect…()` line.
+- **Responses** have `status`, `headers`, `header(name)`, `text`, `body`
+  (parsed JSON for JSON types), `json<T>()`, `bytes`, `cookies` and
+  `setCookies`. They are `TestHTTPResponse`s, so `assertResponseStatus`,
+  `assertResponseBody` and friends accept them.
+- **Cookies** from `Set-Cookie` are kept in `client.cookies` and sent back on
+  later requests (`Path`, `Max-Age` and `Expires` honoured). An explicit
+  `Cookie` header replaces the jar for that request; `{ cookies: false }`
+  turns it off.
+- **Timeouts** default to 5 s per request (`{ timeout }` or `.timeout(ms)`)
+  and reject with a `TimeoutError`; connection failures reject with a
+  `NetworkError`, both from `@zudojs/errors`.
+- **Cleanup**: `client.close()` closes only what the client started. Servers it
+  starts are unref'd, so a forgotten `close()` cannot keep the test process
+  alive; `{ cleanup }` registers `close()` with a cleanup manager.
+
+## Recording doubles
+
+`createTestEventBus()`, `createTestMessageBus()` and `createTestQueue(name)`
+are the real `EventBus`, `MessageBus` and `Queue`, so hand them straight to
+the code under test. They record at the bus and queue level, so every path
+records, not only a wrapper method:
+
+```typescript
+import { createQueueName } from "@zudojs/queue";
+import {
+  assertEventPublished,
+  createTestEventBus,
+  createTestMessageBus,
+  createTestQueue,
+} from "@zudojs/testing";
+
+const events = createTestEventBus(); // an EventBus
+await new UserService(events).register("ann"); // calls events.publishEvent(...)
+assertEventPublished(events.published, "user.created");
+
+const messages = createTestMessageBus(); // a MessageBus
+await messages.send({ type: "email.send", payload: { to: "a@b.c" } });
+messages.dispatched; // send and dispatch both record
+
+const reminders = createTestQueue<{ taskId: number }>(createQueueName("reminders"));
+await reminders.add("remind", { taskId: 7 }); // a Queue
+reminders.findByName("remind"); // also records reminders.queue.add(...)
+```
+
+- **Events**: `publish` (a full `Event` or `{ type, payload }`),
+  `publishEvent` and `emit` all record into `published`; `findByType` and
+  `clear` read and reset it. `bus` is the same instance.
+- **Messages**: `send` and `dispatch` record into `dispatched`.
+- **Queues**: `add`, on the test queue or on the underlying `queue`, records
+  into `jobs`; `findByName` filters them.
+- Methods survive destructuring (`const { publish } = createTestEventBus()`).
+
+## Test application
+
+`createTestApplication()` bundles a container, a logger, a clock and a cleanup
+manager, with the container and logger cleanups registered. It is quiet and
+deterministic by default:
+
+```typescript
+const app = createTestApplication({ name: "task-api" });
+
+app.logger.info("started"); // prints nothing
+app.logger.calls.map((call) => call.message); // ["started"]
+app.clock.now.toISOString(); // "2026-01-01T00:00:00.000Z" (DEFAULT_TEST_APPLICATION_TIME)
+
+await app.dispose();
+```
+
+Opt back in when you want something else: `startTime` moves the default
+clock (`startTime: Date.now()` for wall-clock time), `clock` supplies your
+own, and `logger: createLogger({ name })` from `@zudojs/logger` prints.
+
 ## Features
 
 - 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
+- Recording event bus, message bus, and queue that are the real types and record every path
+- HTTP test client that drives a real app (URL, Node server, fetch handler, or `@zudojs/http` app)
 - HTTP request/response builders
 - Structural assertions for responses, events, errors, and serialization
 - Cleanup manager that reports what failed
@@ -79,8 +206,17 @@ assertResponseBody(response, { id: "u_1", roles: new Set(["admin"]) });
 - `createStub()` hands back the same no-op for a given property every time,
   so `stub.handler === stub.handler` and a register/unregister pair written
   against a stub actually unregisters.
+- The overrides passed to `createStub()` are the stub's own enumerable
+  properties, so `Object.keys(stub)`, `{ ...stub }` and
+  `expect.objectContaining({ send })` see them. The unstubbed no-ops are
+  answered on access only and are not own keys. `asymmetricMatch` is answered
+  with `undefined`, so Vitest's `equals` does not mistake a stub for a matcher.
+- `createSpyMethod(...).restore()` only puts the original method back. The
+  recorded `calls`, `results` and `errors` are kept, so you can assert on them
+  after restoring. Calls made after `restore()` are not recorded.
 - `InMemoryTestStorage.set(key, value, 0)` means "already expired", not "no
-  expiry"; only an omitted TTL never expires.
+  expiry"; only an omitted TTL (or `Infinity`) never expires, and a `NaN` TTL
+  throws. `delete()` returns `false` for an entry that has already expired.
 - `cleanup.dispose()` rejects with an `AggregateError` when any cleanup fails,
   after running them all.
 - `mockResolvedValue` and `mockRejectedValue` return promises; `results` stays

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

@@ -3,8 +3,8 @@
  *
  * Assert HTTP responses, status codes, headers, and bodies.
  */
-import type { HTTPStatusCode } from "../httpTesting/httpStatusCode.type.js";
-import type { TestHTTPResponse } from "../httpTesting/httpResponse.type.js";
+import type { HTTPStatusCode } from "@zudojs/http";
+import type { TestHTTPResponse } from "../httpTesting/httpResponse/index.js";
 /**
  * Asserts that a response has a specific status code.
  *

package/dist/httpTestClient/httpTestClient.cookieJar.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @zudojs/testing — cookie jar for the HTTP test client.
+ *
+ * Stores cookies from `Set-Cookie` and sends matching ones back, the way a
+ * browser session would against a single origin. `Path`, `Max-Age` and
+ * `Expires` are honoured; `Domain`, `Secure` and `SameSite` are not, since
+ * every request goes to the one origin under test (a `Secure` cookie is sent
+ * over plain `http://127.0.0.1` too).
+ */
+/** Cookies kept by a test client across requests. */
+export interface HttpTestCookieJar {
+    /** Number of live cookies. */
+    readonly size: number;
+    /** Value of the named cookie (the most specific path wins), if any. */
+    readonly get: (name: string) => string | undefined;
+    /** Sets a cookie by hand, as if the server had sent it. */
+    readonly set: (name: string, value: string, path?: string) => void;
+    /** Removes every cookie with this name. Returns whether one existed. */
+    readonly delete: (name: string) => boolean;
+    readonly clear: () => void;
+    /** Live cookies as `name → value`. */
+    readonly toJSON: () => Readonly<Record<string, string>>;
+    /** The `Cookie` header for a request to `path`, if any cookie applies. */
+    readonly headerFor: (path: string) => string | undefined;
+    /** Stores `Set-Cookie` values received for a request to `requestPath`. */
+    readonly store: (setCookies: readonly string[], requestPath: string) => void;
+}
+/** Creates an empty cookie jar. */
+export declare function createHttpTestCookieJar(): HttpTestCookieJar;
+//# sourceMappingURL=httpTestClient.cookieJar.d.ts.map

package/dist/httpTestClient/httpTestClient.cookieJar.js

@@ -0,0 +1,107 @@
+/**
+ * @zudojs/testing — cookie jar for the HTTP test client.
+ *
+ * Stores cookies from `Set-Cookie` and sends matching ones back, the way a
+ * browser session would against a single origin. `Path`, `Max-Age` and
+ * `Expires` are honoured; `Domain`, `Secure` and `SameSite` are not, since
+ * every request goes to the one origin under test (a `Secure` cookie is sent
+ * over plain `http://127.0.0.1` too).
+ */
+function defaultPath(requestPath) {
+    const pathname = requestPath.split("?")[0] ?? "/";
+    const slash = pathname.lastIndexOf("/");
+    return slash <= 0 ? "/" : pathname.slice(0, slash);
+}
+function pathMatches(cookiePath, requestPath) {
+    const pathname = requestPath.split("?")[0] || "/";
+    if (cookiePath === "/" || pathname === cookiePath)
+        return true;
+    const prefix = cookiePath.endsWith("/") ? cookiePath : `${cookiePath}/`;
+    return pathname.startsWith(prefix);
+}
+function parseSetCookie(header, requestPath, now) {
+    const [pair = "", ...attributes] = header.split(";");
+    const equals = pair.indexOf("=");
+    if (equals <= 0)
+        return undefined;
+    let path = defaultPath(requestPath);
+    let expiresAt;
+    for (const attribute of attributes) {
+        const [rawKey = "", ...rest] = attribute.split("=");
+        const key = rawKey.trim().toLowerCase();
+        const value = rest.join("=").trim();
+        if (key === "path" && value.startsWith("/"))
+            path = value;
+        if (key === "max-age" && /^-?\d+$/.test(value)) {
+            expiresAt = now + Number(value) * 1000;
+        }
+        if (key === "expires" && expiresAt === undefined) {
+            const parsed = Date.parse(value);
+            if (!Number.isNaN(parsed))
+                expiresAt = parsed;
+        }
+    }
+    return {
+        name: pair.slice(0, equals).trim(),
+        value: pair.slice(equals + 1).trim(),
+        path,
+        expiresAt,
+    };
+}
+/** Creates an empty cookie jar. */
+export function createHttpTestCookieJar() {
+    const cookies = new Map();
+    const keyOf = (name, path) => `${path}\u0000${name}`;
+    const live = () => {
+        const now = Date.now();
+        for (const [key, cookie] of cookies) {
+            if (cookie.expiresAt !== undefined && cookie.expiresAt <= now)
+                cookies.delete(key);
+        }
+        return [...cookies.values()].sort((a, b) => b.path.length - a.path.length);
+    };
+    return {
+        get size() {
+            return live().length;
+        },
+        get: (name) => live().find((cookie) => cookie.name === name)?.value,
+        set: (name, value, path = "/") => {
+            cookies.set(keyOf(name, path), {
+                name,
+                value,
+                path,
+                expiresAt: undefined,
+            });
+        },
+        delete: (name) => {
+            let found = false;
+            for (const [key, cookie] of cookies) {
+                if (cookie.name === name)
+                    found = cookies.delete(key) || found;
+            }
+            return found;
+        },
+        clear: () => cookies.clear(),
+        toJSON: () => {
+            const entries = live()
+                .reverse()
+                .map((c) => [c.name, c.value]);
+            return Object.freeze(Object.fromEntries(entries));
+        },
+        headerFor: (path) => {
+            const matching = live().filter((cookie) => pathMatches(cookie.path, path));
+            return matching.length === 0
+                ? undefined
+                : matching.map((cookie) => `${cookie.name}=${cookie.value}`).join("; ");
+        },
+        store: (setCookies, requestPath) => {
+            const now = Date.now();
+            for (const header of setCookies) {
+                const cookie = parseSetCookie(header, requestPath, now);
+                if (cookie)
+                    cookies.set(keyOf(cookie.name, cookie.path), cookie);
+            }
+        },
+    };
+}
+//# sourceMappingURL=httpTestClient.cookieJar.js.map

package/dist/httpTestClient/httpTestClient.factory.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @zudojs/testing — supertest-style HTTP test client.
+ */
+import type { HttpTestClient, HttpTestClientOptions, HttpTestTarget } from "./httpTestClient.type.js";
+/**
+ * Creates an HTTP test client for an app, server, handler or URL.
+ *
+ * The target is started lazily, on the first request (or `start()`), and
+ * whatever the client started is closed by `close()`. Pass `cleanup` to have
+ * a cleanup manager call `close()` for you.
+ *
+ * @example
+ * ```ts
+ * const client = createHttpTestClient(router, { cleanup });
+ *
+ * await client.post("/users").send({ name: "Ada" }).expect(201);
+ * const response = await client
+ *   .get("/users/1")
+ *   .expect(200)
+ *   .expect("content-type", /json/)
+ *   .expectJson({ name: "Ada" });
+ * ```
+ */
+export declare function createHttpTestClient(target: HttpTestTarget, options?: HttpTestClientOptions): HttpTestClient;
+//# sourceMappingURL=httpTestClient.factory.d.ts.map

package/dist/httpTestClient/httpTestClient.factory.js

@@ -0,0 +1,84 @@
+/**
+ * @zudojs/testing — supertest-style HTTP test client.
+ */
+import { createHttpTestCookieJar } from "./httpTestClient.cookieJar.js";
+import { resolveHttpTestTransport } from "./httpTestClient.target.js";
+import { createHttpTestRequest, substituteParams, } from "./httpTestRequest/index.js";
+const DEFAULT_TIMEOUT_MS = 5_000;
+function fromBuilt(context, built) {
+    const request = createHttpTestRequest(context, built.method, substituteParams(built.path, built.params)).query(built.query);
+    built.headers.forEach((value, name) => request.set(name, value));
+    return built.body === undefined
+        ? request
+        : request.send(built.body);
+}
+/**
+ * Creates an HTTP test client for an app, server, handler or URL.
+ *
+ * The target is started lazily, on the first request (or `start()`), and
+ * whatever the client started is closed by `close()`. Pass `cleanup` to have
+ * a cleanup manager call `close()` for you.
+ *
+ * @example
+ * ```ts
+ * const client = createHttpTestClient(router, { cleanup });
+ *
+ * await client.post("/users").send({ name: "Ada" }).expect(201);
+ * const response = await client
+ *   .get("/users/1")
+ *   .expect(200)
+ *   .expect("content-type", /json/)
+ *   .expectJson({ name: "Ada" });
+ * ```
+ */
+export function createHttpTestClient(target, options = {}) {
+    const timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+    if (!Number.isFinite(timeout) || timeout <= 0) {
+        throw new RangeError(`createHttpTestClient: timeout must be a positive number; got ${timeout}.`);
+    }
+    const cookies = createHttpTestCookieJar();
+    let starting;
+    let closing;
+    const transport = () => {
+        if (closing) {
+            return Promise.reject(new TypeError("This HTTP test client has been closed."));
+        }
+        starting ??= resolveHttpTestTransport(target, options);
+        return starting;
+    };
+    const context = {
+        transport,
+        jar: options.cookies === false ? undefined : cookies,
+        headers: { ...options.headers },
+        timeout,
+    };
+    const request = (methodOrRequest, path = "/") => typeof methodOrRequest === "string"
+        ? createHttpTestRequest(context, methodOrRequest.toUpperCase(), path)
+        : fromBuilt(context, methodOrRequest);
+    const close = () => {
+        closing ??= (async () => {
+            const opened = starting;
+            if (opened)
+                await (await opened.catch(() => undefined))?.close();
+        })();
+        return closing;
+    };
+    options.cleanup?.register(close, "http-test-client");
+    return {
+        get: (path) => request("GET", path),
+        post: (path) => request("POST", path),
+        put: (path) => request("PUT", path),
+        patch: (path) => request("PATCH", path),
+        delete: (path) => request("DELETE", path),
+        head: (path) => request("HEAD", path),
+        options: (path) => request("OPTIONS", path),
+        request,
+        cookies,
+        start: async () => (await transport()).origin,
+        close,
+        get closed() {
+            return closing !== undefined;
+        },
+    };
+}
+//# sourceMappingURL=httpTestClient.factory.js.map

package/dist/httpTestClient/httpTestClient.target.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @zudojs/testing — test client target resolution.
+ *
+ * Works out what kind of thing the client was pointed at and builds the
+ * matching transport. `@zudojs/http` objects are recognised by shape as well
+ * as by class, so a second copy of the package in `node_modules` still works.
+ */
+import type { HttpTestTransport } from "./httpTestTransport/index.js";
+import type { HttpTestClientOptions, HttpTestTarget } from "./httpTestClient.type.js";
+/**
+ * Builds the transport for `target`.
+ *
+ * @throws TypeError when the target is not a supported kind.
+ */
+export declare function resolveHttpTestTransport(target: HttpTestTarget, options?: HttpTestClientOptions): Promise<HttpTestTransport>;
+//# sourceMappingURL=httpTestClient.target.d.ts.map

package/dist/httpTestClient/httpTestClient.target.js

@@ -0,0 +1,80 @@
+/**
+ * @zudojs/testing — test client target resolution.
+ *
+ * Works out what kind of thing the client was pointed at and builds the
+ * matching transport. `@zudojs/http` objects are recognised by shape as well
+ * as by class, so a second copy of the package in `node_modules` still works.
+ */
+import { Server as NetServer } from "node:net";
+import { createAdapterTransport, createFetchTransport, createHandlerTransport, createHttpServerTransport, createListenerTransport, createNodeServerTransport, createOriginTransport, createPipelineTransport, createRouterTransport, } from "./httpTestTransport/index.js";
+function hasMethods(value, ...names) {
+    if (value === null || typeof value !== "object")
+        return false;
+    const record = value;
+    return names.every((name) => typeof record[name] === "function");
+}
+function isHttpServerLike(value) {
+    return (hasMethods(value, "start", "stop", "setHandler") &&
+        typeof value.adapter === "object");
+}
+function isNodeAdapterLike(value) {
+    return (hasMethods(value, "handle", "setHandler", "start", "stop") &&
+        "httpServer" in value);
+}
+/** A base URL's path (`http://host/api`) prefixes every request target. */
+function createBaseUrlTransport(url) {
+    const transport = createOriginTransport(url.origin);
+    const prefix = url.pathname.replace(/\/+$/, "");
+    if (!prefix)
+        return transport;
+    return {
+        ...transport,
+        pathPrefix: prefix,
+        send: (request) => transport.send({ ...request, target: `${prefix}${request.target}` }),
+    };
+}
+function resolveFunction(target, options) {
+    const kind = options.kind ?? (target.length >= 2 ? "node" : "fetch");
+    switch (kind) {
+        case "node":
+            return createListenerTransport(target);
+        case "zudo":
+            return createHandlerTransport(target, options.adapter);
+        default:
+            return Promise.resolve(createFetchTransport(target, options.origin));
+    }
+}
+/**
+ * Builds the transport for `target`.
+ *
+ * @throws TypeError when the target is not a supported kind.
+ */
+export function resolveHttpTestTransport(target, options = {}) {
+    if (typeof target === "string" || target instanceof URL) {
+        return Promise.resolve(createBaseUrlTransport(new URL(target)));
+    }
+    if (typeof target === "function") {
+        return resolveFunction(target, options);
+    }
+    if (target instanceof NetServer) {
+        return createNodeServerTransport(target);
+    }
+    if (isHttpServerLike(target)) {
+        return createHttpServerTransport(target);
+    }
+    if (isNodeAdapterLike(target)) {
+        return createAdapterTransport(target);
+    }
+    if (hasMethods(target, "dispatch", "match")) {
+        return createRouterTransport(target, options.adapter);
+    }
+    if (hasMethods(target, "execute", "use")) {
+        return createPipelineTransport(target, options.adapter);
+    }
+    if (hasMethods(target, "fetch")) {
+        const app = target;
+        return Promise.resolve(createFetchTransport((request) => app.fetch(request), options.origin));
+    }
+    return Promise.reject(new TypeError('createHttpTestClient: unsupported target. Pass a base URL, a Node http.Server, a (req, res) listener, a (request: Request) => Response handler, an object with fetch(), or an @zudojs/http HttpServer, NodeHttpAdapter, HttpRouter, HttpMiddlewarePipeline or handler (with kind: "zudo").'));
+}
+//# sourceMappingURL=httpTestClient.target.js.map

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

@@ -0,0 +1,74 @@
+/**
+ * @zudojs/testing — HTTP test client types.
+ */
+import type { Server as NetServer } from "node:net";
+import type { HttpHandler, HttpMiddlewarePipeline, HttpRouter, HttpServer, NodeHttpAdapter } from "@zudojs/http";
+import type { CleanupManager } from "../cleanupManager/index.js";
+import type { TestHTTPRequest } from "../httpTesting/index.js";
+import type { HttpTestCookieJar } from "./httpTestClient.cookieJar.js";
+import type { HttpTestRequest } from "./httpTestRequest/index.js";
+import type { FetchApplication, FetchHandler, HttpTestAdapterOptions, NodeRequestListener } from "./httpTestTransport/index.js";
+/**
+ * Anything the test client can send requests to.
+ *
+ * - a base URL (`"http://127.0.0.1:3000"`, optionally with a path prefix);
+ * - a Node `http.Server`/`https.Server` (started on port 0 if not listening);
+ * - a Node `(req, res)` request listener;
+ * - a web-standard `(request: Request) => Response` handler, or an object with
+ *   a `fetch` method — dispatched in-process, no port;
+ * - an `@zudojs/http` `HttpServer`, `NodeHttpAdapter`, `HttpRouter`,
+ *   `HttpMiddlewarePipeline`, or `HttpHandler` (with `kind: "zudo"`).
+ */
+export type HttpTestTarget = string | URL | NetServer | NodeRequestListener | FetchHandler | HttpHandler | FetchApplication | HttpServer | NodeHttpAdapter | HttpRouter | HttpMiddlewarePipeline;
+/**
+ * How a function target is called. Functions cannot be told apart reliably,
+ * so the default is by arity: two parameters is a Node listener, otherwise a
+ * fetch handler. An `@zudojs/http` `HttpHandler` needs `kind: "zudo"`.
+ */
+export type HttpTestTargetKind = "fetch" | "node" | "zudo";
+/** Options for `createHttpTestClient`. */
+export interface HttpTestClientOptions {
+    /** How to call a function target. See {@link HttpTestTargetKind}. */
+    readonly kind?: HttpTestTargetKind;
+    /** Per-request timeout in milliseconds. Default 5000. */
+    readonly timeout?: number;
+    /** Headers sent with every request (a request's own `set()` wins). */
+    readonly headers?: Readonly<Record<string, string>>;
+    /** Keep cookies from `Set-Cookie` and send them back. Default true. */
+    readonly cookies?: boolean;
+    /** Registers `client.close()` here, so the cleanup manager releases it. */
+    readonly cleanup?: CleanupManager;
+    /** Origin fetch-handler requests are resolved against. Default `http://localhost`. */
+    readonly origin?: string;
+    /** Settings for the `NodeHttpAdapter` created for routers, pipelines and handlers. */
+    readonly adapter?: HttpTestAdapterOptions;
+}
+/**
+ * A supertest-style client bound to one target.
+ *
+ * Servers the client started are closed by `close()`; servers that were
+ * already running are left alone.
+ */
+export interface HttpTestClient {
+    readonly get: (path: string) => HttpTestRequest;
+    readonly post: (path: string) => HttpTestRequest;
+    readonly put: (path: string) => HttpTestRequest;
+    readonly patch: (path: string) => HttpTestRequest;
+    readonly delete: (path: string) => HttpTestRequest;
+    readonly head: (path: string) => HttpTestRequest;
+    readonly options: (path: string) => HttpTestRequest;
+    /**
+     * Starts a request with any method, or sends one built with
+     * `createTestHTTPRequest()` / `createHTTPRequest()` (its `:params` are
+     * substituted into the path).
+     */
+    readonly request: (methodOrRequest: string | TestHTTPRequest, path?: string) => HttpTestRequest;
+    /** Cookies kept across requests. */
+    readonly cookies: HttpTestCookieJar;
+    /** Starts the target now (otherwise it starts on the first request) and returns its origin. */
+    readonly start: () => Promise<string>;
+    /** Closes whatever the client started. Safe to call more than once. */
+    readonly close: () => Promise<void>;
+    readonly closed: boolean;
+}
+//# sourceMappingURL=httpTestClient.type.d.ts.map

package/dist/httpTestClient/httpTestClient.type.js

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

package/dist/httpTestClient/httpTestRequest/httpTestRequest.core.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @zudojs/testing — fluent HTTP test request.
+ */
+import type { HttpTestRequest, HttpTestRequestContext } from "./httpTestRequest.type.js";
+/**
+ * Creates a request bound to a client context. Nothing is sent until the
+ * request is awaited.
+ */
+export declare function createHttpTestRequest(context: HttpTestRequestContext, method: string, path: string): HttpTestRequest;
+//# sourceMappingURL=httpTestRequest.core.d.ts.map