@stacksjs/bun-router 0.0.14 → 0.0.15

package/src/testing/test-client.ts

@@ -0,0 +1,310 @@
+import type { Router } from '../router/router'
+import type { EnhancedRequest } from '../types'
+import type { TestResponseWrapper } from './test-response'
+import type { TestClientConfig, TestRequestOptions } from './types'
+import { TestRequestBuilder } from './test-request'
+import { createTestResponse } from './test-response'
+
+/**
+ * Test client for making HTTP requests to router instances
+ */
+export class TestClient {
+  private router: Router
+  private config: TestClientConfig
+  private defaultHeaders: Record<string, string>
+
+  constructor(router: Router, config: TestClientConfig = {}) {
+    this.router = router
+    this.config = {
+      baseUrl: 'http://localhost:3000',
+      timeout: 5000,
+      followRedirects: true,
+      validateStatus: (status: number) => status >= 200 && status < 300,
+      ...config,
+    }
+    this.defaultHeaders = config.defaultHeaders || {}
+  }
+
+  /**
+   * Make a GET request
+   */
+  async get(path: string, options: TestRequestOptions = {}): Promise<TestResponseWrapper> {
+    return this.request('GET', path, options)
+  }
+
+  /**
+   * Make a POST request
+   */
+  async post(path: string, options: TestRequestOptions = {}): Promise<TestResponseWrapper> {
+    return this.request('POST', path, options)
+  }
+
+  /**
+   * Make a PUT request
+   */
+  async put(path: string, options: TestRequestOptions = {}): Promise<TestResponseWrapper> {
+    return this.request('PUT', path, options)
+  }
+
+  /**
+   * Make a PATCH request
+   */
+  async patch(path: string, options: TestRequestOptions = {}): Promise<TestResponseWrapper> {
+    return this.request('PATCH', path, options)
+  }
+
+  /**
+   * Make a DELETE request
+   */
+  async delete(path: string, options: TestRequestOptions = {}): Promise<TestResponseWrapper> {
+    return this.request('DELETE', path, options)
+  }
+
+  /**
+   * Make an OPTIONS request
+   */
+  async options(path: string, options: TestRequestOptions = {}): Promise<TestResponseWrapper> {
+    return this.request('OPTIONS', path, options)
+  }
+
+  /**
+   * Make a HEAD request
+   */
+  async head(path: string, options: TestRequestOptions = {}): Promise<TestResponseWrapper> {
+    return this.request('HEAD', path, options)
+  }
+
+  /**
+   * Make a request with custom method
+   */
+  async request(method: string, path: string, options: TestRequestOptions = {}): Promise<TestResponseWrapper> {
+    // Merge default headers
+    const headers = { ...this.defaultHeaders, ...options.headers }
+    const requestOptions = { ...options, headers }
+
+    // Build the test request
+    const request = new TestRequestBuilder(method, path, requestOptions).build()
+
+    try {
+      // Handle the request through the router
+      const response = await this.handleRequest(request)
+      return await createTestResponse(response)
+    }
+    catch (error) {
+      throw new Error(`Test request failed: ${error instanceof Error ? error.message : 'Unknown error'}`)
+    }
+  }
+
+  /**
+   * Handle request through the router
+   */
+  private async handleRequest(request: EnhancedRequest): Promise<Response> {
+    // Find matching route
+    const url = new URL(request.url)
+    const matchResult = this.findMatchingRoute(request.method, url.pathname)
+
+    if (!matchResult) {
+      return new Response('Not Found', { status: 404 })
+    }
+
+    const { route, params } = matchResult
+
+    // Update request with route params
+    request.params = { ...request.params, ...params }
+
+    try {
+      // Execute middleware chain
+      const response = await this.executeMiddlewareChain(request, route)
+      return response || new Response('No response', { status: 500 })
+    }
+    catch (error) {
+      return new Response(
+        JSON.stringify({ error: error instanceof Error ? error.message : 'Internal Server Error' }),
+        {
+          status: 500,
+          headers: { 'Content-Type': 'application/json' },
+        },
+      )
+    }
+  }
+
+  /**
+   * Find matching route for the request
+   */
+  private findMatchingRoute(method: string, pathname: string): { route: any, params: Record<string, string> } | null {
+    for (const route of this.router.routes) {
+      if (route.method.toLowerCase() !== method.toLowerCase()) {
+        continue
+      }
+
+      // Simple pattern matching for testing
+      const params = this.matchPath(route.path, pathname)
+      if (params !== null) {
+        return { route, params }
+      }
+    }
+    return null
+  }
+
+  /**
+   * Simple path matching with parameter extraction
+   */
+  private matchPath(pattern: string, pathname: string): Record<string, string> | null {
+    const patternParts = pattern.split('/')
+    const pathParts = pathname.split('/')
+
+    if (patternParts.length !== pathParts.length) {
+      return null
+    }
+
+    const params: Record<string, string> = {}
+
+    for (let i = 0; i < patternParts.length; i++) {
+      const patternPart = patternParts[i]
+      const pathPart = pathParts[i]
+
+      if (patternPart.startsWith(':')) {
+        // Parameter
+        const paramName = patternPart.slice(1)
+        params[paramName] = pathPart
+      }
+      else if (patternPart !== pathPart) {
+        // Literal mismatch
+        return null
+      }
+    }
+
+    return params
+  }
+
+  /**
+   * Execute middleware chain and route handler
+   */
+  private async executeMiddlewareChain(request: EnhancedRequest, route: any): Promise<Response> {
+    const middlewares = [...this.router.globalMiddleware, ...route.middleware]
+    let index = 0
+
+    const next = async (): Promise<Response | null> => {
+      if (index < middlewares.length) {
+        const middleware = middlewares[index++]
+        return await middleware(request, next)
+      }
+      else {
+        // Execute route handler
+        return await this.executeHandler(route.handler, request)
+      }
+    }
+
+    const result = await next()
+    return result || new Response('No response', { status: 500 })
+  }
+
+  /**
+   * Execute route handler
+   */
+  private async executeHandler(handler: any, request: EnhancedRequest): Promise<Response> {
+    if (typeof handler === 'function') {
+      return await handler(request)
+    }
+    else if (typeof handler === 'string') {
+      // Handle string-based handlers (would normally load from file)
+      throw new TypeError(`String handlers not supported in test environment: ${handler}`)
+    }
+    else if (typeof handler === 'object' && handler.handle) {
+      // Handle class-based handlers
+      const instance = new (handler as any)()
+      return await instance.handle(request)
+    }
+
+    throw new Error('Invalid handler type')
+  }
+
+  /**
+   * Set default headers for all requests
+   */
+  setDefaultHeaders(headers: Record<string, string>): TestClient {
+    this.defaultHeaders = { ...this.defaultHeaders, ...headers }
+    return this
+  }
+
+  /**
+   * Set authorization header for all requests
+   */
+  auth(token: string, type: 'Bearer' | 'Basic' = 'Bearer'): TestClient {
+    this.defaultHeaders.Authorization = `${type} ${token}`
+    return this
+  }
+
+  /**
+   * Set user agent for all requests
+   */
+  userAgent(userAgent: string): TestClient {
+    this.defaultHeaders['User-Agent'] = userAgent
+    return this
+  }
+
+  /**
+   * Create a new test client with additional configuration
+   */
+  withConfig(config: Partial<TestClientConfig>): TestClient {
+    return new TestClient(this.router, { ...this.config, ...config })
+  }
+
+  /**
+   * Create a new test client with additional headers
+   */
+  withHeaders(headers: Record<string, string>): TestClient {
+    return new TestClient(this.router, {
+      ...this.config,
+      defaultHeaders: { ...this.defaultHeaders, ...headers },
+    })
+  }
+
+  /**
+   * Get the router instance
+   */
+  getRouter(): Router {
+    return this.router
+  }
+
+  /**
+   * Get client configuration
+   */
+  getConfig(): TestClientConfig {
+    return { ...this.config }
+  }
+}
+
+/**
+ * Create a test client for a router
+ */
+export function createTestClient(router: Router, config?: TestClientConfig): TestClient {
+  return new TestClient(router, config)
+}
+
+/**
+ * Test client factory with fluent API
+ */
+export const testClient = {
+  /**
+   * Create a test client for a router
+   */
+  for: (router: Router, config?: TestClientConfig): TestClient => createTestClient(router, config),
+
+  /**
+   * Create a test client with specific configuration
+   */
+  withConfig: (config: TestClientConfig): (router: Router) => TestClient => (router: Router): TestClient => createTestClient(router, config),
+
+  /**
+   * Create a test client with authentication
+   */
+  withAuth: (token: string, type: 'Bearer' | 'Basic' = 'Bearer'): (router: Router) => TestClient => (router: Router): TestClient =>
+    createTestClient(router).auth(token, type),
+
+  /**
+   * Create a test client with custom headers
+   */
+  withHeaders: (headers: Record<string, string>): (router: Router) => TestClient => (router: Router): TestClient =>
+    createTestClient(router).withHeaders(headers),
+}

