@stacksjs/bun-router 0.0.16 → 0.0.18

package/src/testing/test-response.ts

@@ -1,332 +0,0 @@
-import type { TestResponse } from './types'
-
-/**
- * Test response wrapper with assertion helpers
- */
-export class TestResponseWrapper implements TestResponse {
-  public status: number
-  public statusText: string
-  public headers: Record<string, string>
-  public body: any
-  public text: string
-  public json: any
-  public cookies: Record<string, string>
-  public redirected: boolean
-  public url: string
-  public ok: boolean
-  public type: string
-
-  private originalResponse: Response
-
-  constructor(response: Response, body?: any) {
-    this.originalResponse = response
-    this.status = response.status
-    this.statusText = response.statusText
-    this.headers = this.parseHeaders(response.headers)
-    this.cookies = this.parseCookies(response.headers.get('set-cookie'))
-    this.redirected = response.redirected
-    this.url = response.url
-    this.ok = response.ok
-    this.type = response.type
-    this.body = body
-    this.text = typeof body === 'string' ? body : JSON.stringify(body)
-
-    try {
-      this.json = typeof body === 'string' ? JSON.parse(body) : body
-    }
-    catch {
-      this.json = null
-    }
-  }
-
-  private parseHeaders(headers: Headers): Record<string, string> {
-    const result: Record<string, string> = {}
-    headers.forEach((value, key) => {
-      result[key.toLowerCase()] = value
-    })
-    return result
-  }
-
-  private parseCookies(cookieHeader: string | null): Record<string, string> {
-    if (!cookieHeader)
-      return {}
-
-    const cookies: Record<string, string> = {}
-    cookieHeader.split(',').forEach((cookie) => {
-      const [nameValue] = cookie.trim().split(';')
-      const [name, value] = nameValue.split('=')
-      if (name && value) {
-        cookies[name.trim()] = value.trim()
-      }
-    })
-    return cookies
-  }
-
-  /**
-   * Assert response status
-   */
-  expectStatus(status: number): TestResponseWrapper {
-    if (this.status !== status) {
-      throw new Error(`Expected status ${status}, got ${this.status}`)
-    }
-    return this
-  }
-
-  /**
-   * Assert response is successful (2xx)
-   */
-  expectSuccess(): TestResponseWrapper {
-    if (!this.ok) {
-      throw new Error(`Expected successful response, got ${this.status}`)
-    }
-    return this
-  }
-
-  /**
-   * Assert response has specific header
-   */
-  expectHeader(name: string, value?: string): TestResponseWrapper {
-    const headerValue = this.headers[name.toLowerCase()]
-    if (headerValue === undefined) {
-      throw new Error(`Expected header '${name}' to be present`)
-    }
-    if (value !== undefined && headerValue !== value) {
-      throw new Error(`Expected header '${name}' to be '${value}', got '${headerValue}'`)
-    }
-    return this
-  }
-
-  /**
-   * Assert response body matches
-   */
-  expectBody(expectedBody: any): TestResponseWrapper {
-    if (typeof expectedBody === 'string') {
-      if (this.text !== expectedBody) {
-        throw new Error(`Expected body '${expectedBody}', got '${this.text}'`)
-      }
-    }
-    else {
-      if (JSON.stringify(this.json) !== JSON.stringify(expectedBody)) {
-        throw new Error(`Expected body ${JSON.stringify(expectedBody)}, got ${JSON.stringify(this.json)}`)
-      }
-    }
-    return this
-  }
-
-  /**
-   * Assert response JSON matches
-   */
-  expectJson(expectedJson: any): TestResponseWrapper {
-    if (JSON.stringify(this.json) !== JSON.stringify(expectedJson)) {
-      throw new Error(`Expected JSON ${JSON.stringify(expectedJson)}, got ${JSON.stringify(this.json)}`)
-    }
-    return this
-  }
-
-  /**
-   * Assert response JSON contains specific properties
-   */
-  expectJsonContains(properties: Record<string, any>): TestResponseWrapper {
-    if (typeof this.json !== 'object' || this.json === null) {
-      throw new Error('Response is not a JSON object')
-    }
-
-    Object.entries(properties).forEach(([key, expectedValue]) => {
-      const actualValue = this.json[key]
-
-      // Deep comparison for objects
-      if (typeof expectedValue === 'object' && expectedValue !== null
-        && typeof actualValue === 'object' && actualValue !== null) {
-        const expectedStr = JSON.stringify(expectedValue)
-        const actualStr = JSON.stringify(actualValue)
-        if (expectedStr !== actualStr) {
-          throw new Error(`Expected JSON property '${key}' to be ${expectedStr}, got ${actualStr}`)
-        }
-      }
-      else if (actualValue !== expectedValue) {
-        throw new Error(`Expected JSON property '${key}' to be '${expectedValue}', got '${actualValue}'`)
-      }
-    })
-
-    return this
-  }
-
-  /**
-   * Assert response has specific cookie
-   */
-  expectCookie(name: string, value?: string): TestResponseWrapper {
-    const cookieValue = this.cookies[name]
-    if (cookieValue === undefined) {
-      throw new Error(`Expected cookie '${name}' to be present`)
-    }
-    if (value !== undefined && cookieValue !== value) {
-      throw new Error(`Expected cookie '${name}' to be '${value}', got '${cookieValue}'`)
-    }
-    return this
-  }
-
-  /**
-   * Assert response is a redirect
-   */
-  expectRedirect(url?: string): TestResponseWrapper {
-    if (this.status < 300 || this.status >= 400) {
-      throw new Error(`Expected redirect status (3xx), got ${this.status}`)
-    }
-    if (url) {
-      const location = this.headers.location
-      if (location !== url) {
-        throw new Error(`Expected redirect to '${url}', got '${location}'`)
-      }
-    }
-    return this
-  }
-
-  /**
-   * Assert response contains validation errors
-   */
-  expectValidationError(field?: string, message?: string): TestResponseWrapper {
-    if (this.status !== 422) {
-      throw new Error(`Expected validation error status (422), got ${this.status}`)
-    }
-
-    if (field) {
-      const errors = this.json?.errors || this.json?.message
-      if (!errors || !errors[field]) {
-        throw new Error(`Expected validation error for field '${field}'`)
-      }
-
-      if (message) {
-        const fieldErrors = Array.isArray(errors[field]) ? errors[field] : [errors[field]]
-        if (!fieldErrors.includes(message)) {
-          throw new Error(`Expected validation error message '${message}' for field '${field}'`)
-        }
-      }
-    }
-    return this
-  }
-
-  /**
-   * Assert response content type
-   */
-  expectContentType(contentType: string): TestResponseWrapper {
-    const actualContentType = this.headers['content-type']
-    if (!actualContentType || !actualContentType.includes(contentType)) {
-      throw new Error(`Expected content type '${contentType}', got '${actualContentType}'`)
-    }
-    return this
-  }
-
-  /**
-   * Assert response body contains text
-   */
-  expectBodyContains(text: string): TestResponseWrapper {
-    if (!this.text.includes(text)) {
-      throw new Error(`Expected body to contain '${text}'`)
-    }
-    return this
-  }
-
-  /**
-   * Assert response body matches regex
-   */
-  expectBodyMatches(pattern: RegExp): TestResponseWrapper {
-    if (!pattern.test(this.text)) {
-      throw new Error(`Expected body to match pattern ${pattern}`)
-    }
-    return this
-  }
-
-  /**
-   * Assert response JSON has specific structure
-   */
-  expectJsonStructure(structure: any): TestResponseWrapper {
-    this.validateStructure(this.json, structure, 'root')
-    return this
-  }
-
-  private validateStructure(data: any, structure: any, path: string): void {
-    // Handle expect.any() matchers - they have a $$typeof property
-    if (structure && typeof structure === 'object' && structure.$$typeof) {
-      // This is an expect.any() matcher, skip validation
-      return
-    }
-
-    if (Array.isArray(structure)) {
-      if (!Array.isArray(data)) {
-        throw new TypeError(`Expected ${path} to be an array`)
-      }
-      if (structure.length > 0 && data.length > 0) {
-        this.validateStructure(data[0], structure[0], `${path}[0]`)
-      }
-    }
-    else if (typeof structure === 'object' && structure !== null) {
-      if (typeof data !== 'object' || data === null) {
-        throw new Error(`Expected ${path} to be an object`)
-      }
-      Object.keys(structure).forEach((key) => {
-        if (!(key in data)) {
-          throw new Error(`Expected ${path} to have property '${key}'`)
-        }
-        this.validateStructure(data[key], structure[key], `${path}.${key}`)
-      })
-    }
-  }
-
-  /**
-   * Get the original Response object
-   */
-  getOriginalResponse(): Response {
-    return this.originalResponse
-  }
-
-  /**
-   * Convert to JSON for easy inspection
-   */
-  toJSON(): any {
-    return {
-      status: this.status,
-      statusText: this.statusText,
-      headers: this.headers,
-      body: this.body,
-      json: this.json,
-      cookies: this.cookies,
-      redirected: this.redirected,
-      url: this.url,
-      ok: this.ok,
-      type: this.type,
-    }
-  }
-}
-
-/**
- * Create a test response from a Response object
- */
-export async function createTestResponse(response: Response): Promise<TestResponseWrapper> {
-  const body = await response.text()
-  return new TestResponseWrapper(response, body)
-}
-
-/**
- * Create a mock response for testing
- */
-export function createMockResponse(
-  status: number = 200,
-  body?: any,
-  headers?: Record<string, string>,
-): TestResponseWrapper {
-  const responseHeaders = new Headers(headers)
-
-  if (body && typeof body === 'object' && !responseHeaders.has('content-type')) {
-    responseHeaders.set('content-type', 'application/json')
-  }
-
-  const response = new Response(
-    body ? (typeof body === 'string' ? body : JSON.stringify(body)) : null,
-    {
-      status,
-      headers: responseHeaders,
-    },
-  )
-
-  return new TestResponseWrapper(response, body)
-}

package/src/testing/types.ts

@@ -1,224 +0,0 @@
-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>
-  }
-}