@velajs/testing 0.4.0 → 0.5.1

package/dist/index.js

@@ -1,3 +1,866 @@
-export { Test } from "./test.js";
-export { TestingModule } from "./testing-module.js";
-export { TestingModuleBuilder, OverrideBy } from "./testing-module.builder.js";
+import { i as registerWsConnector, n as TestWsRequest, r as getWsConnector, t as TestWsConnection } from "./test-ws-connection-BHlEKwQz.js";
+import { DiscoveryService, REQUEST_CONTEXT, Scope } from "@velajs/vela";
+import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_MIDDLEWARE, APP_PIPE, Container, MetadataRegistry, ModuleLoader, ModuleRef, RouteManager, VelaApplication as VelaApplication$1, bindAppProviders } from "@velajs/vela/internal";
+import { Context } from "hono";
+import { SeederRegistry } from "@velajs/vela/seeder";
+import { expect } from "vitest";
+//#region src/http/path-utils.ts
+/**
+* Read the value at a dot-notation path (e.g. `data.user.id`).
+* Returns `undefined` when any segment along the way is null/undefined.
+*/
+function getValueAtPath(obj, path) {
+	const parts = path.split(".");
+	let current = obj;
+	for (const part of parts) {
+		if (current === null || current === void 0) return;
+		current = current[part];
+	}
+	return current;
+}
+/**
+* Whether a dot-notation path exists on the object, even when the value at the
+* path is `null`/`undefined`. Distinguishes "key present but null" from "key
+* absent".
+*/
+function hasValueAtPath(obj, path) {
+	const parts = path.split(".");
+	let current = obj;
+	for (const part of parts) {
+		if (current === null || current === void 0) return false;
+		if (typeof current !== "object") return false;
+		const record = current;
+		if (!(part in record)) return false;
+		current = record[part];
+	}
+	return true;
+}
+//#endregion
+//#region src/http/test-response.ts
+/**
+* TestResponse
+*
+* Wraps a `Response` with fluent, chainable assertions. Synchronous status /
+* header assertions return `this`; JSON assertions (which must read the body)
+* return `Promise<this>`.
+*
+* @example
+* ```ts
+* const res = await module.http.get('/users/1').send();
+* res.assertOk();
+* await res.assertJsonPath('data.id', 1);
+* ```
+*/
+var TestResponse = class {
+	response;
+	jsonData = null;
+	textData = null;
+	constructor(response) {
+		this.response = response;
+	}
+	/** The raw `Response`. */
+	get raw() {
+		return this.response;
+	}
+	/** The response status code. */
+	get status() {
+		return this.response.status;
+	}
+	/** The response headers. */
+	get headers() {
+		return this.response.headers;
+	}
+	/** Parse (and cache) the response body as JSON. */
+	async json() {
+		if (this.jsonData === null) this.jsonData = await this.response.clone().json();
+		return this.jsonData;
+	}
+	/** Read (and cache) the response body as text. */
+	async text() {
+		this.textData ??= await this.response.clone().text();
+		return this.textData;
+	}
+	/** Assert status is 200 OK. */
+	assertOk() {
+		return this.assertStatus(200);
+	}
+	/** Assert status is 201 Created. */
+	assertCreated() {
+		return this.assertStatus(201);
+	}
+	/** Assert status is 204 No Content. */
+	assertNoContent() {
+		return this.assertStatus(204);
+	}
+	/** Assert status is 400 Bad Request. */
+	assertBadRequest() {
+		return this.assertStatus(400);
+	}
+	/** Assert status is 401 Unauthorized. */
+	assertUnauthorized() {
+		return this.assertStatus(401);
+	}
+	/** Assert status is 403 Forbidden. */
+	assertForbidden() {
+		return this.assertStatus(403);
+	}
+	/** Assert status is 404 Not Found. */
+	assertNotFound() {
+		return this.assertStatus(404);
+	}
+	/** Assert status is 422 Unprocessable Entity. */
+	assertUnprocessable() {
+		return this.assertStatus(422);
+	}
+	/** Assert status is 500 Internal Server Error. */
+	assertServerError() {
+		return this.assertStatus(500);
+	}
+	/** Assert the response has the given status code. */
+	assertStatus(expected) {
+		expect(this.response.status, `Expected status ${expected}, got ${this.response.status}`).toBe(expected);
+		return this;
+	}
+	/** Assert the status is in the 2xx range. */
+	assertSuccessful() {
+		expect(this.response.status >= 200 && this.response.status < 300, `Expected successful status (2xx), got ${this.response.status}`).toBe(true);
+		return this;
+	}
+	/** Assert each key in `expected` equals the corresponding top-level value. */
+	async assertJson(expected) {
+		const actual = await this.json();
+		for (const [key, value] of Object.entries(expected)) expect(actual[key], `Expected JSON key "${key}" to be ${JSON.stringify(value)}, got ${JSON.stringify(actual[key])}`).toStrictEqual(value);
+		return this;
+	}
+	/** Assert the value at a dot-notation path equals `expected`. */
+	async assertJsonPath(path, expected) {
+		const actual = getValueAtPath(await this.json(), path);
+		expect(actual, `Expected JSON path "${path}" to be ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`).toStrictEqual(expected);
+		return this;
+	}
+	/** Assert every path/value pair in `expectations` matches (batch assert). */
+	async assertJsonPaths(expectations) {
+		const json = await this.json();
+		for (const [path, expected] of Object.entries(expectations)) {
+			const actual = getValueAtPath(json, path);
+			expect(actual, `Expected JSON path "${path}" to be ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`).toStrictEqual(expected);
+		}
+		return this;
+	}
+	/** Assert the top-level JSON object has every key in `structure`. */
+	async assertJsonStructure(structure) {
+		const json = await this.json();
+		for (const key of structure) expect(key in json, `Expected JSON to have key "${key}", got keys: ${JSON.stringify(Object.keys(json))}`).toBe(true);
+		return this;
+	}
+	/** Assert a path exists (value may be anything, including `null`). */
+	async assertJsonPathExists(path) {
+		expect(hasValueAtPath(await this.json(), path), `Expected JSON path "${path}" to exist`).toBe(true);
+		return this;
+	}
+	/** Assert a path does not exist. */
+	async assertJsonPathMissing(path) {
+		expect(hasValueAtPath(await this.json(), path), `Expected JSON path "${path}" to not exist`).toBe(false);
+		return this;
+	}
+	/** Assert the value at a path satisfies a predicate. */
+	async assertJsonPathMatches(path, matcher) {
+		const value = getValueAtPath(await this.json(), path);
+		expect(matcher(value), `Expected JSON path "${path}" to match predicate, got ${JSON.stringify(value)}`).toBe(true);
+		return this;
+	}
+	/** Assert the string value at a path contains `substring`. */
+	async assertJsonPathContains(path, substring) {
+		const value = getValueAtPath(await this.json(), path);
+		expect(typeof value === "string", `Expected JSON path "${path}" to be a string, got ${typeof value}`).toBe(true);
+		expect(value.includes(substring), `Expected JSON path "${path}" to contain "${substring}", got "${String(value)}"`).toBe(true);
+		return this;
+	}
+	/** Assert the array value at a path includes `item`. */
+	async assertJsonPathIncludes(path, item) {
+		const value = getValueAtPath(await this.json(), path);
+		expect(Array.isArray(value), `Expected JSON path "${path}" to be an array, got ${typeof value}`).toBe(true);
+		expect(value.includes(item), `Expected JSON path "${path}" to include ${JSON.stringify(item)}`).toBe(true);
+		return this;
+	}
+	/** Assert the array value at a path has `count` items. */
+	async assertJsonPathCount(path, count) {
+		const value = getValueAtPath(await this.json(), path);
+		expect(Array.isArray(value), `Expected JSON path "${path}" to be an array, got ${typeof value}`).toBe(true);
+		expect(value.length, `Expected JSON path "${path}" to have ${count} items, got ${value.length}`).toBe(count);
+		return this;
+	}
+	/** Assert a header is present, optionally equal to `expected`. */
+	assertHeader(name, expected) {
+		const actual = this.response.headers.get(name);
+		expect(actual !== null, `Expected header "${name}" to be present`).toBe(true);
+		if (expected !== void 0) expect(actual, `Expected header "${name}" to be "${expected}", got "${actual}"`).toBe(expected);
+		return this;
+	}
+	/** Assert a header is absent. */
+	assertHeaderMissing(name) {
+		const actual = this.response.headers.get(name);
+		expect(actual, `Expected header "${name}" to be absent, but got "${actual}"`).toBeNull();
+		return this;
+	}
+};
+//#endregion
+//#region src/http/test-http-request.ts
+/**
+* TestHttpRequest
+*
+* Fluent builder for a single test HTTP request. `send()` builds a `Request`
+* and drives it through `module.fetch()` (the full Hono pipeline).
+*
+* @example
+* ```ts
+* const res = await module.http
+*   .post('/users')
+*   .withBody({ name: 'A' })
+*   .withHeaders({ 'X-Trace': '1' })
+*   .send();
+* res.assertCreated();
+* ```
+*/
+var TestHttpRequest = class {
+	method;
+	path;
+	module;
+	host;
+	body = void 0;
+	requestHeaders;
+	principal = null;
+	resolver = null;
+	constructor(method, path, headers, module, host = null) {
+		this.method = method;
+		this.path = path;
+		this.module = module;
+		this.host = host;
+		this.requestHeaders = new Headers(headers);
+	}
+	/** Set the request body (JSON-serialized on send). */
+	withBody(data) {
+		this.body = data;
+		return this;
+	}
+	/** Merge additional headers. */
+	withHeaders(headers) {
+		for (const [key, value] of Object.entries(headers)) this.requestHeaders.set(key, value);
+		return this;
+	}
+	/** Set `Content-Type: application/json`. */
+	asJson() {
+		this.requestHeaders.set("Content-Type", "application/json");
+		return this;
+	}
+	/**
+	* Authenticate the request as `principal`. The `resolver` (or a default one
+	* registered via `module.setAuthResolver`) turns the principal into request
+	* headers. The resolver signature `(module, principal) => Promise<Headers>`
+	* is the cross-package contract sibling packages (e.g. `@velajs/better-auth`)
+	* build against.
+	*/
+	actingAs(principal, resolver) {
+		this.principal = principal;
+		this.resolver = resolver ?? null;
+		return this;
+	}
+	/** Build the `Request` and send it through `module.fetch()`. */
+	async send() {
+		await this.applyAuthentication();
+		const hasBody = this.body !== void 0 && this.body !== null;
+		if (hasBody && !this.requestHeaders.has("Content-Type")) this.requestHeaders.set("Content-Type", "application/json");
+		const url = new URL(this.path, `http://${this.host ?? "localhost"}`);
+		const request = new Request(url.toString(), {
+			method: this.method,
+			headers: this.requestHeaders,
+			body: hasBody ? JSON.stringify(this.body) : null
+		});
+		return new TestResponse(await this.module.fetch(request));
+	}
+	async applyAuthentication() {
+		if (!this.principal) return;
+		const resolver = this.resolver ?? this.module.getAuthResolver();
+		if (!resolver) throw new Error("actingAs() requires an auth resolver. Pass one explicitly — actingAs(principal, resolver) — or register a default with module.setAuthResolver(resolver). For better-auth: import { actingAs } from \"@velajs/better-auth/testing\".");
+		const headers = await resolver(this.module, this.principal);
+		for (const [key, value] of headers.entries()) this.requestHeaders.set(key, value);
+	}
+};
+//#endregion
+//#region src/http/test-http-client.ts
+/**
+* TestHttpClient
+*
+* Fluent entry point for test HTTP requests. `forHost`/`withHeaders` return a
+* new immutable client; the verb methods start a {@link TestHttpRequest}.
+*
+* @example
+* ```ts
+* const res = await module.http
+*   .forHost('example.com')
+*   .post('/users')
+*   .withBody({ name: 'A' })
+*   .send();
+* res.assertCreated();
+* ```
+*/
+var TestHttpClient = class TestHttpClient {
+	module;
+	host;
+	defaultHeaders;
+	constructor(module, host = null, defaultHeaders = new Headers()) {
+		this.module = module;
+		this.host = host;
+		this.defaultHeaders = defaultHeaders;
+	}
+	/**
+	* Return a new client bound to `host`. Also sets the `Host` header so domain
+	* routing works even when the runtime reads the header rather than the URL.
+	*/
+	forHost(host) {
+		const headers = new Headers(this.defaultHeaders);
+		headers.set("Host", host);
+		return new TestHttpClient(this.module, host, headers);
+	}
+	/** Return a new client with additional default headers on every request. */
+	withHeaders(headers) {
+		const next = new Headers(this.defaultHeaders);
+		for (const [key, value] of Object.entries(headers)) next.set(key, value);
+		return new TestHttpClient(this.module, this.host, next);
+	}
+	get(path) {
+		return this.createRequest("GET", path);
+	}
+	post(path) {
+		return this.createRequest("POST", path);
+	}
+	put(path) {
+		return this.createRequest("PUT", path);
+	}
+	patch(path) {
+		return this.createRequest("PATCH", path);
+	}
+	delete(path) {
+		return this.createRequest("DELETE", path);
+	}
+	createRequest(method, path) {
+		return new TestHttpRequest(method, path, this.defaultHeaders, this.module, this.host);
+	}
+};
+//#endregion
+//#region src/sse/test-sse-connection.ts
+/**
+* TestSseConnection
+*
+* Reads a streaming `text/event-stream` response body and exposes queue-based
+* wait/assert helpers over the parsed events.
+*
+* @example
+* ```ts
+* const sse = await module.sse('/stream/events').connect();
+* await sse.assertEventData('ping');
+* await sse.waitForEnd();
+* ```
+*/
+var TestSseConnection = class {
+	response;
+	eventQueue = [];
+	eventWaiters = [];
+	streamEnded = false;
+	endWaiters = [];
+	constructor(response) {
+		this.response = response;
+		this.startReading();
+	}
+	/** The raw `Response`. */
+	get raw() {
+		return this.response;
+	}
+	/** Wait for the next event (rejects after `timeout` ms). */
+	async waitForEvent(timeout = 5e3) {
+		if (this.eventQueue.length > 0) return this.eventQueue.shift();
+		if (this.streamEnded) throw new Error("SSE: stream has ended, no more events");
+		return new Promise((resolve, reject) => {
+			const waiter = (event) => {
+				clearTimeout(timer);
+				resolve(event);
+			};
+			const timer = setTimeout(() => {
+				const index = this.eventWaiters.indexOf(waiter);
+				if (index !== -1) this.eventWaiters.splice(index, 1);
+				reject(/* @__PURE__ */ new Error(`SSE: no event received within ${timeout}ms`));
+			}, timeout);
+			this.eventWaiters.push(waiter);
+		});
+	}
+	/** Wait for the stream to end (rejects after `timeout` ms). */
+	async waitForEnd(timeout = 5e3) {
+		if (this.streamEnded) return;
+		return new Promise((resolve, reject) => {
+			const waiter = () => {
+				clearTimeout(timer);
+				resolve();
+			};
+			const timer = setTimeout(() => {
+				const index = this.endWaiters.indexOf(waiter);
+				if (index !== -1) this.endWaiters.splice(index, 1);
+				reject(/* @__PURE__ */ new Error(`SSE: stream did not end within ${timeout}ms`));
+			}, timeout);
+			this.endWaiters.push(waiter);
+		});
+	}
+	/** Collect all remaining events until the stream ends. */
+	async collectEvents(timeout = 5e3) {
+		const events = [];
+		if (this.streamEnded) return [...this.eventQueue.splice(0)];
+		return new Promise((resolve, reject) => {
+			const originalDispatch = this.dispatchEvent.bind(this);
+			this.dispatchEvent = (event) => {
+				events.push(event);
+				originalDispatch(event);
+			};
+			const endWaiter = () => {
+				clearTimeout(timer);
+				this.dispatchEvent = originalDispatch;
+				resolve(events);
+			};
+			const timer = setTimeout(() => {
+				this.dispatchEvent = originalDispatch;
+				const index = this.endWaiters.indexOf(endWaiter);
+				if (index !== -1) this.endWaiters.splice(index, 1);
+				reject(/* @__PURE__ */ new Error(`SSE: stream did not end within ${timeout}ms`));
+			}, timeout);
+			events.push(...this.eventQueue.splice(0));
+			this.endWaiters.push(endWaiter);
+		});
+	}
+	/** Assert the next event matches the expected partial shape. */
+	async assertEvent(expected, timeout = 5e3) {
+		expect(await this.waitForEvent(timeout)).toMatchObject(expected);
+	}
+	/** Assert the next event's `data` equals `expected`. */
+	async assertEventData(expected, timeout = 5e3) {
+		const event = await this.waitForEvent(timeout);
+		expect(event.data, `Expected SSE data "${expected}", got "${event.data}"`).toBe(expected);
+	}
+	/** Assert the next event's `data` is JSON equal to `expected`. */
+	async assertJsonEventData(expected, timeout = 5e3) {
+		const event = await this.waitForEvent(timeout);
+		expect(JSON.parse(event.data)).toEqual(expected);
+	}
+	startReading() {
+		const body = this.response.body;
+		if (!body) {
+			this.streamEnded = true;
+			return;
+		}
+		const reader = body.getReader();
+		const decoder = new TextDecoder();
+		let buffer = "";
+		const read = async () => {
+			try {
+				for (;;) {
+					const { done, value } = await reader.read();
+					if (done) {
+						if (buffer.trim()) {
+							const event = this.parseEvent(buffer);
+							if (event) this.dispatchEvent(event);
+						}
+						this.endStream();
+						return;
+					}
+					buffer += decoder.decode(value, { stream: true });
+					const parts = buffer.split("\n\n");
+					buffer = parts.pop();
+					for (const part of parts) {
+						if (!part.trim()) continue;
+						const event = this.parseEvent(part);
+						if (event) this.dispatchEvent(event);
+					}
+				}
+			} catch {
+				this.endStream();
+			}
+		};
+		read();
+	}
+	endStream() {
+		this.streamEnded = true;
+		for (const waiter of this.endWaiters) waiter();
+		this.endWaiters = [];
+	}
+	parseEvent(raw) {
+		const lines = raw.split("\n");
+		const dataLines = [];
+		let event;
+		let id;
+		let retry;
+		for (const line of lines) {
+			if (line.startsWith(":")) continue;
+			const colonIndex = line.indexOf(":");
+			if (colonIndex === -1) continue;
+			const field = line.slice(0, colonIndex);
+			const value = line[colonIndex + 1] === " " ? line.slice(colonIndex + 2) : line.slice(colonIndex + 1);
+			switch (field) {
+				case "data":
+					dataLines.push(value);
+					break;
+				case "event":
+					event = value;
+					break;
+				case "id":
+					id = value;
+					break;
+				case "retry": {
+					const parsed = parseInt(value, 10);
+					if (!Number.isNaN(parsed)) retry = parsed;
+					break;
+				}
+			}
+		}
+		if (dataLines.length === 0) return null;
+		const result = { data: dataLines.join("\n") };
+		if (event !== void 0) result.event = event;
+		if (id !== void 0) result.id = id;
+		if (retry !== void 0) result.retry = retry;
+		return result;
+	}
+	dispatchEvent(event) {
+		if (this.eventWaiters.length > 0) this.eventWaiters.shift()(event);
+		else this.eventQueue.push(event);
+	}
+};
+//#endregion
+//#region src/sse/test-sse-request.ts
+/**
+* TestSseRequest
+*
+* Builder for a Server-Sent Events connection. `connect()` issues a GET through
+* `module.fetch()`, asserts a `text/event-stream` 200, and wraps the streaming
+* body in a {@link TestSseConnection}.
+*
+* @example
+* ```ts
+* const sse = await module.sse('/stream/events').connect();
+* await sse.assertEvent({ event: 'message', data: 'hello' });
+* ```
+*/
+var TestSseRequest = class {
+	path;
+	module;
+	requestHeaders = new Headers();
+	principal = null;
+	resolver = null;
+	constructor(path, module) {
+		this.path = path;
+		this.module = module;
+	}
+	/** Merge additional headers onto the SSE request. */
+	withHeaders(headers) {
+		for (const [key, value] of Object.entries(headers)) this.requestHeaders.set(key, value);
+		return this;
+	}
+	/** Authenticate the connection (see {@link TestHttpRequest.actingAs}). */
+	actingAs(principal, resolver) {
+		this.principal = principal;
+		this.resolver = resolver ?? null;
+		return this;
+	}
+	/** Open the stream and return a live {@link TestSseConnection}. */
+	async connect() {
+		await this.applyAuthentication();
+		this.requestHeaders.set("Accept", "text/event-stream");
+		const url = new URL(this.path, "http://localhost");
+		const request = new Request(url.toString(), { headers: this.requestHeaders });
+		const response = await this.module.fetch(request);
+		expect(response.status, `Expected status 200, got ${response.status}`).toBe(200);
+		const contentType = response.headers.get("content-type") ?? "";
+		expect(contentType.includes("text/event-stream"), `Expected content-type "text/event-stream", got "${contentType}"`).toBe(true);
+		return new TestSseConnection(response);
+	}
+	async applyAuthentication() {
+		if (!this.principal) return;
+		const resolver = this.resolver ?? this.module.getAuthResolver();
+		if (!resolver) throw new Error("actingAs() requires an auth resolver. Pass one explicitly or register a default with module.setAuthResolver(resolver).");
+		const headers = await resolver(this.module, this.principal);
+		for (const [key, value] of headers.entries()) this.requestHeaders.set(key, value);
+	}
+};
+//#endregion
+//#region src/testing-module.ts
+/**
+* TestingModule
+*
+* The compiled test harness. Beyond `get`/`createApplication`/`close`, it adds
+* Laravel-flavored ergonomics: a fluent HTTP client, SSE/WS builders, request-
+* scope execution, seeding, and database assertion wrappers.
+*
+* @example
+* ```ts
+* const module = await Test.createTestingModule({ imports: [AppModule] }).compile();
+* await module.http.post('/users').withBody({ name: 'A' }).send()
+*   .then((r) => r.assertCreated());
+* ```
+*/
+var TestingModule = class {
+	app;
+	container;
+	_http = null;
+	honoApp = null;
+	authResolver = null;
+	constructor(app, container) {
+		this.app = app;
+		this.container = container;
+	}
+	/** Resolve a provider from the root container. */
+	get(token) {
+		return this.container.resolve(token);
+	}
+	/** Build (once) and return the underlying application. */
+	async createApplication() {
+		await this.app.initRoutes();
+		return this.app;
+	}
+	/** Lazy fluent HTTP client bound to this module. */
+	get http() {
+		this._http ??= new TestHttpClient(this);
+		return this._http;
+	}
+	/** Start an SSE connection builder for `path`. */
+	sse(path) {
+		return new TestSseRequest(path, this);
+	}
+	/** Start a WebSocket connection builder for `path` (needs a transport adapter). */
+	ws(path) {
+		return new TestWsRequest(path, this);
+	}
+	/**
+	* Drive a `Request` through the full Hono pipeline. The Hono app is built
+	* once and reused across requests.
+	*/
+	async fetch(request, env, ctx) {
+		return (await this.ensureHono()).fetch(request, env, ctx);
+	}
+	/**
+	* Register a default auth resolver used by `actingAs(principal)` when no
+	* resolver is passed explicitly.
+	*/
+	setAuthResolver(resolver) {
+		this.authResolver = resolver;
+		return this;
+	}
+	/** The default auth resolver, if one was registered. */
+	getAuthResolver() {
+		return this.authResolver;
+	}
+	/**
+	* Run `callback` inside a request-scoped child container seeded with a mock
+	* {@link RequestContext}, so REQUEST-scoped providers (and anything injecting
+	* `REQUEST_CONTEXT`) resolve. The child is disposed afterwards.
+	*/
+	async runInRequestScope(callback) {
+		const child = this.container.createChild();
+		child.setRequestInstance(REQUEST_CONTEXT, this.createMockRequestContext());
+		try {
+			return await callback(child);
+		} finally {
+			await child.dispose();
+		}
+	}
+	/**
+	* Run the given `@Seeder()` classes, each in its own request scope. Throws if
+	* a class is not a registered seeder. Requires `SeederModule` (or the seeders
+	* themselves) to be present in the module graph.
+	*/
+	async seed(...SeederClasses) {
+		const registry = this.container.resolve(SeederRegistry);
+		const known = new Set(registry.list().map((s) => s.target));
+		for (const SeederClass of SeederClasses) {
+			if (!known.has(SeederClass)) throw new Error(`Seeder "${SeederClass.name}" is not registered. Add it to a module's providers or SeederModule.forRoot({ seeders: [...] }).`);
+			await this.runInRequestScope(async (child) => {
+				await child.resolve(SeederClass).run();
+			});
+		}
+	}
+	/** Assert a row matching `where` exists in `table` (via a {@link TestDatabase}). */
+	async assertDatabaseHas(db, table, where) {
+		expect(await db.has(table, where), `Expected ${table} to have a row matching ${JSON.stringify(where)}`).toBe(true);
+	}
+	/** Assert no row matching `where` exists in `table`. */
+	async assertDatabaseMissing(db, table, where) {
+		expect(await db.has(table, where), `Expected ${table} NOT to have a row matching ${JSON.stringify(where)}`).toBe(false);
+	}
+	/** Assert `table` has exactly `expected` rows. */
+	async assertDatabaseCount(db, table, expected) {
+		const actual = await db.count(table);
+		expect(actual, `Expected ${table} count ${expected}, got ${actual}`).toBe(expected);
+	}
+	/** Dispose the application. */
+	async close(signal) {
+		await this.app.close(signal);
+	}
+	async ensureHono() {
+		if (!this.honoApp) {
+			const app = await this.createApplication();
+			this.honoApp = app.getHonoApp();
+		}
+		return this.honoApp;
+	}
+	/**
+	* Build a minimal, functional {@link RequestContext} for out-of-band request
+	* scopes. Vela has no `createMockRouterContext`; a real (empty) Hono `Context`
+	* backs the `hono` field so nothing dangles.
+	*/
+	createMockRequestContext() {
+		const bag = /* @__PURE__ */ new Map();
+		const request = new Request("http://localhost/");
+		const hono = new Context(request);
+		return {
+			id: crypto.randomUUID(),
+			receivedAt: /* @__PURE__ */ new Date(),
+			request,
+			hono,
+			set(key, value) {
+				bag.set(key, value);
+			},
+			get(key) {
+				return bag.get(key);
+			},
+			has(key) {
+				return bag.has(key);
+			}
+		};
+	}
+};
+//#endregion
+//#region src/testing-module.builder.ts
+var OverrideBy = class {
+	builder;
+	token;
+	constructor(builder, token) {
+		this.builder = builder;
+		this.token = token;
+	}
+	useValue(value) {
+		this.builder["addOverride"]({
+			token: this.token,
+			provider: {
+				provide: this.token,
+				useValue: value
+			}
+		});
+		return this.builder;
+	}
+	useClass(cls) {
+		this.builder["addOverride"]({
+			token: this.token,
+			provider: {
+				provide: this.token,
+				useClass: cls
+			}
+		});
+		return this.builder;
+	}
+	useFactory(options) {
+		this.builder["addOverride"]({
+			token: this.token,
+			provider: {
+				provide: this.token,
+				useFactory: options.factory,
+				inject: options.inject
+			}
+		});
+		return this.builder;
+	}
+};
+var TestingModuleBuilder = class {
+	metadata;
+	overrides = [];
+	constructor(metadata) {
+		this.metadata = metadata;
+	}
+	overrideProvider(token) {
+		return new OverrideBy(this, token);
+	}
+	overrideGuard(guard) {
+		return new OverrideBy(this, guard);
+	}
+	overridePipe(pipe) {
+		return new OverrideBy(this, pipe);
+	}
+	overrideInterceptor(interceptor) {
+		return new OverrideBy(this, interceptor);
+	}
+	overrideFilter(filter) {
+		return new OverrideBy(this, filter);
+	}
+	addOverride(entry) {
+		const idx = this.overrides.findIndex((o) => o.token === entry.token);
+		if (idx !== -1) this.overrides[idx] = entry;
+		else this.overrides.push(entry);
+	}
+	async compile() {
+		class TestRootModule {}
+		MetadataRegistry.setModuleOptions(TestRootModule, {
+			imports: this.metadata.imports,
+			providers: this.metadata.providers,
+			controllers: this.metadata.controllers,
+			exports: this.metadata.exports
+		});
+		const container = new Container();
+		container.register({
+			provide: Container,
+			useValue: container
+		});
+		container.markGlobalToken(Container);
+		container.register({
+			provide: ModuleRef,
+			useFactory: (c) => new ModuleRef(c),
+			inject: [Container]
+		});
+		container.markGlobalToken(ModuleRef);
+		container.register({
+			provide: DiscoveryService,
+			useFactory: (c) => new DiscoveryService(c),
+			inject: [Container]
+		});
+		container.markGlobalToken(DiscoveryService);
+		for (const t of [
+			APP_GUARD,
+			APP_PIPE,
+			APP_INTERCEPTOR,
+			APP_FILTER,
+			APP_MIDDLEWARE
+		]) container.markGlobalToken(t);
+		container.register({
+			provide: REQUEST_CONTEXT,
+			scope: Scope.REQUEST,
+			useFactory: () => {
+				throw new Error("REQUEST_CONTEXT can only be resolved inside a request — it is seeded by RouteManager when the request enters the pipeline.");
+			}
+		});
+		container.markGlobalToken(REQUEST_CONTEXT);
+		for (const override of this.overrides) container.register(override.provider);
+		const routeManager = new RouteManager(container);
+		const loader = new ModuleLoader(container, routeManager);
+		loader.load(TestRootModule);
+		for (const override of this.overrides) container.replaceProvider(override.provider);
+		bindAppProviders(routeManager, container, loader);
+		const app = new VelaApplication$1(container, routeManager);
+		const instances = await loader.resolveAllInstances();
+		app.setInstances(instances);
+		await app.callOnModuleInit();
+		await app.callOnApplicationBootstrap();
+		await app.initRoutes();
+		return new TestingModule(app, container);
+	}
+};
+//#endregion
+//#region src/test.ts
+const Test = { createTestingModule(metadata) {
+	return new TestingModuleBuilder(metadata);
+} };
+//#endregion
+export { OverrideBy, Test, TestHttpClient, TestHttpRequest, TestResponse, TestSseConnection, TestSseRequest, TestWsConnection, TestWsRequest, TestingModule, TestingModuleBuilder, getValueAtPath, getWsConnector, hasValueAtPath, registerWsConnector };
+
+//# sourceMappingURL=index.js.map