package/src/testing/test-request.ts

@@ -0,0 +1,315 @@
+import type { CookieAccessor, CookieOptions, EnhancedRequest, UploadedFile } from '../types'
+import type { TestFile, TestRequestOptions } from './types'
+
+/**
+ * Creates a CookieAccessor from a plain Record<string, string>
+ */
+function createCookieAccessor(cookies: Record<string, string>): CookieAccessor {
+  const cookieStore = { ...cookies }
+  return {
+    get: (name: string) => cookieStore[name],
+    set: (name: string, value: string, _options?: CookieOptions) => {
+      cookieStore[name] = value
+    },
+    delete: (name: string, _options?: CookieOptions) => {
+      delete cookieStore[name]
+    },
+    getAll: () => ({ ...cookieStore }),
+  }
+}
+
+/**
+ * Creates a mock EnhancedRequest for testing
+ */
+export class TestRequestBuilder {
+  private request: Partial<EnhancedRequest>
+  private url: URL
+
+  constructor(method: string, path: string, options: TestRequestOptions = {}) {
+    this.url = new URL(path, 'http://localhost:3000')
+
+    // Apply query parameters
+    if (options.query) {
+      Object.entries(options.query).forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+          value.forEach(v => this.url.searchParams.append(key, v))
+        }
+        else {
+          this.url.searchParams.set(key, value)
+        }
+      })
+    }
+
+    this.request = {
+      method,
+      url: this.url.toString(),
+      headers: new Headers(options.headers || {}),
+      params: {},
+      query: this.parseQuery(this.url.searchParams),
+      jsonBody: undefined,
+      formBody: options.body && typeof options.body === 'object' ? options.body : undefined,
+      files: options.files ? this.convertTestFiles(options.files) : undefined,
+      session: options.session,
+      user: options.user,
+      context: options.context || {},
+      requestId: `test-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      ip: '127.0.0.1',
+      userAgent: () => 'BunRouter-TestClient/1.0',
+      cookies: createCookieAccessor(options.cookies || {}),
+      startTime: Date.now(),
+      traceId: `trace-${Date.now()}`,
+      spanId: `span-${Date.now()}`,
+    }
+
+    // Handle body based on content type
+    this.handleBody(options.body)
+  }
+
+  private parseQuery(searchParams: URLSearchParams): Record<string, string | string[]> {
+    const query: Record<string, string | string[]> = {}
+
+    for (const [key, value] of searchParams.entries()) {
+      if (query[key]) {
+        if (Array.isArray(query[key])) {
+          (query[key] as string[]).push(value)
+        }
+        else {
+          query[key] = [query[key] as string, value]
+        }
+      }
+      else {
+        query[key] = value
+      }
+    }
+
+    return query
+  }
+
+  private convertTestFiles(testFiles: TestFile[]): UploadedFile[] {
+    return testFiles.map(file => ({
+      fieldName: file.fieldName,
+      originalName: file.filename,
+      filename: `test-${Date.now()}-${file.filename}`,
+      path: `/tmp/test-uploads/${file.filename}`,
+      size: file.content instanceof ArrayBuffer
+        ? file.content.byteLength
+        : new TextEncoder().encode(file.content.toString()).length,
+      mimetype: file.mimetype || 'application/octet-stream',
+      buffer: file.content instanceof ArrayBuffer
+        ? file.content
+        : new TextEncoder().encode(file.content.toString()).buffer as ArrayBuffer,
+    }))
+  }
+
+  private handleBody(body: any): void {
+    if (!body)
+      return
+
+    const contentType = this.request.headers?.get('content-type') || ''
+
+    if (contentType.includes('application/json') || typeof body === 'object') {
+      this.request.jsonBody = body
+      if (!this.request.headers?.has('content-type')) {
+        this.request.headers?.set('content-type', 'application/json')
+      }
+    }
+    else if (contentType.includes('application/x-www-form-urlencoded')) {
+      this.request.formBody = body
+    }
+  }
+
+  /**
+   * Set route parameters
+   */
+  params(params: Record<string, string>): TestRequestBuilder {
+    this.request.params = { ...this.request.params, ...params }
+    return this
+  }
+
+  /**
+   * Set request headers
+   */
+  headers(headers: Record<string, string>): TestRequestBuilder {
+    Object.entries(headers).forEach(([key, value]) => {
+      this.request.headers?.set(key, value)
+    })
+    return this
+  }
+
+  /**
+   * Set authorization header
+   */
+  auth(token: string, type: 'Bearer' | 'Basic' = 'Bearer'): TestRequestBuilder {
+    this.request.headers?.set('Authorization', `${type} ${token}`)
+    return this
+  }
+
+  /**
+   * Set user context
+   */
+  user(user: any): TestRequestBuilder {
+    this.request.user = user
+    return this
+  }
+
+  /**
+   * Set session data
+   */
+  session(session: any): TestRequestBuilder {
+    this.request.session = session
+    return this
+  }
+
+  /**
+   * Set cookies
+   */
+  cookies(cookies: Record<string, string>): TestRequestBuilder {
+    const existingCookies = this.request.cookies?.getAll() || {}
+    this.request.cookies = createCookieAccessor({ ...existingCookies, ...cookies })
+    return this
+  }
+
+  /**
+   * Set context data
+   */
+  context(context: Record<string, any>): TestRequestBuilder {
+    this.request.context = { ...this.request.context, ...context }
+    return this
+  }
+
+  /**
+   * Set JSON body
+   */
+  json(data: any): TestRequestBuilder {
+    this.request.jsonBody = data
+    this.request.headers?.set('content-type', 'application/json')
+    return this
+  }
+
+  /**
+   * Set form body
+   */
+  form(data: Record<string, any>): TestRequestBuilder {
+    this.request.formBody = data
+    this.request.headers?.set('content-type', 'application/x-www-form-urlencoded')
+    return this
+  }
+
+  /**
+   * Add uploaded files
+   */
+  files(files: TestFile[]): TestRequestBuilder {
+    this.request.files = this.convertTestFiles(files)
+    this.request.headers?.set('content-type', 'multipart/form-data')
+    return this
+  }
+
+  /**
+   * Set IP address
+   */
+  ip(ip: string): TestRequestBuilder {
+    this.request.ip = ip
+    return this
+  }
+
+  /**
+   * Set user agent
+   */
+  userAgent(userAgent: string): TestRequestBuilder {
+    this.request.userAgent = () => userAgent
+    this.request.headers?.set('User-Agent', userAgent)
+    return this
+  }
+
+  /**
+   * Set CSRF token
+   */
+  csrf(token: string): TestRequestBuilder {
+    this.request.csrfToken = token
+    this.request.headers?.set('X-CSRF-Token', token)
+    return this
+  }
+
+  /**
+   * Build the final request object
+   */
+  build(): EnhancedRequest {
+    // Create a proper Request object
+    const init: RequestInit = {
+      method: this.request.method,
+      headers: this.request.headers,
+    }
+
+    if (this.request.jsonBody) {
+      init.body = JSON.stringify(this.request.jsonBody)
+    }
+    else if (this.request.formBody) {
+      const formData = new FormData()
+      Object.entries(this.request.formBody).forEach(([key, value]) => {
+        formData.append(key, value as string)
+      })
+      init.body = formData
+    }
+
+    const baseRequest = new Request(this.url.toString(), init)
+
+    // Create enhanced request by copying properties to a new object
+    // We can't use Proxy due to Request immutability constraints in Bun
+    const enhancedRequest = Object.assign(baseRequest, {
+      params: this.request.params || {},
+      query: this.request.query || {},
+      jsonBody: this.request.jsonBody,
+      formBody: this.request.formBody,
+      files: this.request.files,
+      session: this.request.session,
+      user: this.request.user,
+      context: this.request.context || {},
+      requestId: this.request.requestId,
+      ip: this.request.ip,
+      userAgent: this.request.userAgent,
+      cookies: this.request.cookies || {},
+      startTime: this.request.startTime,
+      traceId: this.request.traceId,
+      spanId: this.request.spanId,
+    })
+
+    return enhancedRequest as EnhancedRequest
+  }
+}
+
+/**
+ * Helper functions for creating test requests
+ */
+export const testRequest = {
+  get: (path: string, options?: TestRequestOptions): TestRequestBuilder =>
+    new TestRequestBuilder('GET', path, options),
+
+  post: (path: string, options?: TestRequestOptions): TestRequestBuilder =>
+    new TestRequestBuilder('POST', path, options),
+
+  put: (path: string, options?: TestRequestOptions): TestRequestBuilder =>
+    new TestRequestBuilder('PUT', path, options),
+
+  patch: (path: string, options?: TestRequestOptions): TestRequestBuilder =>
+    new TestRequestBuilder('PATCH', path, options),
+
+  delete: (path: string, options?: TestRequestOptions): TestRequestBuilder =>
+    new TestRequestBuilder('DELETE', path, options),
+
+  options: (path: string, options?: TestRequestOptions): TestRequestBuilder =>
+    new TestRequestBuilder('OPTIONS', path, options),
+
+  head: (path: string, options?: TestRequestOptions): TestRequestBuilder =>
+    new TestRequestBuilder('HEAD', path, options),
+}
+
+/**
+ * Create a mock request with minimal setup
+ */
+export function createMockRequest(
+  method: string = 'GET',
+  path: string = '/',
+  options: TestRequestOptions = {},
+): EnhancedRequest {
+  return new TestRequestBuilder(method, path, options).build()
+}