@velajs/testing 0.5.0 → 0.5.1

package/dist/http/test-response.js

@@ -1,166 +0,0 @@
-// Ported from @stratal/testing (MIT, © Temitayo Fadojutimi), minus Macroable —
-// vela has no Macroable, so TestResponse is a plain class.
-import { expect } from "vitest";
-import { getValueAtPath, hasValueAtPath } from "./path-utils.js";
-/**
- * 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);
- * ```
- */ export class TestResponse {
-    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;
-    }
-    // ============================================================
-    // Status assertions
-    // ============================================================
-    /** 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;
-    }
-    // ============================================================
-    // JSON assertions
-    // ============================================================
-    /** 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 json = await this.json();
-        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 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) {
-        const json = await this.json();
-        expect(hasValueAtPath(json, path), `Expected JSON path "${path}" to exist`).toBe(true);
-        return this;
-    }
-    /** Assert a path does not exist. */ async assertJsonPathMissing(path) {
-        const json = await this.json();
-        expect(hasValueAtPath(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 json = await this.json();
-        const value = getValueAtPath(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 json = await this.json();
-        const value = getValueAtPath(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 json = await this.json();
-        const value = getValueAtPath(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 json = await this.json();
-        const value = getValueAtPath(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;
-    }
-    // ============================================================
-    // Header assertions
-    // ============================================================
-    /** 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 !== undefined) {
-            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;
-    }
-}

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

@@ -1,46 +0,0 @@
-/** A parsed Server-Sent Event. */
-export interface TestSseEvent {
-    data: string;
-    event?: string;
-    id?: string;
-    retry?: number;
-}
-/**
- * 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();
- * ```
- */
-export declare class TestSseConnection {
-    private readonly response;
-    private readonly eventQueue;
-    private eventWaiters;
-    private streamEnded;
-    private endWaiters;
-    constructor(response: Response);
-    /** The raw `Response`. */
-    get raw(): Response;
-    /** Wait for the next event (rejects after `timeout` ms). */
-    waitForEvent(timeout?: number): Promise<TestSseEvent>;
-    /** Wait for the stream to end (rejects after `timeout` ms). */
-    waitForEnd(timeout?: number): Promise<void>;
-    /** Collect all remaining events until the stream ends. */
-    collectEvents(timeout?: number): Promise<TestSseEvent[]>;
-    /** Assert the next event matches the expected partial shape. */
-    assertEvent(expected: Partial<TestSseEvent>, timeout?: number): Promise<void>;
-    /** Assert the next event's `data` equals `expected`. */
-    assertEventData(expected: string, timeout?: number): Promise<void>;
-    /** Assert the next event's `data` is JSON equal to `expected`. */
-    assertJsonEventData<T>(expected: T, timeout?: number): Promise<void>;
-    private startReading;
-    private endStream;
-    private parseEvent;
-    private dispatchEvent;
-}

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

@@ -1,196 +0,0 @@
-// Ported near-verbatim from @stratal/testing (MIT, © Temitayo Fadojutimi).
-// Web-standard only (ReadableStream + TextDecoder), so it is edge-pure.
-import { expect } from "vitest";
-/**
- * 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();
- * ```
- */ export class TestSseConnection {
-    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 = 5000) {
-        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(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 = 5000) {
-        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(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 = 5000) {
-        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(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 = 5000) {
-        const event = await this.waitForEvent(timeout);
-        expect(event).toMatchObject(expected);
-    }
-    /** Assert the next event's `data` equals `expected`. */ async assertEventData(expected, timeout = 5000) {
-        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 = 5000) {
-        const event = await this.waitForEvent(timeout);
-        const parsed = JSON.parse(event.data);
-        expect(parsed).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();
-            }
-        };
-        void 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; // comment line
-            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 !== undefined) result.event = event;
-        if (id !== undefined) result.id = id;
-        if (retry !== undefined) result.retry = retry;
-        return result;
-    }
-    dispatchEvent(event) {
-        if (this.eventWaiters.length > 0) {
-            this.eventWaiters.shift()(event);
-        } else {
-            this.eventQueue.push(event);
-        }
-    }
-}

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

@@ -1,30 +0,0 @@
-import type { ActingAsResolver, TestPrincipal, TestingModule } from '../testing-module.js';
-import { TestSseConnection } from './test-sse-connection.js';
-/**
- * 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' });
- * ```
- */
-export declare class TestSseRequest {
-    private readonly path;
-    private readonly module;
-    private readonly requestHeaders;
-    private principal;
-    private resolver;
-    constructor(path: string, module: TestingModule);
-    /** Merge additional headers onto the SSE request. */
-    withHeaders(headers: Record<string, string>): this;
-    /** Authenticate the connection (see {@link TestHttpRequest.actingAs}). */
-    actingAs(principal: TestPrincipal, resolver?: ActingAsResolver): this;
-    /** Open the stream and return a live {@link TestSseConnection}. */
-    connect(): Promise<TestSseConnection>;
-    private applyAuthentication;
-}

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

@@ -1,62 +0,0 @@
-// Adapted from @stratal/testing (MIT, © Temitayo Fadojutimi). Auth uses the
-// generic resolver seam instead of a hard AuthService import.
-import { expect } from "vitest";
-import { TestSseConnection } from "./test-sse-connection.js";
-/**
- * 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' });
- * ```
- */ export class TestSseRequest {
-    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);
-        }
-    }
-}

package/dist/test.d.ts

@@ -1,5 +0,0 @@
-import type { ModuleOptions } from '@velajs/vela';
-import { TestingModuleBuilder } from './testing-module.builder.js';
-export declare const Test: {
-    createTestingModule(metadata: ModuleOptions): TestingModuleBuilder;
-};

package/dist/test.js

@@ -1,6 +0,0 @@
-import { TestingModuleBuilder } from "./testing-module.builder.js";
-export const Test = {
-    createTestingModule (metadata) {
-        return new TestingModuleBuilder(metadata);
-    }
-};

package/dist/testing-module.builder.d.ts

@@ -1,25 +0,0 @@
-import { type ModuleOptions, type Token, type Type } from '@velajs/vela';
-import { TestingModule } from './testing-module.js';
-export declare class OverrideBy {
-    private readonly builder;
-    private readonly token;
-    constructor(builder: TestingModuleBuilder, token: Token);
-    useValue(value: unknown): TestingModuleBuilder;
-    useClass(cls: Type): TestingModuleBuilder;
-    useFactory(options: {
-        factory: (...args: unknown[]) => unknown;
-        inject?: Token[];
-    }): TestingModuleBuilder;
-}
-export declare class TestingModuleBuilder {
-    private readonly metadata;
-    private overrides;
-    constructor(metadata: ModuleOptions);
-    overrideProvider(token: Token): OverrideBy;
-    overrideGuard(guard: Type): OverrideBy;
-    overridePipe(pipe: Type): OverrideBy;
-    overrideInterceptor(interceptor: Type): OverrideBy;
-    overrideFilter(filter: Type): OverrideBy;
-    private addOverride;
-    compile(): Promise<TestingModule>;
-}