{"version":3,"sources":["../src/index.ts","../src/mocks/context.ts","../src/mocks/event-bus.ts","../src/mocks/http.ts","../src/mocks/logger.ts","../src/mocks/middleware.ts","../src/mocks/plugins.ts","../src/mocks/router.ts","../src/mocks/server.ts","../src/utils/helpers.ts"],"sourcesContent":["import {\n  createMockHttp1Request,\n  createMockHttp2Request,\n  createMockResponse,\n  createMockMiddleware,\n  createMockPlugins,\n  createMockPlugin,\n  createMockRouter,\n  createMockServer,\n  createMockServerWithPlugins,\n  createMockHttpServer,\n  resetServerMocks,\n  createMockRoutesSet,\n  createMockContext,\n  createSSEMockContext,\n  mockGetRoute,\n  mockDeleteRoute,\n  mockPatchRoute,\n  mockPostRoute,\n  mockPutRoute,\n  createMockLogger,\n  MockLogger,\n  createMockEventBus,\n  createWorkingMockEventBus,\n} from './mocks';\n\nexport { createRouteTestContext } from './utils/helpers';\nexport type { RouteTestContext } from './utils/helpers';\n\nexport type { MockEventBusHelpers } from './mocks/event-bus';\n\nexport {\n  createWorkingMockEventBus,\n  createMockEventBus,\n  MockLogger,\n  createMockLogger,\n  createMockHttp1Request,\n  createMockHttp2Request,\n  createMockResponse,\n  createMockMiddleware,\n  createMockPlugins,\n  createMockPlugin,\n  createMockRouter,\n  createMockServer,\n  createMockServerWithPlugins,\n  createMockHttpServer,\n  createMockContext,\n  resetServerMocks,\n  createMockRoutesSet,\n  mockGetRoute,\n  mockDeleteRoute,\n  mockPatchRoute,\n  mockPostRoute,\n  mockPutRoute,\n  createSSEMockContext,\n};\n","/* eslint-disable @typescript-eslint/no-unsafe-function-type */\nimport { EventEmitter } from 'node:events';\n\nimport type { Context, QueryParams, Services, State, UploadedFile } from '@blaize-types';\n\n/**\n * Configuration options for creating test contexts\n */\nexport interface TestContextConfig {\n  method?: string;\n  path?: string;\n  query?: Record<string, string | string[]>;\n  params?: Record<string, string>;\n  headers?: Record<string, string>;\n  files?: unknown;\n  body?: unknown;\n  initialState?: Record<string, unknown>;\n  initialServices?: Record<string, unknown>;\n  withEventEmitter?: boolean;\n}\n\n/**\n * Create a test context for BlaizeJS testing\n *\n * Creates a complete Context object suitable for testing route handlers and middleware.\n *\n * The function uses a generic approach that allows the context to be used with\n * handlers that expect different query types (including `never` for SSE routes).\n *\n * @param config Configuration options for the context\n * @returns Complete BlaizeJS Context object\n *\n * @example\n * ```typescript\n * // Basic usage\n * const ctx = createMockContext();\n *\n * // With configuration\n * const ctx = createMockContext({\n *   method: 'POST',\n *   path: '/api/users',\n *   body: { name: 'John Doe' },\n *   headers: { authorization: 'Bearer token' }\n * });\n *\n * // For SSE testing\n * const ctx = createMockContext({\n *   withEventEmitter: true,\n *   headers: { accept: 'text/event-stream' }\n * });\n * ```\n */\nexport function createMockContext<\n  S extends State = State,\n  Svc extends Services = Services,\n  TBody = unknown,\n  TQuery = QueryParams,\n  TFiles = Record<string, UploadedFile | UploadedFile[]>,\n>(config: TestContextConfig = {}): Context<S, Svc, TBody, TQuery, TFiles> {\n  const {\n    method = 'GET',\n    path = '/test',\n    query = {},\n    params = {},\n    headers = {},\n    body,\n    initialState = {},\n    initialServices = {},\n    withEventEmitter = false,\n    files,\n  } = config;\n\n  // Normalize headers for case-insensitive lookup\n  const normalizedHeaders = Object.keys(headers).reduce<Record<string, string>>((acc, key) => {\n    const value = headers[key];\n    if (value !== undefined) {\n      acc[key.toLowerCase()] = value;\n    }\n    return acc;\n  }, {});\n\n  // Create raw request object - either with event emitter methods (for SSE) or minimal mocks\n  let rawRequest: {\n    on: ReturnType<typeof vi.fn>;\n    once?: ReturnType<typeof vi.fn>;\n    removeListener?: ReturnType<typeof vi.fn>;\n    removeAllListeners?: ReturnType<typeof vi.fn>;\n    emit?: ReturnType<typeof vi.fn>;\n    [key: string]: unknown;\n  };\n\n  if (withEventEmitter) {\n    const emitter = new EventEmitter();\n    rawRequest = {\n      ...emitter,\n      // Mock the event emitter methods while preserving functionality\n      on: vi.fn((event: string, handler: Function) => {\n        emitter.on(event, handler as any);\n        return rawRequest;\n      }),\n      once: vi.fn((event: string, handler: Function) => {\n        emitter.once(event, handler as any);\n        return rawRequest;\n      }),\n      removeListener: vi.fn((event: string, handler: Function) => {\n        emitter.removeListener(event, handler as any);\n        return rawRequest;\n      }),\n      removeAllListeners: vi.fn((event?: string) => {\n        emitter.removeAllListeners(event);\n        return rawRequest;\n      }),\n      emit: vi.fn((event: string, ...args: any[]) => {\n        return emitter.emit(event, ...args);\n      }),\n    };\n  } else {\n    rawRequest = {\n      on: vi.fn().mockReturnThis(),\n      once: vi.fn().mockReturnThis(),\n      removeListener: vi.fn().mockReturnThis(),\n      removeAllListeners: vi.fn().mockReturnThis(),\n      emit: vi.fn().mockReturnValue(true),\n    };\n  }\n\n  // Create raw response object with SSE-related methods\n  const rawResponse = {\n    writeHead: vi.fn().mockReturnThis(),\n    write: vi.fn().mockReturnValue(true),\n    end: vi.fn().mockReturnThis(),\n    writableEnded: false,\n    finished: false,\n    headersSent: false,\n    statusCode: 200,\n    statusMessage: '',\n    setHeader: vi.fn().mockReturnThis(),\n    getHeader: vi.fn(),\n    getHeaders: vi.fn().mockReturnValue({}),\n    removeHeader: vi.fn().mockReturnThis(),\n    hasHeader: vi.fn().mockReturnValue(false),\n    flushHeaders: vi.fn(),\n  };\n\n  // Create response object that properly chains\n  const responseObj: Context<S, Svc, TBody, TQuery>['response'] = {\n    raw: rawResponse as any,\n    sent: false,\n    statusCode: 200,\n\n    status: vi.fn(function (this: typeof responseObj, code: number) {\n      this.statusCode = code;\n      rawResponse.statusCode = code;\n      return this;\n    }),\n\n    header: vi.fn(function (this: typeof responseObj, name: string, value: string) {\n      rawResponse.setHeader(name, value);\n      return this;\n    }),\n\n    headers: vi.fn(function (this: typeof responseObj, headerObj: Record<string, string>) {\n      Object.entries(headerObj).forEach(([name, value]) => {\n        rawResponse.setHeader(name, value);\n      });\n      return this;\n    }),\n\n    type: vi.fn(function (this: typeof responseObj, contentType: string) {\n      rawResponse.setHeader('Content-Type', contentType);\n      return this;\n    }),\n\n    json: vi.fn(function (this: typeof responseObj, _body: unknown, status?: number) {\n      if (status) this.statusCode = status;\n      this.sent = true;\n    }),\n\n    text: vi.fn(function (this: typeof responseObj, _body: string, status?: number) {\n      if (status) this.statusCode = status;\n      this.sent = true;\n    }),\n\n    html: vi.fn(function (this: typeof responseObj, _body: string, status?: number) {\n      if (status) this.statusCode = status;\n      this.sent = true;\n    }),\n\n    redirect: vi.fn(function (this: typeof responseObj, _url: string, status?: number) {\n      this.statusCode = status || 302;\n      this.sent = true;\n    }),\n\n    stream: vi.fn(function (\n      this: typeof responseObj,\n      _readable: NodeJS.ReadableStream,\n      _options?: any\n    ) {\n      this.sent = true;\n    }),\n  };\n\n  const contextRequest: Context<S, Svc, TBody, TQuery, TFiles>['request'] = {\n    raw: rawRequest as any,\n    method,\n    path,\n    url: path.startsWith('http') ? new URL(path) : new URL(`http://localhost${path}`),\n    query: query as TQuery,\n    params,\n    protocol: 'http',\n    isHttp2: false,\n    body: body as TBody,\n    files: files as TFiles,\n\n    // Header function with case-insensitive lookup\n    header: vi.fn((name: string): string | undefined => {\n      return normalizedHeaders[name.toLowerCase()];\n    }),\n\n    // Headers function\n    headers: vi.fn((names?: string[]): Record<string, string | undefined> => {\n      if (names && Array.isArray(names)) {\n        return names.reduce<Record<string, string | undefined>>((acc, name) => {\n          acc[name] = normalizedHeaders[name.toLowerCase()];\n          return acc;\n        }, {});\n      }\n      return { ...headers };\n    }),\n  };\n\n  return {\n    request: contextRequest,\n    response: responseObj,\n    state: { ...initialState } as S,\n    services: { ...initialServices } as Svc,\n  };\n}\n\n/**\n * Create a mock context specifically for SSE routes\n * This version ensures compatibility with SSE route handlers\n */\nexport function createSSEMockContext<\n  S extends State = State,\n  Svc extends Services = Services,\n  TQuery = QueryParams,\n>(config: TestContextConfig = {}): Context<S, Svc, never, TQuery> {\n  return createMockContext<S, Svc, never, TQuery>({\n    ...config,\n    withEventEmitter: true,\n    headers: {\n      accept: 'text/event-stream',\n      ...config.headers,\n    },\n  });\n}\n","/**\n * Mock EventBus for Testing\n *\n * Provides mock implementations of EventBus for testing with assertion helpers\n * that reduce test boilerplate by ~70%.\n *\n * @packageDocumentation\n */\n\nimport type { EventBus, Unsubscribe, EventSchemas, TypedEventBus } from '@blaize-types/events';\n\n/**\n * Published event entry for internal tracking\n */\ntype PublishedEvent = {\n  type: string;\n  data: unknown;\n  timestamp: number;\n};\n\n/**\n * Assertion helpers for MockEventBus\n *\n * These methods make testing event publishing much cleaner and more readable.\n */\nexport interface MockEventBusHelpers {\n  /**\n   * Assert that an event with the given type was published\n   *\n   * Optionally validates event data using partial matching (toMatchObject).\n   * This means you only need to specify the fields you care about.\n   *\n   * @param eventType - The expected event type\n   * @param data - Optional data to validate (partial match)\n   * @throws {Error} If the event was not published, with helpful error message\n   *\n   * @example\n   * ```typescript\n   * await eventBus.publish('user:created', { userId: '123', email: 'test@example.com' });\n   *\n   * // Pass - exact match\n   * eventBus.assertPublished('user:created', { userId: '123', email: 'test@example.com' });\n   *\n   * // Pass - partial match (only check userId)\n   * eventBus.assertPublished('user:created', { userId: '123' });\n   *\n   * // Throw - event not found\n   * eventBus.assertPublished('user:deleted'); // Error with actual events listed\n   *\n   * // Throw - data doesn't match\n   * eventBus.assertPublished('user:created', { userId: '456' }); // Error\n   * ```\n   */\n  assertPublished(eventType: string, data?: unknown): void;\n\n  /**\n   * Assert that an event with the given type was NOT published\n   *\n   * @param eventType - The event type that should not have been published\n   * @throws {Error} If the event was published\n   *\n   * @example\n   * ```typescript\n   * await eventBus.publish('user:created', { userId: '123' });\n   *\n   * // Pass - event was not published\n   * eventBus.assertNotPublished('user:deleted');\n   *\n   * // Throw - event was published\n   * eventBus.assertNotPublished('user:created'); // Error\n   * ```\n   */\n  assertNotPublished(eventType: string): void;\n\n  /**\n   * Get all published events, optionally filtered by type\n   *\n   * Returns a copy of the events array to prevent external mutation.\n   *\n   * @param eventType - Optional event type to filter by\n   * @returns Array of published events\n   *\n   * @example\n   * ```typescript\n   * await eventBus.publish('user:created', { userId: '123' });\n   * await eventBus.publish('user:updated', { userId: '123' });\n   * await eventBus.publish('user:created', { userId: '456' });\n   *\n   * // Get all events\n   * const allEvents = eventBus.getPublishedEvents();\n   * console.log(allEvents.length); // 3\n   *\n   * // Get only user:created events\n   * const createdEvents = eventBus.getPublishedEvents('user:created');\n   * console.log(createdEvents.length); // 2\n   * ```\n   */\n  getPublishedEvents(eventType?: string): Array<{ type: string; data: unknown; timestamp: number }>;\n\n  /**\n   * Clear all tracked events and reset mock state\n   *\n   * Clears:\n   * - All published events\n   * - Vitest mock call history\n   *\n   * @example\n   * ```typescript\n   * await eventBus.publish('user:created', { userId: '123' });\n   * eventBus.clear();\n   *\n   * eventBus.getPublishedEvents(); // []\n   * expect(eventBus.publish).not.toHaveBeenCalled(); // ✅ Pass\n   * ```\n   */\n  clear(): void;\n}\n\n/**\n * Create a mock EventBus for testing with assertion helpers\n *\n * NEW in 0.6.0: Assertion helpers reduce test boilerplate by ~70%:\n * - eventBus.assertPublished('event:type', { data })\n * - eventBus.assertNotPublished('event:type')\n * - eventBus.getPublishedEvents('event:type')\n * - eventBus.clear()\n *\n * @param overrides - Optional overrides for specific EventBus methods\n * @returns Mock EventBus with assertion helpers\n *\n * @example Basic usage\n * ```typescript\n * import { createMockEventBus } from '@blaizejs/testing-utils';\n *\n * const eventBus = createMockEventBus();\n * await eventBus.publish('user:created', { userId: '123' });\n *\n * // Old way - verbose\n * expect(eventBus.publish).toHaveBeenCalledWith('user:created', { userId: '123' });\n *\n * // New way - concise\n * eventBus.assertPublished('user:created', { userId: '123' });\n * ```\n *\n * @example With TypeScript event schemas\n * ```typescript\n * type MyEvents = {\n *   'user:created': { userId: string; email: string };\n *   'user:deleted': { userId: string };\n * };\n *\n * const eventBus = createMockEventBus<MyEvents>();\n * await eventBus.publish('user:created', { userId: '123', email: 'test@example.com' });\n *\n * eventBus.assertPublished('user:created', { userId: '123' });\n * ```\n */\nexport function createMockEventBus<TSchemas extends EventSchemas = EventSchemas>(\n  overrides: Partial<EventBus> = {}\n): TypedEventBus<TSchemas> & MockEventBusHelpers {\n  /**\n   * Internal array tracking all published events\n   */\n  const publishedEvents: PublishedEvent[] = [];\n\n  /**\n   * Mock publish function that tracks all calls\n   */\n  const publish = vi.fn(async (type: string, data?: unknown) => {\n    publishedEvents.push({\n      type,\n      data,\n      timestamp: Date.now(),\n    });\n  });\n\n  return {\n    serverId: 'mock-eventbus-server',\n    publish,\n    subscribe: vi.fn().mockReturnValue(vi.fn()), // Returns mock unsubscribe function\n    setAdapter: vi.fn().mockResolvedValue(undefined),\n    disconnect: vi.fn().mockResolvedValue(undefined),\n\n    // Assertion helpers (NEW in 0.6.0)\n    assertPublished(eventType: string, data?: unknown): void {\n      const found = publishedEvents.find(e => e.type === eventType);\n\n      if (!found) {\n        const types = publishedEvents.map(e => e.type).join(', ');\n        throw new Error(\n          `Expected event \"${eventType}\" was not published.\\n` +\n            `Published events: [${types || 'none'}]`\n        );\n      }\n\n      if (data) {\n        expect(found.data).toMatchObject(data);\n      }\n    },\n\n    assertNotPublished(eventType: string): void {\n      const found = publishedEvents.find(e => e.type === eventType);\n\n      if (found) {\n        throw new Error(\n          `Expected event \"${eventType}\" to NOT be published, but it was.\\n` +\n            `Event data: ${JSON.stringify(found.data)}`\n        );\n      }\n    },\n\n    getPublishedEvents(eventType?: string): Array<{ type: string; data: unknown; timestamp: number }> {\n      if (eventType) {\n        return publishedEvents\n          .filter(e => e.type === eventType)\n          .map(e => ({ type: e.type, data: e.data, timestamp: e.timestamp }));\n      }\n      // Return copy to prevent external mutation\n      return publishedEvents.map(e => ({ type: e.type, data: e.data, timestamp: e.timestamp }));\n    },\n\n    clear(): void {\n      publishedEvents.length = 0; // Clear array\n      vi.clearAllMocks(); // Clear vitest mock state\n    },\n\n    ...overrides,\n  } as TypedEventBus<TSchemas> & MockEventBusHelpers;\n}\n\n/**\n * Create a working mock EventBus with in-memory pub/sub for integration tests\n *\n * This implementation actually handles subscriptions and calls handlers when\n * events are published, making it useful for integration tests that need\n * real event flow.\n *\n * @param serverId - Optional server ID (defaults to 'mock-server')\n * @returns Working EventBus with real pub/sub behavior\n *\n * @example\n * ```typescript\n * const eventBus = createWorkingMockEventBus('test-server');\n *\n * const handler = vi.fn();\n * eventBus.subscribe('user:*', handler);\n *\n * await eventBus.publish('user:created', { userId: '123' });\n *\n * expect(handler).toHaveBeenCalledWith(\n *   expect.objectContaining({\n *     type: 'user:created',\n *     data: { userId: '123' },\n *   })\n * );\n * ```\n */\nexport function createWorkingMockEventBus(serverId: string = 'mock-server'): EventBus {\n  const subscriptions = new Map<string, Set<(event: any) => void>>();\n\n  return {\n    serverId,\n\n    publish: vi.fn().mockImplementation(async (type: string, data?: unknown) => {\n      const event = {\n        type,\n        data,\n        timestamp: Date.now(),\n        serverId,\n        correlationId: 'test-correlation-id',\n      };\n\n      // Call matching subscribers\n      for (const [pattern, handlers] of subscriptions.entries()) {\n        if (matchesPattern(type, pattern)) {\n          handlers.forEach(handler => handler(event));\n        }\n      }\n    }),\n\n    subscribe: vi\n      .fn()\n      .mockImplementation((pattern: string, handler: (event: any) => void): Unsubscribe => {\n        if (!subscriptions.has(pattern)) {\n          subscriptions.set(pattern, new Set());\n        }\n        subscriptions.get(pattern)!.add(handler);\n\n        // Return unsubscribe function\n        return () => {\n          subscriptions.get(pattern)?.delete(handler);\n          if (subscriptions.get(pattern)?.size === 0) {\n            subscriptions.delete(pattern);\n          }\n        };\n      }),\n\n    setAdapter: vi.fn().mockResolvedValue(undefined),\n    disconnect: vi.fn().mockResolvedValue(undefined),\n  };\n}\n\n/**\n * Simple pattern matching for testing\n *\n * Supports:\n * - Exact match: 'user:created' matches 'user:created'\n * - Wildcard: 'user:*' matches 'user:created', 'user:updated', etc.\n * - Global wildcard: '*' matches any event\n *\n * @internal\n */\nfunction matchesPattern(eventType: string, pattern: string): boolean {\n  if (pattern === '*') return true;\n  if (pattern === eventType) return true;\n\n  // Simple wildcard support\n  const regex = new RegExp('^' + pattern.replace(/\\*/g, '[^:]*') + '$');\n  return regex.test(eventType);\n}","import type { IncomingHttpHeaders } from 'node:http';\n\ninterface MockRequestBase {\n  url: string;\n  method: string;\n  headers: IncomingHttpHeaders;\n  socket: {\n    encrypted: boolean;\n  };\n}\n\ninterface MockHttp2Request extends MockRequestBase {\n  stream: object;\n  httpVersionMajor: number;\n}\n\n// Create mock HTTP/1.1 request with overrides\nexport const createMockHttp1Request = (\n  overrides: Partial<MockRequestBase> = {}\n): MockRequestBase => ({\n  url: '/test?foo=bar&arr=1&arr=2',\n  method: 'GET',\n  headers: {\n    host: 'example.com',\n    'user-agent': 'test-agent',\n    'x-custom-header': 'custom-value',\n    ...(overrides.headers ?? {}),\n  },\n  socket: {\n    encrypted: false,\n    ...(overrides.socket ?? {}),\n  },\n  ...overrides,\n});\n\n// Create mock HTTP/2 request with overrides\nexport const createMockHttp2Request = (\n  overrides: Partial<MockHttp2Request> = {}\n): MockHttp2Request => ({\n  url: '/test?foo=bar&arr=1&arr=2',\n  method: 'GET',\n  headers: {\n    host: 'example.com',\n    'user-agent': 'test-agent',\n    'x-custom-header': 'custom-value',\n    ...(overrides.headers ?? {}),\n  },\n  socket: {\n    encrypted: true,\n    ...(overrides.socket ?? {}),\n  },\n  stream: {},\n  httpVersionMajor: 2,\n  ...overrides,\n});\n\n// Create mock response\nexport const createMockResponse = () => ({\n  statusCode: 200,\n  setHeader: vi.fn(),\n  getHeader: vi.fn(),\n  removeHeader: vi.fn(),\n  end: vi.fn(),\n  write: vi.fn(),\n  on: vi.fn(),\n});\n","/**\n * Mock Logger for Testing\n *\n * Provides a mock implementation of BlaizeLogger for testing middleware\n * and route handlers with tracking capabilities and assertion helpers.\n *\n * @packageDocumentation\n */\n\nimport type { BlaizeLogger, LogMetadata } from '@blaize-types/logger';\n\n/**\n * Log entry for internal tracking\n */\ntype LogEntry = {\n  level: 'info' | 'debug' | 'warn' | 'error';\n  message: string;\n  meta?: LogMetadata;\n};\n\n/**\n * Mock logger for testing with tracking capabilities and assertion helpers\n *\n * Tracks all log calls and child logger creations for assertion in tests.\n * All log methods are Vitest spies, so you can use assertions like:\n * - expect(logger.info).toHaveBeenCalled()\n * - expect(logger.warn).toHaveBeenCalledWith('message', { meta })\n *\n * NEW in 0.6.0: Assertion helpers reduce test boilerplate by ~70%:\n * - logger.assertInfoCalled('message', { meta })\n * - logger.assertErrorCalled('Error occurred')\n * - logger.getLogsByLevel('warn')\n * - logger.clear()\n *\n * @example\n * ```typescript\n * import { createMockLogger } from '@blaizejs/testing-utils';\n *\n * const logger = createMockLogger();\n * await middleware.execute(ctx, next, logger);\n *\n * // Old way - verbose\n * expect(logger.info).toHaveBeenCalledWith('Processing request');\n *\n * // New way - concise\n * logger.assertInfoCalled('Processing request');\n * ```\n *\n * @example Partial meta matching\n * ```typescript\n * logger.info('User created', { userId: '123', timestamp: 1234567890 });\n *\n * // Only check userId, ignore timestamp\n * logger.assertInfoCalled('User created', { userId: '123' });\n * ```\n */\nexport class MockLogger implements BlaizeLogger {\n  /**\n   * All log entries captured by this logger\n   *\n   * Public for backwards compatibility with existing tests.\n   * Prefer using getLogsByLevel() for cleaner tests.\n   */\n  public logs: LogEntry[];\n\n  /**\n   * Child logger contexts created\n   */\n  public childContexts: LogMetadata[];\n\n  /**\n   * Child logger instances created\n   *\n   * When child() is called, the new logger instance is stored here.\n   * Useful for tests that need to access child logger logs.\n   */\n  public childLoggers: MockLogger[];\n\n  /**\n   * Constructor for MockLogger\n   *\n   * @param sharedLogs - Optional shared logs array (for child loggers)\n   * @param sharedChildContexts - Optional shared child contexts array\n   * @param sharedChildLoggers - Optional shared child loggers array\n   */\n  constructor(\n    sharedLogs?: LogEntry[],\n    sharedChildContexts?: LogMetadata[],\n    sharedChildLoggers?: MockLogger[]\n  ) {\n    // Use shared arrays if provided (child logger), otherwise create new arrays (parent logger)\n    this.logs = sharedLogs ?? [];\n    this.childContexts = sharedChildContexts ?? [];\n    this.childLoggers = sharedChildLoggers ?? [];\n  }\n\n  // Use spies for all log methods so they can be asserted with toHaveBeenCalled\n  /**\n   * Log a debug message\n   */\n  public debug = vi.fn((message: string, meta?: LogMetadata): void => {\n    this.logs.push({ level: 'debug', message, meta });\n  });\n\n  /**\n   * Log an info message\n   */\n  public info = vi.fn((message: string, meta?: LogMetadata): void => {\n    this.logs.push({ level: 'info', message, meta });\n  });\n\n  /**\n   * Log a warning message\n   */\n  public warn = vi.fn((message: string, meta?: LogMetadata): void => {\n    this.logs.push({ level: 'warn', message, meta });\n  });\n\n  /**\n   * Log an error message\n   */\n  public error = vi.fn((message: string, meta?: LogMetadata): void => {\n    this.logs.push({ level: 'error', message, meta });\n  });\n\n  /**\n   * Create a child logger with additional context\n   *\n   * Child loggers share the parent's logs array, so all logs from\n   * children appear in the parent's logs for easier testing.\n   */\n  public child = vi.fn((context: LogMetadata): BlaizeLogger => {\n    this.childContexts.push(context);\n    // Create child that shares parent's logs array\n    const childLogger = new MockLogger(this.logs, this.childContexts, this.childLoggers);\n    this.childLoggers.push(childLogger);\n    return childLogger;\n  });\n\n  /**\n   * Flush any pending logs (no-op for mock)\n   */\n  public flush = vi.fn(async (): Promise<void> => {});\n\n  /**\n   * Assert that an info log with the given message was called\n   *\n   * Optionally validates metadata using partial matching (toMatchObject).\n   * This means you only need to specify the fields you care about.\n   *\n   * @param message - The expected log message\n   * @param meta - Optional metadata to validate (partial match)\n   * @throws {Error} If the log was not called, with helpful error message listing actual logs\n   *\n   * @example\n   * ```typescript\n   * logger.info('User created', { userId: '123', extra: 'data' });\n   *\n   * // Pass - exact match\n   * logger.assertInfoCalled('User created', { userId: '123', extra: 'data' });\n   *\n   * // Pass - partial match (only check userId)\n   * logger.assertInfoCalled('User created', { userId: '123' });\n   *\n   * // Throw - message not found\n   * logger.assertInfoCalled('Missing message'); // Error with actual logs listed\n   *\n   * // Throw - meta doesn't match\n   * logger.assertInfoCalled('User created', { userId: '456' }); // Error\n   * ```\n   */\n  assertInfoCalled(message: string, meta?: Record<string, unknown>): void {\n    const found = this.logs.find(l => l.level === 'info' && l.message === message);\n\n    if (!found) {\n      const actualMessages = this.logs\n        .filter(l => l.level === 'info')\n        .map(l => l.message)\n        .join(', ');\n\n      throw new Error(\n        `Expected info log \"${message}\" was not called.\\n` +\n          `Actual info logs: [${actualMessages || 'none'}]`\n      );\n    }\n\n    if (meta !== undefined) {\n      expect(found.meta).toMatchObject(meta);\n    }\n  }\n\n  /**\n   * Assert that a debug log with the given message was called\n   *\n   * @param message - The expected log message\n   * @param meta - Optional metadata to validate (partial match)\n   * @throws {Error} If the log was not called\n   *\n   * @example\n   * ```typescript\n   * logger.debug('Query executed', { duration: 42 });\n   * logger.assertDebugCalled('Query executed', { duration: 42 });\n   * ```\n   */\n  assertDebugCalled(message: string, meta?: Record<string, unknown>): void {\n    const found = this.logs.find(l => l.level === 'debug' && l.message === message);\n\n    if (!found) {\n      const actualMessages = this.logs\n        .filter(l => l.level === 'debug')\n        .map(l => l.message)\n        .join(', ');\n\n      throw new Error(\n        `Expected debug log \"${message}\" was not called.\\n` +\n          `Actual debug logs: [${actualMessages || 'none'}]`\n      );\n    }\n\n    if (meta !== undefined) {\n      expect(found.meta).toMatchObject(meta);\n    }\n  }\n\n  /**\n   * Assert that a warn log with the given message was called\n   *\n   * @param message - The expected log message\n   * @param meta - Optional metadata to validate (partial match)\n   * @throws {Error} If the log was not called\n   *\n   * @example\n   * ```typescript\n   * logger.warn('Rate limit approaching', { remaining: 10 });\n   * logger.assertWarnCalled('Rate limit approaching', { remaining: 10 });\n   * ```\n   */\n  assertWarnCalled(message: string, meta?: Record<string, unknown>): void {\n    const found = this.logs.find(l => l.level === 'warn' && l.message === message);\n\n    if (!found) {\n      const actualMessages = this.logs\n        .filter(l => l.level === 'warn')\n        .map(l => l.message)\n        .join(', ');\n\n      throw new Error(\n        `Expected warn log \"${message}\" was not called.\\n` +\n          `Actual warn logs: [${actualMessages || 'none'}]`\n      );\n    }\n\n    if (meta !== undefined) {\n      expect(found.meta).toMatchObject(meta);\n    }\n  }\n\n  /**\n   * Assert that an error log with the given message was called\n   *\n   * @param message - The expected log message\n   * @param meta - Optional metadata to validate (partial match)\n   * @throws {Error} If the log was not called\n   *\n   * @example\n   * ```typescript\n   * logger.error('Database connection failed', { error: dbError });\n   * logger.assertErrorCalled('Database connection failed');\n   * ```\n   */\n  assertErrorCalled(message: string, meta?: Record<string, unknown>): void {\n    const found = this.logs.find(l => l.level === 'error' && l.message === message);\n\n    if (!found) {\n      const actualMessages = this.logs\n        .filter(l => l.level === 'error')\n        .map(l => l.message)\n        .join(', ');\n\n      throw new Error(\n        `Expected error log \"${message}\" was not called.\\n` +\n          `Actual error logs: [${actualMessages || 'none'}]`\n      );\n    }\n\n    if (meta !== undefined) {\n      expect(found.meta).toMatchObject(meta);\n    }\n  }\n\n  /**\n   * Get all logs for a specific level\n   *\n   * Returns a copy of the logs array to prevent external mutation.\n   *\n   * @param level - The log level to filter by\n   * @returns Array of log entries (message and meta)\n   *\n   * @example\n   * ```typescript\n   * logger.info('First');\n   * logger.debug('Debug');\n   * logger.info('Second');\n   *\n   * const infoLogs = logger.getLogsByLevel('info');\n   * console.log(infoLogs);\n   * // [\n   * //   { message: 'First', meta: undefined },\n   * //   { message: 'Second', meta: undefined }\n   * // ]\n   * ```\n   */\n  getLogsByLevel(level: 'info' | 'debug' | 'warn' | 'error'): Array<{\n    message: string;\n    meta?: LogMetadata;\n  }> {\n    return this.logs\n      .filter(l => l.level === level)\n      .map(l => ({ message: l.message, meta: l.meta }));\n  }\n\n  /**\n   * Check if a log with the given message and level exists\n   *\n   * Helper method for backwards compatibility with existing tests.\n   *\n   * @param message - The log message to search for\n   * @param level - The log level (defaults to 'info')\n   * @returns True if a matching log entry exists\n   *\n   * @example\n   * ```typescript\n   * logger.info('Server started');\n   * logger.hasLog('Server started', 'info'); // true\n   * logger.hasLog('Not logged', 'info'); // false\n   * ```\n   */\n  hasLog(message: string, level: 'info' | 'debug' | 'warn' | 'error' = 'info'): boolean {\n    return this.logs.some(l => l.level === level && l.message === message);\n  }\n\n  /**\n   * Get all logs from this logger and all child loggers\n   *\n   * NOTE: With the shared logs implementation, this method now returns\n   * the same array as `this.logs` since child loggers share the parent's\n   * logs array. Kept for backwards compatibility.\n   *\n   * @returns Array of all log entries\n   *\n   * @example\n   * ```typescript\n   * const parentLogger = createMockLogger();\n   * const childLogger = parentLogger.child({ requestId: '123' });\n   *\n   * parentLogger.info('Parent log');\n   * childLogger.info('Child log');\n   *\n   * const allLogs = parentLogger.getAllLogs();\n   * // Same as parentLogger.logs (child logs already included)\n   * ```\n   */\n  getAllLogs(): LogEntry[] {\n    // Since child loggers now share the parent's logs array,\n    // we just return a copy of this.logs\n    return [...this.logs];\n  }\n\n  /**\n   * Clear all tracked data and reset mock state\n   *\n   * Clears:\n   * - All log entries\n   * - Child logger contexts\n   * - Child logger instances\n   * - Vitest mock call history\n   *\n   * @example\n   * ```typescript\n   * logger.info('Test');\n   * logger.clear();\n   *\n   * logger.getLogsByLevel('info'); // []\n   * expect(logger.info).not.toHaveBeenCalled(); // ✅ Pass\n   * ```\n   */\n  clear(): void {\n    this.logs.length = 0; // Clear array\n    this.childContexts.length = 0; // Clear child contexts\n    this.childLoggers.length = 0; // Clear child logger instances\n    vi.clearAllMocks(); // Clear vitest mock state\n  }\n\n  /**\n   * Get last log entry (legacy method, kept for backwards compatibility)\n   * @deprecated Use getLogsByLevel() instead\n   */\n  getLastLog() {\n    return this.logs[this.logs.length - 1];\n  }\n}\n\n/**\n * Factory function for creating mock loggers\n *\n * @returns A new MockLogger instance with assertion helpers\n *\n * @example\n * ```typescript\n * import { createMockLogger } from '@blaizejs/testing-utils';\n *\n * const logger = createMockLogger();\n * logger.info('Test message', { userId: '123' });\n * logger.assertInfoCalled('Test message', { userId: '123' });\n * ```\n */\nexport function createMockLogger(): MockLogger {\n  return new MockLogger();\n}\n","/**\n * Middleware Testing Utilities\n *\n * Helper functions for testing middleware with context object signature\n */\n\nimport { createMockContext } from './context';\nimport { createMockEventBus } from './event-bus';\nimport { createMockLogger } from './logger';\n\nimport type { MockLogger } from './logger';\nimport type { Middleware, Context, NextFunction, TypedEventBus, EventSchemas } from '@blaize-types';\n\n/**\n * Result from executing middleware in tests\n */\nexport interface MiddlewareTestResult {\n  context: Context;\n  nextCalled: boolean;\n  logger: MockLogger;\n  eventBus: TypedEventBus<EventSchemas>;\n  error?: Error;\n}\n\n/**\n * Execute a single middleware and track if next() was called\n * This eliminates the repetitive nextCalled tracking in tests\n */\nexport async function executeMiddleware(\n  middleware: Middleware,\n  context?: Context,\n  logger?: MockLogger,\n  eventBus?: TypedEventBus<EventSchemas>\n): Promise<MiddlewareTestResult> {\n  const ctx = context || createMockContext();\n  const mockLogger = logger || createMockLogger();\n  const mockEventBus = eventBus || createMockEventBus();\n  let nextCalled = false;\n  let error: Error | undefined;\n\n  const next: NextFunction = vi.fn().mockImplementation(async () => {\n    nextCalled = true;\n  });\n\n  try {\n    await middleware.execute({\n      ctx,\n      next,\n      logger: mockLogger,\n      eventBus: mockEventBus,\n    });\n  } catch (err) {\n    error = err as Error;\n  }\n\n  const result: MiddlewareTestResult = {\n    context: ctx,\n    nextCalled,\n    logger: mockLogger,\n    eventBus: mockEventBus,\n  };\n\n  if (error) {\n    result.error = error;\n  }\n\n  return result;\n}\n\n/**\n * Test middleware execution order in a chain\n * This replaces the manual executionOrder tracking pattern\n */\nexport async function trackMiddlewareOrder(\n  middlewares: Middleware[],\n  context?: Context,\n  logger?: MockLogger,\n  eventBus?: TypedEventBus<EventSchemas>\n): Promise<{\n  context: Context;\n  executionOrder: string[];\n  logger: MockLogger;\n  eventBus: TypedEventBus<EventSchemas>;\n  error?: Error;\n}> {\n  const ctx = context || createMockContext();\n  const mockLogger = logger || createMockLogger();\n  const mockEventBus = eventBus || createMockEventBus();\n  const executionOrder: string[] = [];\n  let error: Error | undefined;\n\n  // Wrap middlewares to track their execution\n  const trackedMiddlewares = middlewares.map(middleware => ({\n    ...middleware,\n    execute: async (mc: {\n      ctx: Context;\n      next: NextFunction;\n      logger: MockLogger;\n      eventBus: TypedEventBus<EventSchemas>;\n    }) => {\n      executionOrder.push(`${middleware.name}-before`);\n      try {\n        await middleware.execute(mc);\n        executionOrder.push(`${middleware.name}-after`);\n      } catch (err) {\n        executionOrder.push(`${middleware.name}-error`);\n        throw err;\n      }\n    },\n  }));\n\n  const finalHandler = async () => {\n    executionOrder.push('final-handler');\n  };\n\n  try {\n    // Simple chain execution\n    let index = 0;\n    async function dispatch(): Promise<void> {\n      if (index >= trackedMiddlewares.length) {\n        await finalHandler();\n        return;\n      }\n      const middleware = trackedMiddlewares[index++];\n      if (!middleware) {\n        throw new Error('Middleware is undefined - this should not happen');\n      }\n      await middleware.execute({\n        ctx,\n        next: dispatch,\n        logger: mockLogger,\n        eventBus: mockEventBus,\n      });\n    }\n    await dispatch();\n  } catch (err) {\n    error = err as Error;\n  }\n\n  const result = {\n    context: ctx,\n    executionOrder,\n    logger: mockLogger,\n    eventBus: mockEventBus,\n  };\n\n  if (error) {\n    return { ...result, error };\n  }\n\n  return result;\n}\n\n/**\n * Enhanced createMockMiddleware that covers common test scenarios\n */\nexport function createMockMiddleware(\n  config: {\n    name?: string;\n    execute?: (mc: {\n      ctx: Context;\n      next: NextFunction;\n      logger: MockLogger;\n      eventBus: TypedEventBus<EventSchemas>;\n    }) => Promise<void> | void;\n    behavior?: 'pass' | 'block' | 'error';\n    errorMessage?: string;\n    stateChanges?: Record<string, unknown>;\n    skip?: (ctx: Context) => boolean;\n    debug?: boolean;\n  } = {}\n): Middleware {\n  const {\n    name = 'test-middleware',\n    execute,\n    behavior = 'pass',\n    errorMessage = 'Test error',\n    stateChanges = {},\n    skip,\n    debug,\n  } = config;\n\n  return {\n    name,\n    skip,\n    debug,\n    execute: vi\n      .fn()\n      .mockImplementation(\n        async (mc: {\n          ctx: Context;\n          next: NextFunction;\n          logger: MockLogger;\n          eventBus: TypedEventBus<EventSchemas>;\n        }) => {\n          // If custom execute function provided, use that\n          if (execute) {\n            return execute(mc);\n          }\n\n          // Apply any state changes\n          Object.assign(mc.ctx.state, stateChanges);\n\n          switch (behavior) {\n            case 'pass':\n              await mc.next();\n              break;\n            case 'block':\n              mc.ctx.response.status(403).json({ error: 'Blocked' });\n              // Don't call next()\n              break;\n            case 'error':\n              throw new Error(errorMessage);\n          }\n        }\n      ),\n  };\n}\n","import { Plugin, PluginLifecycleManager } from '../../../blaize-types/src/index';\n\n/**\n * Create a mock plugin for testing\n */\nexport function createMockPlugin(overrides: Partial<Plugin> = {}): Plugin {\n  return {\n    name: 'test-plugin',\n    version: '1.0.0',\n    register: vi.fn().mockResolvedValue(undefined) as any,\n    initialize: vi.fn().mockResolvedValue(undefined),\n    terminate: vi.fn().mockResolvedValue(undefined),\n    onServerStart: vi.fn().mockResolvedValue(undefined),\n    onServerStop: vi.fn().mockResolvedValue(undefined),\n    ...overrides,\n  };\n}\n\n/**\n * Create multiple mock plugins for testing\n */\nexport function createMockPlugins(count: number, baseOverrides: Partial<Plugin> = {}): Plugin[] {\n  return Array.from({ length: count }, (_, index) =>\n    createMockPlugin({\n      name: `test-plugin-${index + 1}`,\n      ...baseOverrides,\n    })\n  );\n}\n\n/**\n * Create a mock plugin lifecycle manager for testing\n */\nexport function createMockPluginLifecycleManager(\n  overrides: Partial<PluginLifecycleManager> = {}\n): PluginLifecycleManager {\n  return {\n    registerPlugins: vi.fn().mockResolvedValue(undefined),\n    initializePlugins: vi.fn().mockResolvedValue(undefined),\n    terminatePlugins: vi.fn().mockResolvedValue(undefined),\n    onServerStart: vi.fn().mockResolvedValue(undefined),\n    onServerStop: vi.fn().mockResolvedValue(undefined),\n    ...overrides,\n  };\n}\n","import { z } from 'zod';\n\nimport type {\n  CreateDeleteRoute,\n  CreateGetRoute,\n  CreateHeadRoute,\n  CreateOptionsRoute,\n  CreatePatchRoute,\n  CreatePostRoute,\n  CreatePutRoute,\n  Route,\n  RouteMethodOptions,\n  Router,\n  State,\n  Services,\n  EventSchemas,\n} from '../../../blaize-types/src/index';\n\n/**\n * Create a mock router for testing\n */\nexport function createMockRouter(overrides: Partial<Router> = {}): Router {\n  return {\n    ready: Promise.resolve(),\n    handleRequest: vi.fn().mockResolvedValue(undefined),\n    getRoutes: vi.fn().mockReturnValue([]),\n    addRoute: vi.fn(),\n    addRoutes: vi.fn().mockReturnValue({ added: [], removed: [], changed: [] }),\n    addRouteDirectory: vi.fn().mockResolvedValue(undefined),\n    getRouteConflicts: vi.fn().mockReturnValue([]),\n    close: vi.fn().mockResolvedValue(undefined),\n    ...overrides,\n  };\n}\n\n/**\n * Create a mock route handler for testing\n * This eliminates the repeated createMockHandler pattern in router tests\n */\nexport function createMockRouteHandler(name: string): RouteMethodOptions {\n  return {\n    handler: vi.fn().mockResolvedValue({ message: `${name} handler` }),\n    middleware: [],\n    schema: {},\n  };\n}\n\n/**\n * Create a complete Route object for testing\n * This eliminates repetitive route object creation\n */\nexport function createMockRoute(\n  path: string,\n  methods: Partial<\n    Record<'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS', RouteMethodOptions>\n  >\n): Route {\n  return {\n    path,\n    ...methods,\n  } as Route;\n}\n\n/**\n * Create multiple routes for testing route addition/removal scenarios\n */\nexport function createMockRoutes(count: number, basePath = '/test'): Route[] {\n  return Array.from({ length: count }, (_, index) =>\n    createMockRoute(`${basePath}-${index + 1}`, {\n      GET: createMockRouteHandler(`handler-${index + 1}`),\n    })\n  );\n}\n\n/**\n * Mock implementation of createGetRoute for testing\n * Now returns a function that accepts state/services/events generics\n */\nexport const mockGetRoute: CreateGetRoute = <\n  _TState extends State = State,\n  _TServices extends Services = Services,\n  _TEvents extends EventSchemas = EventSchemas,\n>() => {\n  return (config: any) => {\n    const handler = config.handler || vi.fn().mockResolvedValue({ message: 'mock response' });\n\n    return {\n      GET: { ...config, handler } as any,\n      path: '/mock/path',\n    };\n  };\n};\n\n/**\n * Mock implementation of createPostRoute for testing\n * Now returns a function that accepts state/services/events generics\n */\nexport const mockPostRoute: CreatePostRoute = <\n  _TState extends State = State,\n  _TServices extends Services = Services,\n  _TEvents extends EventSchemas = EventSchemas,\n>() => {\n  return (config: any) => {\n    const handler = config.handler || vi.fn().mockResolvedValue({ message: 'mock response' });\n\n    return {\n      POST: { ...config, handler } as any,\n      path: '/mock/path',\n    };\n  };\n};\n\n/**\n * Mock implementation of createPutRoute for testing\n * Now returns a function that accepts state/services/events generics\n */\nexport const mockPutRoute: CreatePutRoute = <\n  _TState extends State = State,\n  _TServices extends Services = Services,\n  _TEvents extends EventSchemas = EventSchemas,\n>() => {\n  return (config: any) => {\n    const handler = config.handler || vi.fn().mockResolvedValue({ message: 'mock response' });\n\n    return {\n      PUT: { ...config, handler } as any,\n      path: '/mock/path',\n    };\n  };\n};\n\n/**\n * Mock implementation of createDeleteRoute for testing\n * Now returns a function that accepts state/services/events generics\n */\nexport const mockDeleteRoute: CreateDeleteRoute = <\n  _TState extends State = State,\n  _TServices extends Services = Services,\n  _TEvents extends EventSchemas = EventSchemas,\n>() => {\n  return (config: any) => {\n    const handler = config.handler || vi.fn().mockResolvedValue({ message: 'mock response' });\n\n    return {\n      DELETE: { ...config, handler } as any,\n      path: '/mock/path',\n    };\n  };\n};\n\n/**\n * Mock implementation of createPatchRoute for testing\n * Now returns a function that accepts state/services/events generics\n */\nexport const mockPatchRoute: CreatePatchRoute = <\n  _TState extends State = State,\n  _TServices extends Services = Services,\n  _TEvents extends EventSchemas = EventSchemas,\n>() => {\n  return (config: any) => {\n    const handler = config.handler || vi.fn().mockResolvedValue({ message: 'mock response' });\n\n    return {\n      PATCH: { ...config, handler } as any,\n      path: '/mock/path',\n    };\n  };\n};\n\n/**\n * Mock implementation of createHeadRoute for testing\n * Now returns a function that accepts state/services/events generics\n */\nexport const mockHeadRoute: CreateHeadRoute = <\n  _TState extends State = State,\n  _TServices extends Services = Services,\n  _TEvents extends EventSchemas = EventSchemas,\n>() => {\n  return (config: any) => {\n    const handler = config.handler || vi.fn().mockResolvedValue({ message: 'mock response' });\n\n    return {\n      HEAD: { ...config, handler } as any,\n      path: '/mock/path',\n    };\n  };\n};\n\n/**\n * Mock implementation of createOptionsRoute for testing\n * Now returns a function that accepts state/services/events generics\n */\nexport const mockOptionsRoute: CreateOptionsRoute = <\n  _TState extends State = State,\n  _TServices extends Services = Services,\n  _TEvents extends EventSchemas = EventSchemas,\n>() => {\n  return (config: any) => {\n    const handler = config.handler || vi.fn().mockResolvedValue({ message: 'mock response' });\n\n    return {\n      OPTIONS: { ...config, handler } as any,\n      path: '/mock/path',\n    };\n  };\n};\n\n/**\n * Helper to override the path for a mock route\n */\nexport function withPath<T extends { path: string }>(route: T, path: string): T {\n  return { ...route, path };\n}\n\n/**\n * Mock route factory for testing - matches the real createRouteFactory\n * Usage: const routes = createMockRouteFactory<TestState, TestServices>();\n */\nexport function createMockRouteFactory<\n  TState extends State = State,\n  TServices extends Services = Services,\n  TEvents extends EventSchemas = EventSchemas,\n>() {\n  return {\n    get: mockGetRoute<TState, TServices, TEvents>(),\n    post: mockPostRoute<TState, TServices, TEvents>(),\n    put: mockPutRoute<TState, TServices, TEvents>(),\n    delete: mockDeleteRoute<TState, TServices, TEvents>(),\n    patch: mockPatchRoute<TState, TServices, TEvents>(),\n    head: mockHeadRoute<TState, TServices, TEvents>(),\n    options: mockOptionsRoute<TState, TServices, TEvents>(),\n  } as const;\n}\n\n/**\n * Create a set of commonly used mock routes for testing\n * Now uses the updated mock route creators with state/services/events support\n * IMPORTANT: All handlers now use NEW signature ({ ctx, params, logger, eventBus })\n */\nexport function createMockRoutesSet() {\n  // Create route creators with default state/services/events\n  const routes = createMockRouteFactory();\n\n  return {\n    // Route with no schemas - should not require arguments\n    healthCheck: withPath(\n      routes.get({\n        schema: {\n          response: z.object({\n            status: z.string(),\n            timestamp: z.number(),\n          }),\n        },\n        // NEW SIGNATURE: handler receives context object\n        handler: async () => ({ status: 'ok', timestamp: Date.now() }),\n      }),\n      '/health'\n    ),\n\n    // Route with params only\n    getUser: withPath(\n      routes.get({\n        schema: {\n          params: z.object({ userId: z.string() }),\n          response: z.object({\n            user: z.object({\n              id: z.string(),\n              name: z.string(),\n              email: z.string().email(),\n            }),\n          }),\n        },\n        // NEW SIGNATURE: destructure params from context object\n        handler: async ({ params }: any) => ({\n          user: { id: params.userId, name: 'John Doe', email: 'john@example.com' },\n        }),\n      }),\n      '/users/:userId'\n    ),\n\n    // Route with body only\n    createUser: withPath(\n      routes.post({\n        schema: {\n          body: z.object({\n            name: z.string(),\n            email: z.string().email(),\n          }),\n          response: z.object({\n            user: z.object({\n              id: z.string(),\n              name: z.string(),\n              email: z.string().email(),\n            }),\n          }),\n        },\n        // NEW SIGNATURE: destructure ctx to access body\n        handler: async ({ ctx }: any) => ({\n          user: { id: '456', name: ctx.body.name, email: ctx.body.email },\n        }),\n      }),\n      '/users'\n    ),\n\n    // Route with query only\n    listUsers: withPath(\n      routes.get({\n        schema: {\n          query: z.object({\n            page: z.number().optional(),\n            limit: z.number().optional(),\n            sort: z.enum(['asc', 'desc']).optional(),\n          }),\n          response: z.object({\n            users: z.array(\n              z.object({\n                id: z.string(),\n                name: z.string(),\n              })\n            ),\n            total: z.number(),\n          }),\n        },\n        // NEW SIGNATURE: can access ctx.query if needed\n        handler: async () => ({\n          users: [],\n          total: 0,\n        }),\n      }),\n      '/users'\n    ),\n\n    // Route with all schemas\n    updateUser: withPath(\n      routes.put({\n        schema: {\n          params: z.object({ userId: z.string() }),\n          query: z.object({ notify: z.boolean().optional() }),\n          body: z.object({\n            name: z.string().optional(),\n            email: z.string().email().optional(),\n          }),\n          response: z.object({\n            user: z.object({\n              id: z.string(),\n              name: z.string(),\n              email: z.string().email(),\n            }),\n          }),\n        },\n        // NEW SIGNATURE: destructure multiple properties\n        handler: async ({ params, ctx }: any) => ({\n          user: {\n            id: params.userId,\n            name: ctx.body.name || 'John Updated',\n            email: ctx.body.email || 'john.updated@example.com',\n          },\n        }),\n      }),\n      '/users/:userId'\n    ),\n  } as const;\n}\n\n/**\n * Test helper: Create mock routes with custom state/services types\n * Useful for testing type-safe route handlers\n */\nexport function createTypedMockRoutesSet<\n  TState extends State = State,\n  TServices extends Services = Services,\n  TEvents extends EventSchemas = EventSchemas,\n>() {\n  const routes = createMockRouteFactory<TState, TServices, TEvents>();\n\n  return {\n    typedRoute: routes.get({\n      schema: {\n        response: z.object({\n          success: z.boolean(),\n        }),\n      },\n      // NEW SIGNATURE: destructure ctx to access state and services\n      handler: async () => {\n        // ctx.state and ctx.services will be typed as TState and TServices\n        return { success: true };\n      },\n    }),\n  };\n}\n\n/**\n * Test helper: Create a route that uses state and services\n * For testing middleware/plugin integration\n */\nexport function createStateAwareRoute<\n  TState extends State = State,\n  TServices extends Services = Services,\n>(stateKey: keyof TState, serviceKey: keyof TServices) {\n  const routes = createMockRouteFactory<TState, TServices>();\n\n  return routes.get({\n    schema: {\n      response: z.object({\n        stateValue: z.unknown(),\n        serviceExists: z.boolean(),\n      }),\n    },\n    // NEW SIGNATURE: destructure ctx\n    handler: async ({ ctx }: any) => {\n      return {\n        stateValue: ctx.state[stateKey],\n        serviceExists: serviceKey in ctx.services,\n      };\n    },\n  });\n}\n","/* eslint-disable @typescript-eslint/no-empty-object-type */\nimport EventEmitter from 'node:events';\n\nimport { createMockEventBus } from './event-bus';\nimport { createMockLogger } from './logger';\nimport { createMockPluginLifecycleManager, createMockPlugins } from './plugins';\nimport { createMockRouter } from './router';\nimport {\n  Plugin,\n  PluginLifecycleManager,\n  Server,\n  EventSchemas,\n} from '../../../blaize-types/src/index';\n\n/**\n * Create a mock server instance for testing\n */\nexport function createMockServer<TState, TServices, TEvents extends EventSchemas = EventSchemas>(\n  overrides: Partial<Server<TState, TServices, TEvents>> = {},\n  pluginManagerOverrides: Partial<PluginLifecycleManager> = {}\n): Server<TState, TServices, TEvents> {\n  const mockRouter = createMockRouter();\n  const mockPluginManager = createMockPluginLifecycleManager(pluginManagerOverrides);\n  const logger = createMockLogger();\n  const mockEventBus = createMockEventBus(); // NEW\n\n  return {\n    server: undefined,\n    port: 3000,\n    host: 'localhost',\n    serverId: 'mock-server-id', // NEW\n    eventBus: mockEventBus, // NEW\n    events: new EventEmitter(),\n    plugins: [],\n    middleware: [],\n    corsOptions: undefined, // NEW - was missing\n    bodyLimits: {\n      // NEW - was missing\n      json: 512 * 1024,\n      form: 1024 * 1024,\n      text: 5 * 1024 * 1024,\n      raw: 10 * 1024 * 1024,\n      multipart: {\n        maxFileSize: 50 * 1024 * 1024,\n        maxTotalSize: 100 * 1024 * 1024,\n        maxFiles: 10,\n        maxFieldSize: 1024 * 1024,\n      },\n    },\n    _signalHandlers: { unregister: vi.fn() },\n    _logger: logger,\n    listen: vi.fn().mockResolvedValue({} as Server<TState, TServices>),\n    close: vi.fn().mockResolvedValue(undefined),\n    use: vi.fn().mockReturnThis(),\n    register: vi.fn().mockResolvedValue({} as Server<TState, TServices>),\n    router: mockRouter,\n    pluginManager: mockPluginManager,\n    context: {\n      getStore: vi.fn(),\n      run: vi.fn(),\n      enterWith: vi.fn(),\n      disable: vi.fn(),\n      exit: vi.fn(),\n    } as any,\n    ...overrides,\n  } as Server<TState, TServices, TEvents>;\n}\n\n/**\n * Create a mock server with plugins for testing\n */\nexport function createMockServerWithPlugins<\n  TState,\n  TServices,\n  TEvents extends EventSchemas = EventSchemas,\n>(\n  pluginCount: number = 2,\n  serverOverrides: Partial<Server<TState, TServices, TEvents>> = {},\n  pluginOverrides: Partial<Plugin> = {},\n  pluginManagerOverrides: Partial<PluginLifecycleManager> = {}\n): { server: Server<TState, TServices, TEvents>; plugins: Plugin[] } {\n  const plugins = createMockPlugins(pluginCount, pluginOverrides);\n\n  const pluginManager = createMockPluginLifecycleManager(pluginManagerOverrides);\n  const server = createMockServer<TState, TServices, TEvents>({\n    plugins,\n    pluginManager,\n    ...serverOverrides,\n  });\n\n  return { server, plugins };\n}\n\n/**\n * Create a mock HTTP server for testing\n */\nexport function createMockHttpServer(overrides: any = {}) {\n  return {\n    close: vi.fn().mockImplementation(callback => {\n      if (callback) callback();\n    }),\n    listen: vi.fn(),\n    address: vi.fn().mockReturnValue({ port: 3000, address: 'localhost' }),\n    on: vi.fn(),\n    removeListener: vi.fn(),\n    addListener: vi.fn(),\n    emit: vi.fn(),\n    once: vi.fn(),\n    ...overrides,\n  } as any;\n}\n\n/**\n * Test server lifecycle (listen -> close) with automatic cleanup\n * This eliminates the repetitive beforeEach/afterEach pattern in server tests\n */\nexport async function testServerLifecycle<TState = {}, TServices = {}>(\n  server: Server<TState, TServices>,\n  testFn: (server: Server<TState, TServices>) => Promise<void> | void\n): Promise<void> {\n  try {\n    await server.listen();\n    await testFn(server);\n  } finally {\n    await server.close();\n  }\n}\n\n/**\n * Create a spy for server events that's easy to test\n * This eliminates repetitive event spying setup\n */\nexport function spyOnServerEvents<TState = {}, TServices = {}>(server: Server<TState, TServices>) {\n  const eventSpy = vi.spyOn(server.events, 'emit');\n\n  return {\n    expectEvent: (eventName: string) => {\n      expect(eventSpy).toHaveBeenCalledWith(eventName);\n    },\n    expectNoEvents: () => {\n      expect(eventSpy).not.toHaveBeenCalled();\n    },\n    reset: () => eventSpy.mockClear(),\n  };\n}\n\n/**\n * Reset all mocks in a server instance\n */\nexport function resetServerMocks<TState = {}, TServices = {}>(\n  server: Server<TState, TServices>\n): void {\n  // Reset plugin mocks\n  server.plugins.forEach(plugin => {\n    if (vi.isMockFunction(plugin.register)) vi.mocked(plugin.register).mockClear();\n    if (vi.isMockFunction(plugin.initialize)) vi.mocked(plugin.initialize).mockClear();\n    if (vi.isMockFunction(plugin.terminate)) vi.mocked(plugin.terminate).mockClear();\n    if (vi.isMockFunction(plugin.onServerStart)) vi.mocked(plugin.onServerStart).mockClear();\n    if (vi.isMockFunction(plugin.onServerStop)) vi.mocked(plugin.onServerStop).mockClear();\n  });\n\n  // Reset middleware mocks\n  server.middleware.forEach(middleware => {\n    if (vi.isMockFunction(middleware.execute)) {\n      vi.mocked(middleware.execute).mockClear();\n    }\n  });\n\n  // Reset server method mocks\n  if (vi.isMockFunction(server.listen)) vi.mocked(server.listen).mockClear();\n  if (vi.isMockFunction(server.close)) vi.mocked(server.close).mockClear();\n  if (vi.isMockFunction(server.use)) vi.mocked(server.use).mockClear();\n  if (vi.isMockFunction(server.register)) vi.mocked(server.register).mockClear();\n\n  // Reset router mocks\n  const router = server.router as any;\n  if (vi.isMockFunction(router.handleRequest)) vi.mocked(router.handleRequest).mockClear();\n  if (vi.isMockFunction(router.getRoutes)) vi.mocked(router.getRoutes).mockClear();\n  if (vi.isMockFunction(router.addRoute)) vi.mocked(router.addRoute).mockClear();\n  if (vi.isMockFunction(router.addRouteDirectory)) vi.mocked(router.addRouteDirectory).mockClear();\n  if (vi.isMockFunction(router.getRouteConflicts)) vi.mocked(router.getRouteConflicts).mockClear();\n}\n","/**\n * Test Helper Utilities\n *\n * Common test patterns and helper functions for BlaizeJS route testing.\n * Reduces boilerplate and provides consistent testing patterns.\n *\n * @packageDocumentation\n */\n\nimport { createMockEventBus } from '../mocks/event-bus';\nimport { createMockLogger } from '../mocks/logger';\n\nimport type { MockEventBusHelpers } from '../mocks/event-bus';\nimport type { MockLogger } from '../mocks/logger';\nimport type { TypedEventBus, EventSchemas } from '@blaize-types/events';\n\n/**\n * Route test context with logger, eventBus, and cleanup\n *\n * Provides all the common dependencies needed for route handler testing\n * in a single convenient object.\n *\n * @template TSchemas - Optional event schemas for typed EventBus\n */\nexport interface RouteTestContext<TSchemas extends EventSchemas = EventSchemas> {\n  /**\n   * Mock logger with assertion helpers\n   *\n   * @example\n   * ```typescript\n   * logger.info('User created', { userId: '123' });\n   * logger.assertInfoCalled('User created', { userId: '123' });\n   * ```\n   */\n  logger: MockLogger;\n\n  /**\n   * Mock EventBus with assertion helpers\n   *\n   * @example\n   * ```typescript\n   * await eventBus.publish('user:created', { userId: '123' });\n   * eventBus.assertPublished('user:created', { userId: '123' });\n   * ```\n   */\n  eventBus: TypedEventBus<TSchemas> & MockEventBusHelpers;\n\n  /**\n   * Cleanup function to reset all mocks\n   *\n   * Clears:\n   * - Logger state and assertions\n   * - EventBus state and assertions\n   * - All Vitest mock call history\n   *\n   * @example\n   * ```typescript\n   * afterEach(() => {\n   *   cleanup();\n   * });\n   * ```\n   */\n  cleanup: () => void;\n}\n\n/**\n * Create a complete test context for route handler testing\n *\n * Provides pre-configured logger and eventBus with assertion helpers,\n * plus a cleanup function to reset state between tests.\n *\n * This is the primary testing utility - use it in every route test to\n * reduce boilerplate from ~10 lines to ~1 line.\n *\n * @template TSchemas - Optional event schemas for typed EventBus\n * @returns Test context with logger, eventBus, and cleanup\n *\n * @example Basic usage\n * ```typescript\n * import { createRouteTestContext } from '@blaizejs/testing-utils';\n *\n * describe('GET /users/:userId', () => {\n *   it('should fetch user and publish event', async () => {\n *     const { logger, eventBus, cleanup } = createRouteTestContext();\n *\n *     const result = await getUserById.handler({\n *       params: { userId: 'test-123' },\n *       logger,\n *       eventBus,\n *     });\n *\n *     expect(result.id).toBe('test-123');\n *     logger.assertInfoCalled('Fetching user', { userId: 'test-123' });\n *     eventBus.assertPublished('user:viewed', { userId: 'test-123' });\n *\n *     cleanup();\n *   });\n * });\n * ```\n *\n * @example With cleanup in afterEach\n * ```typescript\n * describe('User routes', () => {\n *   const { logger, eventBus, cleanup } = createRouteTestContext();\n *\n *   afterEach(() => {\n *     cleanup(); // Reset state between tests\n *   });\n *\n *   it('test 1', async () => {\n *     // Use logger and eventBus\n *   });\n *\n *   it('test 2', async () => {\n *     // Fresh state from cleanup\n *   });\n * });\n * ```\n *\n * @example With typed event schemas\n * ```typescript\n * import { z } from 'zod';\n *\n * type MyEvents = {\n *   'user:created': z.ZodObject<{ userId: z.ZodString }>;\n *   'order:placed': z.ZodObject<{ orderId: z.ZodString }>;\n * };\n *\n * const { logger, eventBus, cleanup } = createRouteTestContext<MyEvents>();\n *\n * // eventBus now has type hints for event names and data\n * await eventBus.publish('user:created', { userId: '123' });\n * ```\n */\nexport function createRouteTestContext<\n  TSchemas extends EventSchemas = EventSchemas,\n>(): RouteTestContext<TSchemas> {\n  const logger = createMockLogger();\n  const eventBus = createMockEventBus<TSchemas>();\n\n  return {\n    logger,\n    eventBus,\n    cleanup: () => {\n      logger.clear();\n      eventBus.clear();\n      vi.clearAllMocks();\n    },\n  };\n}\n"],"mappings":"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","names":["import_node_events","EventEmitter"]}