@znight/testing 0.5.1 → 0.6.0

package/README.md

@@ -230,14 +230,15 @@ await using app = await TestApp.create({
 })
 ```
 
-| Member                  | Description                                                                                                              |
-| ----------------------- | ------------------------------------------------------------------------------------------------------------------------ |
-| `inject(request)`       | In-memory request through the HTTP plugin: `{ method = 'GET', url, headers?, body?, query?, cookies?, signedCookies? }`. |
-| `injectSse(request)`    | An event stream (Server-Sent Events) read in memory like `EventSource` (see below).                                      |
-| `injectStream(request)` | In-memory request resolving at the response headers, its `body` a `ReadableStream` read as it is produced.               |
-| `get(key)`              | `app.container.get(key)` (class, token, alias or display name).                                                          |
-| `close()`               | Stops the application (idempotent). Also `await using app = await TestApp.create(...)`.                                  |
-| `app` / `container`     | The `Application` and its `Container`.                                                                                   |
+| Member                    | Description                                                                                                              |
+| ------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
+| `inject(request)`         | In-memory request through the HTTP plugin: `{ method = 'GET', url, headers?, body?, query?, cookies?, signedCookies? }`. |
+| `injectSse(request)`      | An event stream (Server-Sent Events) read in memory like `EventSource` (see below).                                      |
+| `injectStream(request)`   | In-memory request resolving at the response headers, its `body` a `ReadableStream` read as it is produced.               |
+| `connect(path, options?)` | In-memory WebSocket connection through `WebSocketPlugin` (`@znight/websocket`, see below).                               |
+| `get(key)`                | `app.container.get(key)` (class, token, alias or display name).                                                          |
+| `close()`                 | Stops the application (idempotent). Also `await using app = await TestApp.create(...)`.                                  |
+| `app` / `container`       | The `Application` and its `Container`.                                                                                   |
 
 `inject()` resolves with `{ status, headers, body, bytes, cookies, json() }` (`body` decoded as
 UTF-8, `bytes` the raw body, for downloads, `cookies` the `set-cookie` headers parsed by name); it
@@ -425,6 +426,27 @@ without importing any feature package:
 | `extensions.schedule.jobs[].token`                                                                 | `TestApp` boot roots                         |
 | `extensions.graphql.types[kind: 'object'].fields[].resolver.{ token, guards, loaders }`            | `TestApp` boot roots                         |
 
+### WebSocket connections
+
+`app.connect(path, { query?, headers?, protocols?, origin?, cookies? })` runs the real WebSocket
+handshake of `WebSocketPlugin` (`@znight/websocket`) through the HTTP pipeline, in memory, and
+resolves with a `TestWsClient`: `request(event, data?)` (the reply's data; rejects with a
+`WsRequestError` `{ code, message, details }`), `next(event?)` (the oldest server event not taken
+yet: frames are buffered from the start), `send`, `sendRaw`, `nextRaw`, `frames`, `close()` and
+`closed`. A refused handshake rejects with a `WsHandshakeError` (`status`, `headers`, `body`,
+`json()`). `connectWebSocket(url, { headers?, protocols? })` gives the same client over the network
+(the global `WebSocket` of Node.js and Bun).
+
+```ts
+import { connectWebSocket, WsHandshakeError } from '@znight/testing'
+
+await using alice = await app.connect('/chat', { protocols: ['chat.v1'] })
+expect(await alice.request('room.join', { room: 'general' })).toEqual({ members: 1 })
+await expect(app.connect('/chat', { origin: 'https://evil.example' })).rejects.toBeInstanceOf(WsHandshakeError)
+
+await using remote = await connectWebSocket(`ws://127.0.0.1:${port}/chat`, { protocols: ['chat.v1'] })
+```
+
 Runtime contract with `@znight/http`: the plugin named `'http'` exposes
 `inject(request: { method: string; url: string; headers?; body?; query?; cookies?; signedCookies? }): Promise<{ status: number; headers; body: string; bytes?: Uint8Array; cookies?: Record<string, SetCookieInfo>; json<T>(): T }>`
 (`HttpInjector`, `HttpInjectResult`), dispatching in memory. `TestApp` forwards every request field
@@ -435,6 +457,12 @@ as is (signing `signedCookies` is the plugin's job), returns the plugin's respon
 `HttpPlugin` of `@znight/http` ≥ 0.1.0), the method defaulting to `GET`; the response shapes are
 `InjectStreamResponse` and `InjectSseResponse` (structural copies of the `@znight/http` types).
 
+Runtime contract with `@znight/websocket`: the plugin named `'websocket'` exposes
+`connect(path, options?): Promise<TestWsClient>` (`WebSocketConnector`). `WsHandshakeError` and
+`WsRequestError` match the errors of `@znight/websocket` structurally (`instanceof` checks their
+`name` and `status` / `code`). `TestApp` boots the gateways of `metadata.extensions.websocket` with
+their guards.
+
 Runtime contract with every plugin: the optional `initRoots(context: { metadata }): readonly ProviderKey[]`
 member of `Plugin` (`@znight/core`; `PluginInitRoots` names a plugin implementing it) returns the
 providers (classes or tokens) the plugin resolves at boot that the metadata does not make entry

package/dist/index.d.mts

@@ -349,6 +349,92 @@ export declare function overrideFactory<T>(key: ProviderKey<T>, factory: Provide
 export declare function createSpy<F extends AnyFunction = UntypedFunction>(implementation?: F): MockFunction<F>;
 /** Whether `value` is a spy created by {@link createSpy}. */
 export declare function isBuiltinSpy(value: unknown): boolean;
+/**
+ * WebSocket test clients (RFC 0003 §5.10). `TestApp.connect()` delegates to the plugin named
+ * `websocket` (`WebSocketPlugin` of `@znight/websocket`, an in-memory connection);
+ * `connectWebSocket(url)` wraps the global `WebSocket` (Node.js and Bun) with the same interface.
+ * `@znight/testing` depends on no feature package: the errors match structurally.
+ */
+/** How a connection closed. */
+interface TestWsCloseInfo {
+  readonly code: number;
+  readonly reason: string;
+}
+/** Options of the waiting methods of {@link TestWsClient}. */
+interface TestWsWaitOptions {
+  /** Default: 1 000 ms (`request()`: 5 000 ms). */
+  readonly timeoutMs?: number;
+}
+/** A WebSocket client speaking the `events` protocol of `@znight/websocket`, or raw frames. */
+interface TestWsClient extends AsyncDisposable {
+  /** The negotiated subprotocol, `''` when none. */
+  readonly protocol: string;
+  /** Every frame received, in order: JSON objects decoded, other text frames as strings, binary frames as bytes. */
+  readonly frames: readonly unknown[];
+  /** Sends an event without id. */
+  send(event: string, data?: unknown): void;
+  /** Sends a request; resolves with the `data` of its reply, rejects with a {@link WsRequestError}. */
+  request<T = unknown>(event: string, data?: unknown, options?: TestWsWaitOptions): Promise<T>;
+  /** The `data` of the oldest server event (matching `event`) not taken yet: frames are buffered from the start. */
+  next<T = unknown>(event?: string, options?: TestWsWaitOptions): Promise<T>;
+  sendRaw(frame: string | Uint8Array): void;
+  nextRaw(options?: TestWsWaitOptions): Promise<string | Uint8Array>;
+  close(code?: number, reason?: string): Promise<TestWsCloseInfo>;
+  readonly closed: Promise<TestWsCloseInfo>;
+}
+/** Options of `TestApp.connect()`. */
+interface TestWsConnectOptions {
+  readonly query?: Readonly<Record<string, string | readonly string[]>>;
+  readonly headers?: Readonly<Record<string, string>>;
+  readonly protocols?: readonly string[];
+  /** The `origin` header (a browser's). Default: none. */
+  readonly origin?: string;
+  readonly cookies?: Readonly<Record<string, string>>;
+}
+/** Options of {@link connectWebSocket}. */
+interface ConnectWebSocketOptions {
+  /** Handshake headers (Node.js and Bun clients accept them; browsers cannot set any). */
+  readonly headers?: Readonly<Record<string, string>>;
+  readonly protocols?: readonly string[];
+  /** Default: 2 000 ms. */
+  readonly timeoutMs?: number;
+}
+/** What `TestApp.connect()` expects from the plugin named `'websocket'`. */
+interface WebSocketConnector {
+  connect(path: string, options?: TestWsConnectOptions): Promise<TestWsClient>;
+}
+/**
+ * A refused handshake (`status`, `headers`, `body`, `json()`). `instanceof` also matches the
+ * `WsHandshakeError` of `@znight/websocket` (what `TestApp.connect()` rejects with).
+ */
+export declare class WsHandshakeError extends Error {
+  readonly status: number;
+  readonly headers: Readonly<Record<string, string | string[]>>;
+  readonly body: string;
+  constructor(status: number, headers?: Readonly<Record<string, string | string[]>>, body?: string);
+  static override [Symbol.hasInstance](value: unknown): boolean;
+  /** The body parsed as JSON. */
+  json<T = unknown>(): T;
+}
+/** The failure reply of a request (`code`, `message`, `details`); matches `@znight/websocket`'s too. */
+export declare class WsRequestError extends Error {
+  readonly code: string;
+  readonly details: unknown;
+  constructor(code: string, message: string, details?: unknown);
+  static override [Symbol.hasInstance](value: unknown): boolean;
+}
+/**
+ * Connects to a WebSocket server over the network (end-to-end tests, Node.js and Bun) and returns
+ * a {@link TestWsClient}. Rejects with a {@link WsHandshakeError} (`status: 0`: the client cannot
+ * read the status of a refused handshake) when the connection fails.
+ *
+ * ```ts
+ * await using client = await connectWebSocket(`ws://127.0.0.1:${port}/chat`, { headers: { 'x-api-key': KEY } })
+ * ```
+ */
+export declare function connectWebSocket(url: string, options?: ConnectWebSocketOptions): Promise<TestWsClient>;
+/** Name of the WebSocket plugin `TestApp.connect()` delegates to (`WebSocketPlugin` from `@znight/websocket`). */
+export declare const WEBSOCKET_PLUGIN_NAME = "websocket";
 /** Name of the HTTP plugin `TestApp.inject()` delegates to (`HttpPlugin.configure()` from `@znight/http`). */
 export declare const HTTP_PLUGIN_NAME = "http";
 /** An in-memory HTTP request for {@link TestApp.inject}. */
@@ -589,6 +675,20 @@ export declare class TestApp implements AsyncDisposable {
    * @throws ZnightError ZNIGHT001 when the application has no HTTP plugin, ZNIGHT021 once closed.
    */
   inject(request: InjectRequest): Promise<InjectResponse>;
+  /**
+   * Opens an in-memory WebSocket connection through the WebSocket plugin (`WebSocketPlugin` of
+   * `@znight/websocket`): the real handshake through the HTTP pipeline (guards, origin and
+   * subprotocol checks), then an in-memory transport. `path` is the URL path, HTTP prefix included.
+   * Rejects with a `WsHandshakeError` when the handshake is refused.
+   *
+   * ```ts
+   * await using alice = await app.connect('/chat', { protocols: ['chat.v1'] })
+   * expect(await alice.request('room.join', { room: 'general' })).toEqual({ members: 1 })
+   * ```
+   *
+   * @throws ZnightError ZNIGHT001 when the application has no WebSocket plugin, ZNIGHT021 once closed.
+   */
+  connect(path: string, options?: TestWsConnectOptions): Promise<TestWsClient>;
   /**
    * Dispatches a request in memory and resolves at the response headers; the body is read as it is
    * produced (`response.body`). Cancelling the body (or aborting `signal`) disconnects the client.
@@ -693,5 +793,5 @@ export declare class TestBed {
   static create<T>(target: ProviderClass<T> | ClassKey<T>, options: TestBedOptions): Promise<TestBedResult<T>>;
   static create<T = unknown>(target: TypedToken<T>, options: TestBedOptions): Promise<TestBedResult<T>>;
 }
-export type { AnyFunction, AopMode, ConfigProperties, ConfigValues, CreateMetadataOptions, CreateMockOptions, DeepMock, DeepMockFunction, HttpInjectResult, HttpInjector, HttpStreamInjector, InjectRequest, InjectResponse, InjectSseResponse, InjectStreamRequest, InjectStreamResponse, MockFnFactory, MockFnOption, MockFnSource, MockFunction, MockRegistry, MockResult, MockState, Mocked, MockedMember, OverrideDefinitionEntry, OverrideEntry, OverrideFactoryOptions, PluginInitRoots, ResolvedMockFn, SetCookieInfo, SseMessage, TestAppOptions, TestBedOptions, TestBedResult, TestDependency, TestKey, TestMetadataSpec, TestProvider, UntypedFunction };
+export type { AnyFunction, AopMode, ConfigProperties, ConfigValues, ConnectWebSocketOptions, CreateMetadataOptions, CreateMockOptions, DeepMock, DeepMockFunction, HttpInjectResult, HttpInjector, HttpStreamInjector, InjectRequest, InjectResponse, InjectSseResponse, InjectStreamRequest, InjectStreamResponse, MockFnFactory, MockFnOption, MockFnSource, MockFunction, MockRegistry, MockResult, MockState, Mocked, MockedMember, OverrideDefinitionEntry, OverrideEntry, OverrideFactoryOptions, PluginInitRoots, ResolvedMockFn, SetCookieInfo, SseMessage, TestAppOptions, TestBedOptions, TestBedResult, TestDependency, TestKey, TestMetadataSpec, TestProvider, TestWsClient, TestWsCloseInfo, TestWsConnectOptions, TestWsWaitOptions, UntypedFunction, WebSocketConnector };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -709,6 +709,19 @@ function readGraphQLRoots(metadata) {
 	}
 	return roots;
 }
+/**
+* Tokens a WebSocket application needs at boot (`extensions.websocket`, RFC 0003 §7.1): every
+* gateway, its handshake and message guards and the guards of its handlers.
+*/
+function readWebSocketRoots(metadata) {
+	const roots = [];
+	for (const gateway of arrayOf(extension(metadata, "websocket")?.["gateways"])) {
+		if (!isRecord(gateway) || typeof gateway["token"] !== "string") continue;
+		roots.push(gateway["token"], ...tokensOf(gateway["handshakeGuards"]), ...tokensOf(gateway["messageGuards"]));
+		for (const handler of arrayOf(gateway["handlers"])) if (isRecord(handler)) roots.push(...tokensOf(handler["guards"]));
+	}
+	return roots;
+}
 // src/metadata-index.ts
 /**
 * Read-only index over compiled metadata: provider definitions, aliases, externals and the key
@@ -827,6 +840,8 @@ function assertMetadata(metadata) {
 	if (metadata.version !== METADATA_VERSION) throw new ZnightError(ErrorCode.VersionMismatch, `Unsupported metadata version ${String(metadata.version)} (expected ${METADATA_VERSION})`, { hints: ["Regenerate the metadata with the @znight/compiler version matching @znight/testing"] });
 }
 // src/test-app.ts
+/** Name of the WebSocket plugin `TestApp.connect()` delegates to (`WebSocketPlugin` from `@znight/websocket`). */
+const WEBSOCKET_PLUGIN_NAME = "websocket";
 /** Name of the HTTP plugin `TestApp.inject()` delegates to (`HttpPlugin.configure()` from `@znight/http`). */
 const HTTP_PLUGIN_NAME = "http";
 /**
@@ -917,6 +932,30 @@ var TestApp = class TestApp {
 		}
 	}
 	/**
+	* Opens an in-memory WebSocket connection through the WebSocket plugin (`WebSocketPlugin` of
+	* `@znight/websocket`): the real handshake through the HTTP pipeline (guards, origin and
+	* subprotocol checks), then an in-memory transport. `path` is the URL path, HTTP prefix included.
+	* Rejects with a `WsHandshakeError` when the handshake is refused.
+	*
+	* ```ts
+	* await using alice = await app.connect('/chat', { protocols: ['chat.v1'] })
+	* expect(await alice.request('room.join', { room: 'general' })).toEqual({ members: 1 })
+	* ```
+	*
+	* @throws ZnightError ZNIGHT001 when the application has no WebSocket plugin, ZNIGHT021 once closed.
+	*/
+	connect(path, options) {
+		try {
+			if (this.#closed) throw new ZnightError(ErrorCode.LifecycleFailed, "TestApp.connect(): the application is closed");
+			if (typeof path !== "string") throw new TypeError("[znight] TestApp.connect() expects a path");
+			const plugin = this.app.getPlugin(WEBSOCKET_PLUGIN_NAME);
+			if (plugin === void 0 || typeof plugin.connect !== "function") throw new ZnightError(ErrorCode.MissingProvider, "TestApp.connect() requires the WebSocket plugin", { hints: ["Add WebSocketPlugin.configure() from @znight/websocket (and HttpPlugin) to TestApp.create({ plugins })"] });
+			return plugin.connect(path, options);
+		} catch (error) {
+			return Promise.reject(error);
+		}
+	}
+	/**
 	* Dispatches a request in memory and resolves at the response headers; the body is read as it is
 	* produced (`response.body`). Cancelling the body (or aborting `signal`) disconnects the client.
 	*
@@ -1011,7 +1050,8 @@ function initOptions(options, index, overrides) {
 			...readHttpRoots(metadata),
 			...readMessagingRoots(metadata),
 			...readScheduleRoots(metadata),
-			...readGraphQLRoots(metadata)
+			...readGraphQLRoots(metadata),
+			...readWebSocketRoots(metadata)
 		].filter((token) => index.isProvider(token));
 		if (roots.length === 0) return {};
 	} else {
@@ -1579,6 +1619,207 @@ var TestBed = class {
 		}
 	}
 };
-export { HTTP_PLUGIN_NAME, TestApp, TestBed, clearMock, createMetadata, createMock, createSpy, defineTestMetadata, detectMockFn, isBuiltinSpy, isMock, override, overrideFactory, resetMock, resolveMockFn, setDefaultMockFn, testToken };
+// src/websocket.ts
+/**
+* A refused handshake (`status`, `headers`, `body`, `json()`). `instanceof` also matches the
+* `WsHandshakeError` of `@znight/websocket` (what `TestApp.connect()` rejects with).
+*/
+var WsHandshakeError = class extends Error {
+	status;
+	headers;
+	body;
+	constructor(status, headers = {}, body = "") {
+		super(`The WebSocket handshake was refused with ${status}: ${body}`);
+		this.name = "WsHandshakeError";
+		this.status = status;
+		this.headers = headers;
+		this.body = body;
+	}
+	static [Symbol.hasInstance](value) {
+		return value instanceof Error && value.name === "WsHandshakeError" && typeof value.status === "number";
+	}
+	/** The body parsed as JSON. */
+	json() {
+		return JSON.parse(this.body);
+	}
+};
+/** The failure reply of a request (`code`, `message`, `details`); matches `@znight/websocket`'s too. */
+var WsRequestError = class extends Error {
+	code;
+	details;
+	constructor(code, message, details) {
+		super(message);
+		this.name = "WsRequestError";
+		this.code = code;
+		this.details = details;
+	}
+	static [Symbol.hasInstance](value) {
+		return value instanceof Error && value.name === "WsRequestError" && typeof value.code === "string";
+	}
+};
+function decode(frame) {
+	if (typeof frame !== "string") return void 0;
+	try {
+		const value = JSON.parse(frame);
+		return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+	} catch {
+		return;
+	}
+}
+/** A {@link TestWsClient} over a global `WebSocket`. */
+var NetworkClient = class {
+	#ws;
+	#entries = [];
+	#waiters = /* @__PURE__ */ new Set();
+	#closed = Promise.withResolvers();
+	#ended = false;
+	#nextId = 1;
+	constructor(ws) {
+		this.#ws = ws;
+		ws.addEventListener("message", (event) => {
+			const data = event.data;
+			this.#receive(typeof data === "string" ? data : new Uint8Array(data));
+		});
+		ws.addEventListener("close", (event) => {
+			this.#ended = true;
+			this.#closed.resolve({
+				code: event.code,
+				reason: event.reason
+			});
+		});
+	}
+	get protocol() {
+		return this.#ws.protocol;
+	}
+	get frames() {
+		return this.#entries.map((entry) => entry.envelope ?? entry.frame);
+	}
+	get closed() {
+		return this.#closed.promise;
+	}
+	send(event, data) {
+		this.#ws.send(JSON.stringify(data === void 0 ? { event } : {
+			event,
+			data
+		}));
+	}
+	request(event, data, options = {}) {
+		const id = this.#nextId++;
+		const reply = this.#wait((entry) => !entry.consumed && entry.envelope?.["id"] === id && entry.envelope["event"] === void 0, (entry, resolve, reject) => {
+			entry.consumed = true;
+			const envelope = entry.envelope;
+			const error = envelope["error"];
+			if (error === void 0) resolve(envelope["data"]);
+			else reject(new WsRequestError(typeof error["code"] === "string" ? error["code"] : "INTERNAL", typeof error["message"] === "string" ? error["message"] : `The request "${event}" failed`, error["details"]));
+		}, options.timeoutMs ?? 5e3, `the reply to "${event}" (id ${id})`);
+		this.#ws.send(JSON.stringify(data === void 0 ? {
+			event,
+			id
+		} : {
+			event,
+			data,
+			id
+		}));
+		return reply;
+	}
+	next(event, options = {}) {
+		return this.#wait((entry) => !entry.consumed && typeof entry.envelope?.["event"] === "string" && (event === void 0 || entry.envelope["event"] === event), (entry, resolve) => {
+			entry.consumed = true;
+			resolve(entry.envelope["data"]);
+		}, options.timeoutMs ?? 1e3, event === void 0 ? "a server event" : `the event "${event}"`);
+	}
+	sendRaw(frame) {
+		this.#ws.send(frame);
+	}
+	nextRaw(options = {}) {
+		return this.#wait((entry) => !entry.rawConsumed, (entry, resolve) => {
+			entry.rawConsumed = true;
+			resolve(entry.frame);
+		}, options.timeoutMs ?? 1e3, "a frame");
+	}
+	close(code = 1e3, reason = "") {
+		if (!this.#ended) this.#ws.close(code, reason);
+		return this.#closed.promise;
+	}
+	async [Symbol.asyncDispose]() {
+		await this.close();
+	}
+	#wait(match, take, timeoutMs, what) {
+		const { promise, resolve, reject } = Promise.withResolvers();
+		const found = this.#entries.find(match);
+		if (found !== void 0) {
+			take(found, resolve, reject);
+			return promise;
+		}
+		if (this.#ended) {
+			reject(/* @__PURE__ */ new Error(`The WebSocket connection is closed: no ${what} will arrive`));
+			return promise;
+		}
+		const timer = setTimeout(() => {
+			this.#waiters.delete(waiter);
+			reject(/* @__PURE__ */ new Error(`Timed out after ${timeoutMs} ms waiting for ${what}`));
+		}, timeoutMs);
+		const waiter = {
+			match,
+			take: (entry) => {
+				clearTimeout(timer);
+				take(entry, resolve, reject);
+			}
+		};
+		this.#waiters.add(waiter);
+		this.#closed.promise.then(() => {
+			if (!this.#waiters.delete(waiter)) return;
+			clearTimeout(timer);
+			reject(/* @__PURE__ */ new Error(`The WebSocket connection closed while waiting for ${what}`));
+		});
+		return promise;
+	}
+	#receive(frame) {
+		const entry = {
+			frame,
+			envelope: decode(frame),
+			consumed: false,
+			rawConsumed: false
+		};
+		this.#entries.push(entry);
+		for (const waiter of this.#waiters) {
+			if (!waiter.match(entry)) continue;
+			this.#waiters.delete(waiter);
+			waiter.take(entry);
+		}
+	}
+};
+/**
+* Connects to a WebSocket server over the network (end-to-end tests, Node.js and Bun) and returns
+* a {@link TestWsClient}. Rejects with a {@link WsHandshakeError} (`status: 0`: the client cannot
+* read the status of a refused handshake) when the connection fails.
+*
+* ```ts
+* await using client = await connectWebSocket(`ws://127.0.0.1:${port}/chat`, { headers: { 'x-api-key': KEY } })
+* ```
+*/
+function connectWebSocket(url, options = {}) {
+	const ws = new WebSocket(url, {
+		...options.headers === void 0 ? {} : { headers: options.headers },
+		...options.protocols === void 0 ? {} : { protocols: options.protocols }
+	});
+	ws.binaryType = "arraybuffer";
+	const client = new NetworkClient(ws);
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			ws.close();
+			reject(/* @__PURE__ */ new Error(`connectWebSocket(${url}): no handshake after ${options.timeoutMs ?? 2e3} ms`));
+		}, options.timeoutMs ?? 2e3);
+		ws.addEventListener("open", () => {
+			clearTimeout(timer);
+			resolve(client);
+		});
+		ws.addEventListener("error", () => {
+			clearTimeout(timer);
+			reject(new WsHandshakeError(0, {}, `connectWebSocket(${url}) failed`));
+		});
+	});
+}
+export { HTTP_PLUGIN_NAME, TestApp, TestBed, WEBSOCKET_PLUGIN_NAME, WsHandshakeError, WsRequestError, clearMock, connectWebSocket, createMetadata, createMock, createSpy, defineTestMetadata, detectMockFn, isBuiltinSpy, isMock, override, overrideFactory, resetMock, resolveMockFn, setDefaultMockFn, testToken };
 
 //# sourceMappingURL=index.mjs.map