@stacksjs/bun-router 0.0.14 → 0.0.15

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

@@ -0,0 +1,85 @@
+import type { EnhancedRequest } from '../types';
+import type { TestFile, TestRequestOptions } from './types';
+/**
+ * Creates a mock EnhancedRequest for testing
+ */
+export declare class TestRequestBuilder {
+    private request;
+    private url;
+    constructor(method: string, path: string, options?: TestRequestOptions);
+    private parseQuery;
+    private convertTestFiles;
+    private handleBody;
+    /**
+     * Set route parameters
+     */
+    params(params: Record<string, string>): TestRequestBuilder;
+    /**
+     * Set request headers
+     */
+    headers(headers: Record<string, string>): TestRequestBuilder;
+    /**
+     * Set authorization header
+     */
+    auth(token: string, type?: 'Bearer' | 'Basic'): TestRequestBuilder;
+    /**
+     * Set user context
+     */
+    user(user: any): TestRequestBuilder;
+    /**
+     * Set session data
+     */
+    session(session: any): TestRequestBuilder;
+    /**
+     * Set cookies
+     */
+    cookies(cookies: Record<string, string>): TestRequestBuilder;
+    /**
+     * Set context data
+     */
+    context(context: Record<string, any>): TestRequestBuilder;
+    /**
+     * Set JSON body
+     */
+    json(data: any): TestRequestBuilder;
+    /**
+     * Set form body
+     */
+    form(data: Record<string, any>): TestRequestBuilder;
+    /**
+     * Add uploaded files
+     */
+    files(files: TestFile[]): TestRequestBuilder;
+    /**
+     * Set IP address
+     */
+    ip(ip: string): TestRequestBuilder;
+    /**
+     * Set user agent
+     */
+    userAgent(userAgent: string): TestRequestBuilder;
+    /**
+     * Set CSRF token
+     */
+    csrf(token: string): TestRequestBuilder;
+    /**
+     * Build the final request object
+     */
+    build(): EnhancedRequest;
+}
+/**
+ * Helper functions for creating test requests
+ */
+export declare const testRequest: {
+    get: (path: string, options?: TestRequestOptions) => TestRequestBuilder;
+    post: (path: string, options?: TestRequestOptions) => TestRequestBuilder;
+    put: (path: string, options?: TestRequestOptions) => TestRequestBuilder;
+    patch: (path: string, options?: TestRequestOptions) => TestRequestBuilder;
+    delete: (path: string, options?: TestRequestOptions) => TestRequestBuilder;
+    options: (path: string, options?: TestRequestOptions) => TestRequestBuilder;
+    head: (path: string, options?: TestRequestOptions) => TestRequestBuilder;
+};
+/**
+ * Create a mock request with minimal setup
+ */
+export declare function createMockRequest(method?: string, path?: string, options?: TestRequestOptions): EnhancedRequest;

package/dist/testing/test-response.d.ts

@@ -0,0 +1,90 @@
+import type { TestResponse } from './types';
+/**
+ * Test response wrapper with assertion helpers
+ */
+export declare class TestResponseWrapper implements TestResponse {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: any;
+    text: string;
+    json: any;
+    cookies: Record<string, string>;
+    redirected: boolean;
+    url: string;
+    ok: boolean;
+    type: string;
+    private originalResponse;
+    constructor(response: Response, body?: any);
+    private parseHeaders;
+    private parseCookies;
+    /**
+     * Assert response status
+     */
+    expectStatus(status: number): TestResponseWrapper;
+    /**
+     * Assert response is successful (2xx)
+     */
+    expectSuccess(): TestResponseWrapper;
+    /**
+     * Assert response has specific header
+     */
+    expectHeader(name: string, value?: string): TestResponseWrapper;
+    /**
+     * Assert response body matches
+     */
+    expectBody(expectedBody: any): TestResponseWrapper;
+    /**
+     * Assert response JSON matches
+     */
+    expectJson(expectedJson: any): TestResponseWrapper;
+    /**
+     * Assert response JSON contains specific properties
+     */
+    expectJsonContains(properties: Record<string, any>): TestResponseWrapper;
+    /**
+     * Assert response has specific cookie
+     */
+    expectCookie(name: string, value?: string): TestResponseWrapper;
+    /**
+     * Assert response is a redirect
+     */
+    expectRedirect(url?: string): TestResponseWrapper;
+    /**
+     * Assert response contains validation errors
+     */
+    expectValidationError(field?: string, message?: string): TestResponseWrapper;
+    /**
+     * Assert response content type
+     */
+    expectContentType(contentType: string): TestResponseWrapper;
+    /**
+     * Assert response body contains text
+     */
+    expectBodyContains(text: string): TestResponseWrapper;
+    /**
+     * Assert response body matches regex
+     */
+    expectBodyMatches(pattern: RegExp): TestResponseWrapper;
+    /**
+     * Assert response JSON has specific structure
+     */
+    expectJsonStructure(structure: any): TestResponseWrapper;
+    private validateStructure;
+    /**
+     * Get the original Response object
+     */
+    getOriginalResponse(): Response;
+    /**
+     * Convert to JSON for easy inspection
+     */
+    toJSON(): any;
+}
+/**
+ * Create a test response from a Response object
+ */
+export declare function createTestResponse(response: Response): Promise<TestResponseWrapper>;
+/**
+ * Create a mock response for testing
+ */
+export declare function createMockResponse(status?: number, body?: any, headers?: Record<string, string>): TestResponseWrapper;

