@velajs/testing 0.5.0 → 0.5.1

package/dist/testing-module.builder.js

@@ -1,160 +0,0 @@
-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, bindAppProviders } from "@velajs/vela/internal";
-import { TestingModule } from "./testing-module.js";
-export class OverrideBy {
-    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;
-    }
-}
-export class TestingModuleBuilder {
-    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() {
-        let TestRootModule = 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();
-        // Replicate bootstrap()'s global token setup so request-pipeline tests
-        // can resolve REQUEST_CONTEXT, ModuleRef, and the APP_* sentinel tokens
-        // from any module scope. Without this, guards / decorators that inject
-        // REQUEST_CONTEXT through ExecutionContext fail with "no provider"
-        // when the request enters the pipeline. See vela/src/factory/bootstrap.ts.
-        container.register({
-            provide: Container,
-            useValue: container
-        });
-        container.markGlobalToken(Container);
-        container.register({
-            provide: ModuleRef,
-            useFactory: (c)=>new ModuleRef(c),
-            inject: [
-                Container
-            ]
-        });
-        container.markGlobalToken(ModuleRef);
-        // Decorator-driven discovery — global so any provider can inject it, and so
-        // callOnApplicationBootstrap() reuses this instance instead of self-building
-        // one. Mirrors vela/src/factory/bootstrap.ts.
-        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);
-        }
-        // REQUEST_CONTEXT is seeded into each per-request child container by
-        // RouteManager via setRequestInstance. Registering with a throw-factory
-        // here ensures findRegistration succeeds (so the child's cached request
-        // instance is returned) while surfacing a clear error if the token is
-        // ever resolved outside the request path.
-        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);
-        // Pre-register at root so `moduleRef.get(token)` and framework-internal
-        // resolves (instantiate(guard, container) with no requestingModuleId) see
-        // the override immediately.
-        for (const override of this.overrides){
-            container.register(override.provider);
-        }
-        const routeManager = new RouteManager(container);
-        const loader = new ModuleLoader(container, routeManager);
-        loader.load(TestRootModule);
-        // Force-apply overrides into every module bucket that already holds the
-        // token (plus root). Without this, controller constructor-injection (which
-        // passes requestingModuleId to findRegistration) finds the module's own
-        // registration first and never consults the root override. The default
-        // 'all-existing' buckets replace every non-root bucket holding the token
-        // and re-register at root — the supported form of the old private loop.
-        for (const override of this.overrides){
-            container.replaceProvider(override.provider);
-        }
-        bindAppProviders(routeManager, container, loader);
-        const app = new VelaApplication(container, routeManager);
-        const instances = await loader.resolveAllInstances();
-        app.setInstances(instances);
-        await app.callOnModuleInit();
-        await app.callOnApplicationBootstrap();
-        await app.initRoutes();
-        return new TestingModule(app, container);
-    }
-}

package/dist/testing-module.d.ts