package/dist/testing/types.d.ts

@@ -0,0 +1,207 @@
+import type { EnhancedRequest, MiddlewareHandler } from '../types';
+/**
+ * Test client configuration options
+ */
+export interface TestClientConfig {
+    baseUrl?: string;
+    defaultHeaders?: Record<string, string>;
+    timeout?: number;
+    followRedirects?: boolean;
+    validateStatus?: (status: number) => boolean;
+}
+/**
+ * Test request options
+ */
+export interface TestRequestOptions {
+    headers?: Record<string, string>;
+    query?: Record<string, string | string[]>;
+    body?: any;
+    files?: TestFile[];
+    cookies?: Record<string, string>;
+    session?: any;
+    user?: any;
+    context?: Record<string, any>;
+    timeout?: number;
+    followRedirects?: boolean;
+}
+/**
+ * Test file for upload testing
+ */
+export interface TestFile {
+    fieldName: string;
+    filename: string;
+    content: string | ArrayBuffer | Uint8Array;
+    mimetype?: string;
+}
+/**
+ * Test response interface
+ */
+export interface TestResponse {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: any;
+    text: string;
+    json: any;
+    cookies: Record<string, string>;
+    redirected: boolean;
+    url: string;
+    ok: boolean;
+    type: string;
+}
+/**
+ * Middleware test context
+ */
+export interface MiddlewareTestContext {
+    request: EnhancedRequest;
+    response?: Response;
+    next: ReturnType<typeof import('bun:test').mock<() => Promise<Response | null>>>;
+    error?: Error;
+}
+/**
+ * Authentication test user
+ */
+export interface TestUser {
+    id: string | number;
+    email?: string;
+    username?: string;
+    roles?: string[];
+    permissions?: string[];
+    [key: string]: any;
+}
+/**
+ * JWT test options
+ */
+export interface JWTTestOptions {
+    secret?: string;
+    expiresIn?: string;
+    algorithm?: 'HS256' | 'HS384' | 'HS512' | 'RS256';
+    payload?: Record<string, any>;
+    headers?: Record<string, any>;
+}
+/**
+ * Session test options
+ */
+export interface SessionTestOptions {
+    sessionId?: string;
+    data?: Record<string, any>;
+    maxAge?: number;
+    secure?: boolean;
+    httpOnly?: boolean;
+}
+/**
+ * Model binding test options
+ */
+export interface ModelBindingTestOptions {
+    modelClass?: any;
+    routeKey?: string;
+    constraints?: Record<string, any>;
+    customResolver?: (value: string) => Promise<any>;
+}
+/**
+ * Performance test metrics
+ */
+export interface PerformanceMetrics {
+    responseTime: number;
+    memoryUsage: {
+        heapUsed: number;
+        heapTotal: number;
+        external: number;
+        rss: number;
+    };
+    cpuUsage: {
+        user: number;
+        system: number;
+    };
+    requestsPerSecond?: number;
+    concurrentRequests?: number;
+}
+/**
+ * Load test configuration
+ */
+export interface LoadTestConfig {
+    duration: number;
+    concurrency: number;
+    rampUp?: number;
+    rampDown?: number;
+    requestsPerSecond?: number;
+    maxRequests?: number;
+}
+/**
+ * WebSocket test message
+ */
+export interface WSTestMessage {
+    type: 'text' | 'binary';
+    data: string | ArrayBuffer | Uint8Array;
+    timestamp?: number;
+}
+/**
+ * WebSocket test client
+ */
+export interface WSTestClient {
+    send: (message: string | ArrayBuffer | Uint8Array) => void;
+    close: (code?: number, reason?: string) => void;
+    ping: (data?: Uint8Array) => void;
+    pong: (data?: Uint8Array) => void;
+    messages: WSTestMessage[];
+    isConnected: boolean;
+    readyState: number;
+}
+/**
+ * Test assertion helpers
+ */
+export interface TestAssertions {
+    toHaveStatus: (status: number) => void;
+    toHaveHeader: (name: string, value?: string) => void;
+    toHaveBody: (body: any) => void;
+    toHaveJson: (json: any) => void;
+    toHaveCookie: (name: string, value?: string) => void;
+    toBeRedirected: (url?: string) => void;
+    toHaveValidationError: (field?: string, message?: string) => void;
+    toBeAuthenticated: (user?: any) => void;
+    toBeUnauthenticated: () => void;
+    toHaveMiddleware: (middleware: string | MiddlewareHandler) => void;
+    toHaveModel: (model: any) => void;
+    toHaveUploadedFile: (fieldName: string, filename?: string) => void;
+    toRespondWithin: (milliseconds: number) => void;
+}
+/**
+ * Mock factory options
+ */
+export interface MockFactoryOptions {
+    count?: number;
+    overrides?: Record<string, any>;
+    relations?: Record<string, any>;
+}
+/**
+ * Database test helpers
+ */
+export interface DatabaseTestHelpers {
+    seed: (data: any[]) => Promise<void>;
+    truncate: (tables?: string[]) => Promise<void>;
+    factory: <T>(model: string, options?: MockFactoryOptions) => T[];
+    create: <T>(model: string, data?: Partial<T>) => Promise<T>;
+    transaction: <T>(callback: () => Promise<T>) => Promise<T>;
+}
+/**
+ * Test environment configuration
+ */
+export interface TestEnvironment {
+    database?: DatabaseTestHelpers;
+    cache?: {
+        clear: () => Promise<void>;
+        get: (key: string) => Promise<any>;
+        set: (key: string, value: any, ttl?: number) => Promise<void>;
+    };
+    storage?: {
+        clear: () => Promise<void>;
+        put: (path: string, content: string | ArrayBuffer) => Promise<void>;
+        get: (path: string) => Promise<string | ArrayBuffer | null>;
+        delete: (path: string) => Promise<void>;
+    };
+    queue?: {
+        clear: () => Promise<void>;
+        push: (job: any) => Promise<void>;
+        process: () => Promise<void>;
+    };
+}