@@ -1,87 +0,0 @@
-import { type Token, type Type, type VelaApplication } from '@velajs/vela';
-import type { Container } from '@velajs/vela/internal';
-import { type ISeeder } from '@velajs/vela/seeder';
-import type { TestDatabase } from './db/test-database.js';
-import { TestHttpClient } from './http/test-http-client.js';
-import { TestSseRequest } from './sse/test-sse-request.js';
-import { TestWsRequest } from './ws/test-ws-request.js';
-/** A test principal — an opaque object the auth resolver turns into headers. */
-export type TestPrincipal = Record<string, unknown>;
-/**
- * Turns a principal into request headers (session cookie, bearer token, …).
- * The signature `(module, principal) => Promise<Headers>` is a cross-package
- * contract: sibling packages (e.g. `@velajs/better-auth/testing`) build a
- * resolver against it. Kept generic so `@velajs/testing` needs no auth deps.
- */
-export type ActingAsResolver = (module: TestingModule, principal: TestPrincipal) => Promise<Headers>;
-/**
- * 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());
- * ```
- */
-export declare class TestingModule {
-    private readonly app;
-    private readonly container;
-    private _http;
-    private honoApp;
-    private authResolver;
-    constructor(app: VelaApplication, container: Container);
-    /** Resolve a provider from the root container. */
-    get<T>(token: Token<T>): T;
-    /** Build (once) and return the underlying application. */
-    createApplication(): Promise<VelaApplication>;
-    /** Lazy fluent HTTP client bound to this module. */
-    get http(): TestHttpClient;
-    /** Start an SSE connection builder for `path`. */
-    sse(path: string): TestSseRequest;
-    /** Start a WebSocket connection builder for `path` (needs a transport adapter). */
-    ws(path: string): TestWsRequest;
-    /**
-     * Drive a `Request` through the full Hono pipeline. The Hono app is built
-     * once and reused across requests.
-     */
-    fetch(request: Request, env?: unknown, ctx?: unknown): Promise<Response>;
-    /**
-     * Register a default auth resolver used by `actingAs(principal)` when no
-     * resolver is passed explicitly.
-     */
-    setAuthResolver(resolver: ActingAsResolver): this;
-    /** The default auth resolver, if one was registered. */
-    getAuthResolver(): ActingAsResolver | null;
-    /**
-     * 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.
-     */
-    runInRequestScope<T>(callback: (container: Container) => T | Promise<T>): Promise<T>;
-    /**
-     * 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.
-     */
-    seed(...SeederClasses: Type<ISeeder>[]): Promise<void>;
-    /** Assert a row matching `where` exists in `table` (via a {@link TestDatabase}). */
-    assertDatabaseHas(db: TestDatabase, table: string, where: Record<string, unknown>): Promise<void>;
-    /** Assert no row matching `where` exists in `table`. */
-    assertDatabaseMissing(db: TestDatabase, table: string, where: Record<string, unknown>): Promise<void>;
-    /** Assert `table` has exactly `expected` rows. */
-    assertDatabaseCount(db: TestDatabase, table: string, expected: number): Promise<void>;
-    /** Dispose the application. */
-    close(signal?: string): Promise<void>;
-    private ensureHono;
-    /**
-     * 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.
-     */
-    private createMockRequestContext;
-}

package/dist/testing-module.js

@@ -1,141 +0,0 @@
-import { Context } from "hono";
-import { REQUEST_CONTEXT } from "@velajs/vela";
-import { SeederRegistry } from "@velajs/vela/seeder";
-import { expect } from "vitest";
-import { TestHttpClient } from "./http/test-http-client.js";
-import { TestSseRequest } from "./sse/test-sse-request.js";
-import { TestWsRequest } from "./ws/test-ws-request.js";
-/**
- * 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());
- * ```
- */ export class TestingModule {
-    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) {
-        const hono = await this.ensureHono();
-        return hono.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)=>{
-                const instance = child.resolve(SeederClass);
-                await instance.run();
-            });
-        }
-    }
-    /** Assert a row matching `where` exists in `table` (via a {@link TestDatabase}). */ async assertDatabaseHas(db, table, where) {
-        const exists = await db.has(table, where);
-        expect(exists, `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) {
-        const exists = await db.has(table, where);
-        expect(exists, `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 = new Map();
-        const request = new Request('http://localhost/');
-        const hono = new Context(request);
-        return {
-            id: crypto.randomUUID(),
-            receivedAt: new Date(),
-            request,
-            hono,
-            set (key, value) {
-                bag.set(key, value);
-            },
-            get (key) {
-                return bag.get(key);
-            },
-            has (key) {
-                return bag.has(key);
-            }
-        };
-    }
-}

package/dist/ws/test-ws-connection.d.ts

@@ -1,41 +0,0 @@
-/**
- * TestWsConnection
- *
- * Wraps a live `WebSocket` with queue-based wait/assert helpers. Transport is
- * supplied by the caller — the core harness never opens a socket itself (see
- * `@velajs/testing/websocket-node`).
- *
- * @example
- * ```ts
- * const ws = await module.ws('/ws/chat').connect();
- * ws.send('hi');
- * await ws.assertMessage('echo:hi');
- * ws.close();
- * ```
- */
-export declare class TestWsConnection {
-    private readonly ws;
-    private readonly cleanup?;
-    private readonly messageQueue;
-    private messageWaiters;
-    private closeEvent;
-    private closeWaiters;
-    constructor(ws: WebSocket, cleanup?: (() => void | Promise<void>) | undefined);
-    /** The raw `WebSocket`. */
-    get raw(): WebSocket;
-    /** Send a message. */
-    send(data: string | ArrayBufferLike | ArrayBufferView): void;
-    /** Close the connection. */
-    close(code?: number, reason?: string): void;
-    /** Wait for the next message (rejects after `timeout` ms). */
-    waitForMessage(timeout?: number): Promise<string | ArrayBuffer>;
-    /** Wait for the connection to close (rejects after `timeout` ms). */
-    waitForClose(timeout?: number): Promise<{
-        code?: number;
-        reason?: string;
-    }>;
-    /** Assert the next message equals `expected`. */
-    assertMessage(expected: string, timeout?: number): Promise<void>;
-    /** Assert the connection closes, optionally with `expectedCode`. */
-    assertClosed(expectedCode?: number, timeout?: number): Promise<void>;
-}

package/dist/ws/test-ws-connection.js

@@ -1,105 +0,0 @@
-// Ported from @stratal/testing (MIT, © Temitayo Fadojutimi). Web-standard
-// `WebSocket` wrapper; the optional `cleanup` hook lets a transport adapter
-// (e.g. websocket-node) tear down its server when the socket closes.
-import { expect } from "vitest";
-/**
- * TestWsConnection
- *
- * Wraps a live `WebSocket` with queue-based wait/assert helpers. Transport is
- * supplied by the caller — the core harness never opens a socket itself (see
- * `@velajs/testing/websocket-node`).
- *
- * @example
- * ```ts
- * const ws = await module.ws('/ws/chat').connect();
- * ws.send('hi');
- * await ws.assertMessage('echo:hi');
- * ws.close();
- * ```
- */ export class TestWsConnection {
-    ws;
-    cleanup;
-    messageQueue = [];
-    messageWaiters = [];
-    closeEvent = null;
-    closeWaiters = [];
-    constructor(ws, cleanup){
-        this.ws = ws;
-        this.cleanup = cleanup;
-        this.ws.addEventListener('message', (event)=>{
-            const data = event.data;
-            if (this.messageWaiters.length > 0) {
-                this.messageWaiters.shift()(data);
-            } else {
-                this.messageQueue.push(data);
-            }
-        });
-        this.ws.addEventListener('close', (event)=>{
-            this.closeEvent = {
-                code: event.code,
-                reason: event.reason
-            };
-            for (const waiter of this.closeWaiters){
-                waiter(this.closeEvent);
-            }
-            this.closeWaiters = [];
-            void this.cleanup?.();
-        });
-    }
-    /** The raw `WebSocket`. */ get raw() {
-        return this.ws;
-    }
-    /** Send a message. */ send(data) {
-        // The runtime WebSocket.send accepts all of these; the cast bridges the
-        // slight type differences between DOM/undici and Bun's WebSocket typings.
-        this.ws.send(data);
-    }
-    /** Close the connection. */ close(code, reason) {
-        this.ws.close(code, reason);
-    }
-    /** Wait for the next message (rejects after `timeout` ms). */ async waitForMessage(timeout = 5000) {
-        if (this.messageQueue.length > 0) {
-            return this.messageQueue.shift();
-        }
-        return new Promise((resolve, reject)=>{
-            const waiter = (data)=>{
-                clearTimeout(timer);
-                resolve(data);
-            };
-            const timer = setTimeout(()=>{
-                const index = this.messageWaiters.indexOf(waiter);
-                if (index !== -1) this.messageWaiters.splice(index, 1);
-                reject(new Error(`WebSocket: no message received within ${timeout}ms`));
-            }, timeout);
-            this.messageWaiters.push(waiter);
-        });
-    }
-    /** Wait for the connection to close (rejects after `timeout` ms). */ async waitForClose(timeout = 5000) {
-        if (this.closeEvent) {
-            return this.closeEvent;
-        }
-        return new Promise((resolve, reject)=>{
-            const waiter = (event)=>{
-                clearTimeout(timer);
-                resolve(event);
-            };
-            const timer = setTimeout(()=>{
-                const index = this.closeWaiters.indexOf(waiter);
-                if (index !== -1) this.closeWaiters.splice(index, 1);
-                reject(new Error(`WebSocket: connection did not close within ${timeout}ms`));
-            }, timeout);
-            this.closeWaiters.push(waiter);
-        });
-    }
-    /** Assert the next message equals `expected`. */ async assertMessage(expected, timeout = 5000) {
-        const data = await this.waitForMessage(timeout);
-        const message = typeof data === 'string' ? data : '[ArrayBuffer]';
-        expect(message, `Expected WebSocket message "${expected}", got "${message}"`).toBe(expected);
-    }
-    /** Assert the connection closes, optionally with `expectedCode`. */ async assertClosed(expectedCode, timeout = 5000) {
-        const event = await this.waitForClose(timeout);
-        if (expectedCode !== undefined) {
-            expect(event.code, `Expected close code ${expectedCode}, got ${event.code}`).toBe(expectedCode);
-        }
-    }
-}