package/dist/testing/websocket-testing.d.ts

@@ -0,0 +1,227 @@
+import type { ServerWebSocket } from 'bun';
+import type { WSTestClient, WSTestMessage } from './types';
+/**
+ * WebSocket testing utilities
+ */
+export declare class WebSocketTester {
+    private messages;
+    private isConnected;
+    private readyState;
+    private eventHandlers;
+    constructor();
+    private setupEventHandlers;
+    /**
+     * Simulate WebSocket connection
+     */
+    connect(): WebSocketTester;
+    /**
+     * Simulate WebSocket disconnection
+     */
+    disconnect(code?: number, reason?: string): WebSocketTester;
+    /**
+     * Simulate sending a message
+     */
+    send(data: string | ArrayBuffer | Uint8Array): WebSocketTester;
+    /**
+     * Simulate receiving a message
+     */
+    receive(data: string | ArrayBuffer | Uint8Array): WebSocketTester;
+    /**
+     * Simulate ping
+     */
+    ping(data?: Uint8Array): WebSocketTester;
+    /**
+     * Simulate pong
+     */
+    pong(data?: Uint8Array): WebSocketTester;
+    /**
+     * Add event listener
+     */
+    on(event: string, handler: (...args: any[]) => any): WebSocketTester;
+    /**
+     * Remove event listener
+     */
+    off(event: string, handler: (...args: any[]) => any): WebSocketTester;
+    /**
+     * Emit event
+     */
+    private emit;
+    /**
+     * Get all sent messages
+     */
+    getSentMessages(): WSTestMessage[];
+    /**
+     * Get messages of specific type
+     */
+    getMessagesByType(type: 'text' | 'binary'): WSTestMessage[];
+    /**
+     * Clear message history
+     */
+    clearMessages(): WebSocketTester;
+    /**
+     * Get connection state
+     */
+    getState(): {
+        isConnected: boolean;
+        readyState: number;
+    };
+    /**
+     * Create a test client interface
+     */
+    getTestClient(): WSTestClient;
+}
+/**
+ * Mock ServerWebSocket for testing
+ */
+export declare class MockServerWebSocket {
+    private tester;
+    private _data;
+    constructor(data?: any);
+    send(message: string | ArrayBuffer | Uint8Array): void;
+    close(code?: number, reason?: string): void;
+    ping(data?: Uint8Array): void;
+    pong(data?: Uint8Array): void;
+    publish(topic: string, message: string | ArrayBuffer | Uint8Array): void;
+    subscribe(_topic: string): void;
+    unsubscribe(_topic: string): void;
+    isSubscribed(_topic: string): boolean;
+    cork(callback: () => void): void;
+    get readyState(): number;
+    get data(): any;
+    set data(value: any);
+    getTester(): WebSocketTester;
+}
+/**
+ * WebSocket handler testing utilities
+ */
+export declare const wsHandlerMocks: {
+    /**
+     * Mock WebSocket open handler
+     */
+    onOpen: () => any;
+    /**
+     * Mock WebSocket message handler
+     */
+    onMessage: (response?: string | ArrayBuffer | Uint8Array) => any;
+    /**
+     * Mock WebSocket close handler
+     */
+    onClose: () => any;
+    /**
+     * Mock WebSocket error handler
+     */
+    onError: () => any;
+    /**
+     * Mock echo handler
+     */
+    echo: () => any;
+    /**
+     * Mock broadcast handler
+     */
+    broadcast: (clients: ServerWebSocket<any>[]) => any;
+    /**
+     * Mock chat room handler
+     */
+    chatRoom: (room: string) => any;
+};
+/**
+ * WebSocket test scenarios
+ */
+export declare const wsTestScenarios: {
+    /**
+     * Test basic connection and message exchange
+     */
+    basicConnection: () => WebSocketTester;
+    /**
+     * Test connection failure
+     */
+    connectionFailure: () => WebSocketTester;
+    /**
+     * Test message broadcasting
+     */
+    messageBroadcast: (clientCount?: number) => WebSocketTester[];
+    /**
+     * Test ping/pong mechanism
+     */
+    pingPong: () => WebSocketTester;
+    /**
+     * Test connection timeout
+     */
+    connectionTimeout: () => WebSocketTester;
+};
+/**
+ * WebSocket assertion helpers
+ */
+export declare const wsAssertions: {
+    /**
+     * Assert WebSocket is connected
+     */
+    isConnected: (tester: WebSocketTester) => void;
+    /**
+     * Assert WebSocket is disconnected
+     */
+    isDisconnected: (tester: WebSocketTester) => void;
+    /**
+     * Assert message was sent
+     */
+    messageSent: (tester: WebSocketTester, expectedMessage: string | ArrayBuffer | Uint8Array) => void;
+    /**
+     * Assert number of messages sent
+     */
+    messageCount: (tester: WebSocketTester, expectedCount: number) => void;
+    /**
+     * Assert message type
+     */
+    messageType: (tester: WebSocketTester, index: number, expectedType: "text" | "binary") => void;
+    /**
+     * Assert ready state
+     */
+    readyState: (tester: WebSocketTester, expectedState: number) => void;
+};
+/**
+ * WebSocket performance testing
+ */
+export declare const wsPerformance: {
+    /**
+     * Test message throughput
+     */
+    testThroughput: (messageCount?: number, messageSize?: number) => Promise<{
+        messagesPerSecond: number;
+        totalTime: number;
+        averageLatency: number;
+    }>;
+    /**
+     * Test concurrent connections
+     */
+    testConcurrentConnections: (connectionCount?: number) => Promise<{
+        successfulConnections: number;
+        failedConnections: number;
+        averageConnectionTime: number;
+    }>;
+};
+/**
+ * Factory functions
+ */
+export declare function createWebSocketTester(): WebSocketTester;
+export declare function createMockServerWebSocket(data?: any): MockServerWebSocket;
+/**
+ * WebSocket test utilities
+ */
+export declare const wsTestUtils: {
+    /**
+     * Create multiple connected clients
+     */
+    createClients: (count: number) => WebSocketTester[];
+    /**
+     * Simulate network latency
+     */
+    withLatency: (tester: WebSocketTester, latencyMs: number) => WebSocketTester;
+    /**
+     * Simulate packet loss
+     */
+    withPacketLoss: (tester: WebSocketTester, lossRate: number) => WebSocketTester;
+    /**
+     * Create message generator
+     */
+    messageGenerator(count: number, prefix?: string): Generator<string>;
+};