package/dist/ws/test-ws-request.d.ts

@@ -1,43 +0,0 @@
-import type { ActingAsResolver, TestPrincipal, TestingModule } from '../testing-module.js';
-import type { TestWsConnection } from './test-ws-connection.js';
-/**
- * A transport adapter that performs the WebSocket upgrade and returns a live
- * connection. Registered by a platform package (e.g. websocket-node).
- */
-export type WsConnector = (module: TestingModule, path: string, headers: Headers) => Promise<TestWsConnection>;
-/**
- * Register the transport that {@link TestWsRequest.connect} uses. Called by a
- * platform adapter's side-effect import (e.g. `@velajs/testing/websocket-node`).
- */
-export declare function registerWsConnector(connector: WsConnector): void;
-/** The currently registered WebSocket connector, if any. */
-export declare function getWsConnector(): WsConnector | null;
-/**
- * TestWsRequest
- *
- * Builder for a WebSocket connection. `connect()` requires a transport adapter
- * to be registered; without one it throws a clear, actionable error.
- *
- * @example
- * ```ts
- * import '@velajs/testing/websocket-node';
- * const ws = await module.ws('/ws/chat').connect();
- * ws.send('hi');
- * await ws.assertMessage('echo:hi');
- * ```
- */
-export declare class TestWsRequest {
-    private readonly path;
-    private readonly module;
-    private readonly requestHeaders;
-    private principal;
-    private resolver;
-    constructor(path: string, module: TestingModule);
-    /** Merge additional headers onto the upgrade request. */
-    withHeaders(headers: Record<string, string>): this;
-    /** Authenticate the connection (see {@link TestHttpRequest.actingAs}). */
-    actingAs(principal: TestPrincipal, resolver?: ActingAsResolver): this;
-    /** Open the socket via the registered transport adapter. */
-    connect(): Promise<TestWsConnection>;
-    private applyAuthentication;
-}

package/dist/ws/test-ws-request.js

@@ -1,69 +0,0 @@
-// Adapted from @stratal/testing (MIT, © Temitayo Fadojutimi). Vela's WebSocket
-// transport is pluggable and NOT reachable through a plain in-memory fetch, so
-// the actual upgrade is delegated to a registered connector — provided by
-// `@velajs/testing/websocket-node` for Node. The core harness never promises a
-// universal `connect()`.
-let registeredConnector = null;
-/**
- * Register the transport that {@link TestWsRequest.connect} uses. Called by a
- * platform adapter's side-effect import (e.g. `@velajs/testing/websocket-node`).
- */ export function registerWsConnector(connector) {
-    registeredConnector = connector;
-}
-/** The currently registered WebSocket connector, if any. */ export function getWsConnector() {
-    return registeredConnector;
-}
-/**
- * TestWsRequest
- *
- * Builder for a WebSocket connection. `connect()` requires a transport adapter
- * to be registered; without one it throws a clear, actionable error.
- *
- * @example
- * ```ts
- * import '@velajs/testing/websocket-node';
- * const ws = await module.ws('/ws/chat').connect();
- * ws.send('hi');
- * await ws.assertMessage('echo:hi');
- * ```
- */ export class TestWsRequest {
-    path;
-    module;
-    requestHeaders = new Headers();
-    principal = null;
-    resolver = null;
-    constructor(path, module){
-        this.path = path;
-        this.module = module;
-    }
-    /** Merge additional headers onto the upgrade 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 socket via the registered transport adapter. */ async connect() {
-        const connector = getWsConnector();
-        if (!connector) {
-            throw new Error('WebSocket connect() requires a transport adapter. Import ' + '"@velajs/testing/websocket-node" (Node). Cloudflare Durable-Object ' + 'WebSockets are exercised via @velajs/cloudflare + the workerd pool, ' + 'not the core harness.');
-        }
-        await this.applyAuthentication();
-        return connector(this.module, this.path, this.requestHeaders);
-    }
-    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);
-        }
-    }
-}