@frontmcp/testing 0.5.0

package/src/http-mock/http-mock.types.d.ts

@@ -0,0 +1,124 @@
+/**
+ * @file http-mock.types.ts
+ * @description Types for HTTP request mocking (fetch/XHR interception)
+ *
+ * This module allows mocking HTTP requests made by tools during MCP server testing,
+ * enabling fully offline testing of MCP servers.
+ */
+/**
+ * HTTP method types
+ */
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+/**
+ * Request matcher - defines which requests to intercept
+ */
+export interface HttpRequestMatcher {
+    /** URL pattern - string for exact match, RegExp for pattern, or function for custom */
+    url: string | RegExp | ((url: string) => boolean);
+    /** HTTP method(s) to match (default: all methods) */
+    method?: HttpMethod | HttpMethod[];
+    /** Headers that must be present (partial match) */
+    headers?: Record<string, string | RegExp>;
+    /** Body matcher for POST/PUT/PATCH */
+    body?: string | RegExp | Record<string, unknown> | ((body: unknown) => boolean);
+}
+/**
+ * Mocked HTTP response
+ */
+export interface HttpMockResponse {
+    /** HTTP status code (default: 200) */
+    status?: number;
+    /** Status text (default: 'OK') */
+    statusText?: string;
+    /** Response headers */
+    headers?: Record<string, string>;
+    /** Response body - string, object/array (will be JSON.stringify'd), or Buffer */
+    body?: string | Record<string, unknown> | unknown[] | Buffer | ArrayBuffer;
+    /** Delay before responding in ms */
+    delay?: number;
+}
+/**
+ * HTTP mock definition
+ */
+export interface HttpMockDefinition {
+    /** Request matcher */
+    match: HttpRequestMatcher;
+    /** Response to return */
+    response: HttpMockResponse | ((request: HttpRequestInfo) => HttpMockResponse | Promise<HttpMockResponse>);
+    /** Number of times to use this mock (default: Infinity) */
+    times?: number;
+    /** Name for debugging/tracking */
+    name?: string;
+}
+/**
+ * Information about an intercepted HTTP request
+ */
+export interface HttpRequestInfo {
+    /** Full URL */
+    url: string;
+    /** HTTP method */
+    method: HttpMethod;
+    /** Request headers */
+    headers: Record<string, string>;
+    /** Request body (parsed if JSON) */
+    body?: unknown;
+    /** Raw body string */
+    rawBody?: string;
+}
+/**
+ * Handle returned when adding an HTTP mock
+ */
+export interface HttpMockHandle {
+    /** Remove this mock */
+    remove(): void;
+    /** Get call count */
+    callCount(): number;
+    /** Get all intercepted requests */
+    calls(): HttpRequestInfo[];
+    /** Wait for a specific number of calls */
+    waitForCalls(count: number, timeoutMs?: number): Promise<HttpRequestInfo[]>;
+}
+/**
+ * HTTP interceptor - controls when mocks are active
+ */
+export interface HttpInterceptor {
+    /** Add an HTTP mock */
+    mock(definition: HttpMockDefinition): HttpMockHandle;
+    /** Convenience: mock a GET request */
+    get(url: string | RegExp, response: HttpMockResponse | Record<string, unknown>): HttpMockHandle;
+    /** Convenience: mock a POST request */
+    post(url: string | RegExp, response: HttpMockResponse | Record<string, unknown>): HttpMockHandle;
+    /** Convenience: mock a PUT request */
+    put(url: string | RegExp, response: HttpMockResponse | Record<string, unknown>): HttpMockHandle;
+    /** Convenience: mock a DELETE request */
+    delete(url: string | RegExp, response: HttpMockResponse | Record<string, unknown>): HttpMockHandle;
+    /** Convenience: mock any method */
+    any(url: string | RegExp, response: HttpMockResponse | Record<string, unknown>): HttpMockHandle;
+    /** Clear all mocks in this scope */
+    clear(): void;
+    /** Get all pending (unused) mocks */
+    pending(): HttpMockDefinition[];
+    /** Check if all mocks were used */
+    isDone(): boolean;
+    /** Assert all mocks were used (throws if not) */
+    assertDone(): void;
+    /** Enable passthrough for unmatched requests (default: false, throws error) */
+    allowPassthrough(allow: boolean): void;
+    /** Restore original fetch/XHR */
+    restore(): void;
+}
+/**
+ * Global HTTP mock manager
+ */
+export interface HttpMockManager {
+    /** Create a new HTTP interceptor */
+    interceptor(): HttpInterceptor;
+    /** Enable HTTP mocking globally */
+    enable(): void;
+    /** Disable HTTP mocking and restore originals */
+    disable(): void;
+    /** Check if mocking is enabled */
+    isEnabled(): boolean;
+    /** Clear all scopes and mocks */
+    clearAll(): void;
+}

package/src/http-mock/http-mock.types.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * @file http-mock.types.ts
+ * @description Types for HTTP request mocking (fetch/XHR interception)
+ *
+ * This module allows mocking HTTP requests made by tools during MCP server testing,
+ * enabling fully offline testing of MCP servers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=http-mock.types.js.map

package/src/http-mock/http-mock.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-mock.types.js","sourceRoot":"","sources":["../../../src/http-mock/http-mock.types.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG","sourcesContent":["/**\n * @file http-mock.types.ts\n * @description Types for HTTP request mocking (fetch/XHR interception)\n *\n * This module allows mocking HTTP requests made by tools during MCP server testing,\n * enabling fully offline testing of MCP servers.\n */\n\n/**\n * HTTP method types\n */\nexport type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';\n\n/**\n * Request matcher - defines which requests to intercept\n */\nexport interface HttpRequestMatcher {\n  /** URL pattern - string for exact match, RegExp for pattern, or function for custom */\n  url: string | RegExp | ((url: string) => boolean);\n  /** HTTP method(s) to match (default: all methods) */\n  method?: HttpMethod | HttpMethod[];\n  /** Headers that must be present (partial match) */\n  headers?: Record<string, string | RegExp>;\n  /** Body matcher for POST/PUT/PATCH */\n  body?: string | RegExp | Record<string, unknown> | ((body: unknown) => boolean);\n}\n\n/**\n * Mocked HTTP response\n */\nexport interface HttpMockResponse {\n  /** HTTP status code (default: 200) */\n  status?: number;\n  /** Status text (default: 'OK') */\n  statusText?: string;\n  /** Response headers */\n  headers?: Record<string, string>;\n  /** Response body - string, object/array (will be JSON.stringify'd), or Buffer */\n  body?: string | Record<string, unknown> | unknown[] | Buffer | ArrayBuffer;\n  /** Delay before responding in ms */\n  delay?: number;\n}\n\n/**\n * HTTP mock definition\n */\nexport interface HttpMockDefinition {\n  /** Request matcher */\n  match: HttpRequestMatcher;\n  /** Response to return */\n  response: HttpMockResponse | ((request: HttpRequestInfo) => HttpMockResponse | Promise<HttpMockResponse>);\n  /** Number of times to use this mock (default: Infinity) */\n  times?: number;\n  /** Name for debugging/tracking */\n  name?: string;\n}\n\n/**\n * Information about an intercepted HTTP request\n */\nexport interface HttpRequestInfo {\n  /** Full URL */\n  url: string;\n  /** HTTP method */\n  method: HttpMethod;\n  /** Request headers */\n  headers: Record<string, string>;\n  /** Request body (parsed if JSON) */\n  body?: unknown;\n  /** Raw body string */\n  rawBody?: string;\n}\n\n/**\n * Handle returned when adding an HTTP mock\n */\nexport interface HttpMockHandle {\n  /** Remove this mock */\n  remove(): void;\n  /** Get call count */\n  callCount(): number;\n  /** Get all intercepted requests */\n  calls(): HttpRequestInfo[];\n  /** Wait for a specific number of calls */\n  waitForCalls(count: number, timeoutMs?: number): Promise<HttpRequestInfo[]>;\n}\n\n/**\n * HTTP interceptor - controls when mocks are active\n */\nexport interface HttpInterceptor {\n  /** Add an HTTP mock */\n  mock(definition: HttpMockDefinition): HttpMockHandle;\n\n  /** Convenience: mock a GET request */\n  get(url: string | RegExp, response: HttpMockResponse | Record<string, unknown>): HttpMockHandle;\n\n  /** Convenience: mock a POST request */\n  post(url: string | RegExp, response: HttpMockResponse | Record<string, unknown>): HttpMockHandle;\n\n  /** Convenience: mock a PUT request */\n  put(url: string | RegExp, response: HttpMockResponse | Record<string, unknown>): HttpMockHandle;\n\n  /** Convenience: mock a DELETE request */\n  delete(url: string | RegExp, response: HttpMockResponse | Record<string, unknown>): HttpMockHandle;\n\n  /** Convenience: mock any method */\n  any(url: string | RegExp, response: HttpMockResponse | Record<string, unknown>): HttpMockHandle;\n\n  /** Clear all mocks in this scope */\n  clear(): void;\n\n  /** Get all pending (unused) mocks */\n  pending(): HttpMockDefinition[];\n\n  /** Check if all mocks were used */\n  isDone(): boolean;\n\n  /** Assert all mocks were used (throws if not) */\n  assertDone(): void;\n\n  /** Enable passthrough for unmatched requests (default: false, throws error) */\n  allowPassthrough(allow: boolean): void;\n\n  /** Restore original fetch/XHR */\n  restore(): void;\n}\n\n/**\n * Global HTTP mock manager\n */\nexport interface HttpMockManager {\n  /** Create a new HTTP interceptor */\n  interceptor(): HttpInterceptor;\n\n  /** Enable HTTP mocking globally */\n  enable(): void;\n\n  /** Disable HTTP mocking and restore originals */\n  disable(): void;\n\n  /** Check if mocking is enabled */\n  isEnabled(): boolean;\n\n  /** Clear all scopes and mocks */\n  clearAll(): void;\n}\n"]}

package/src/http-mock/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @file index.ts
+ * @description Barrel exports for HTTP mock module
+ */
+export { httpMock, httpResponse } from './http-mock';
+export type { HttpMethod, HttpRequestMatcher, HttpMockResponse, HttpMockDefinition, HttpRequestInfo, HttpMockHandle, HttpInterceptor, HttpMockManager, } from './http-mock.types';

package/src/http-mock/index.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * @file index.ts
+ * @description Barrel exports for HTTP mock module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpResponse = exports.httpMock = void 0;
+var http_mock_1 = require("./http-mock");
+Object.defineProperty(exports, "httpMock", { enumerable: true, get: function () { return http_mock_1.httpMock; } });
+Object.defineProperty(exports, "httpResponse", { enumerable: true, get: function () { return http_mock_1.httpResponse; } });
+//# sourceMappingURL=index.js.map

package/src/http-mock/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/http-mock/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,yCAAqD;AAA5C,qGAAA,QAAQ,OAAA;AAAE,yGAAA,YAAY,OAAA","sourcesContent":["/**\n * @file index.ts\n * @description Barrel exports for HTTP mock module\n */\n\nexport { httpMock, httpResponse } from './http-mock';\n\nexport type {\n  HttpMethod,\n  HttpRequestMatcher,\n  HttpMockResponse,\n  HttpMockDefinition,\n  HttpRequestInfo,\n  HttpMockHandle,\n  HttpInterceptor,\n  HttpMockManager,\n} from './http-mock.types';\n"]}

package/src/index.d.ts

@@ -0,0 +1,65 @@
+/**
+ * @file index.ts
+ * @description Main barrel exports for @frontmcp/testing
+ *
+ * @example Quick Start with Fixtures
+ * ```typescript
+ * import { test, expect } from '@frontmcp/testing';
+ *
+ * test.use({
+ *   server: './src/main.ts',
+ *   port: 3003,
+ * });
+ *
+ * test('server exposes tools', async ({ mcp }) => {
+ *   const tools = await mcp.tools.list();
+ *   expect(tools).toContainTool('my-tool');
+ * });
+ *
+ * test('tool execution works', async ({ mcp }) => {
+ *   const result = await mcp.tools.call('my-tool', { input: 'test' });
+ *   expect(result).toBeSuccessful();
+ * });
+ * ```
+ *
+ * @example Manual Client Usage
+ * ```typescript
+ * import { McpTestClient, TestServer } from '@frontmcp/testing';
+ *
+ * const server = await TestServer.start({ command: 'npx tsx src/main.ts' });
+ * const client = await McpTestClient.create({ baseUrl: server.info.baseUrl })
+ *   .withTransport('streamable-http')
+ *   .buildAndConnect();
+ *
+ * const tools = await client.tools.list();
+ * console.log(tools);
+ *
+ * await client.disconnect();
+ * await server.stop();
+ * ```
+ */
+export { McpTestClient } from './client/mcp-test-client';
+export { McpTestClientBuilder } from './client/mcp-test-client.builder';
+export type { McpTestClientConfig, McpResponse, McpErrorInfo, TestTransportType, TestAuthConfig, ToolResultWrapper, ResourceContentWrapper, PromptResultWrapper, LogEntry, LogLevel, RequestTrace, NotificationEntry, ProgressUpdate, SessionInfo, AuthState, } from './client/mcp-test-client.types';
+export type { McpTransport, TransportConfig, TransportState } from './transport/transport.interface';
+export { StreamableHttpTransport } from './transport/streamable-http.transport';
+export { TestTokenFactory } from './auth/token-factory';
+export type { CreateTokenOptions, TokenFactoryOptions } from './auth/token-factory';
+export { AuthHeaders } from './auth/auth-headers';
+export { TestUsers, createTestUser } from './auth/user-fixtures';
+export type { TestUserFixture } from './auth/user-fixtures';
+export { TestServer } from './server/test-server';
+export type { TestServerOptions, TestServerInfo } from './server/test-server';
+export { McpAssertions, containsTool, containsResource, containsResourceTemplate, containsPrompt, isSuccessful, isError, hasTextContent, hasMimeType, } from './assertions/mcp-assertions';
+export { TestClientError, ConnectionError, TimeoutError, McpProtocolError, ServerStartError, AssertionError, } from './errors/index';
+export type { InitializeResult, ListToolsResult, CallToolResult, ListResourcesResult, ReadResourceResult, ListResourceTemplatesResult, ListPromptsResult, GetPromptResult, Tool, Resource, ResourceTemplate, Prompt, JSONRPCRequest, JSONRPCResponse, } from './client/mcp-test-client.types';
+export { test } from './fixtures';
+export type { TestConfig, TestFixtures, AuthFixture, ServerFixture, TestFn, TestWithFixtures, TestUser, } from './fixtures';
+export { expect } from './expect';
+export { mcpMatchers } from './matchers';
+export type { McpMatchers } from './matchers';
+export { DefaultMockRegistry, DefaultInterceptorChain, mockResponse, interceptors } from './interceptor';
+export type { InterceptorContext, InterceptorResult, RequestInterceptor, ResponseInterceptorContext, ResponseInterceptorResult, ResponseInterceptor, MockDefinition, MockRegistry, MockHandle, InterceptorChain, } from './interceptor';
+export { httpMock, httpResponse } from './http-mock';
+export type { HttpMethod, HttpRequestMatcher, HttpMockResponse, HttpMockDefinition, HttpRequestInfo, HttpMockHandle, HttpInterceptor, HttpMockManager, } from './http-mock';
+export { uiMatchers, UIAssertions } from './ui';

package/src/index.js

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * @file index.ts
+ * @description Main barrel exports for @frontmcp/testing
+ *
+ * @example Quick Start with Fixtures
+ * ```typescript
+ * import { test, expect } from '@frontmcp/testing';
+ *
+ * test.use({
+ *   server: './src/main.ts',
+ *   port: 3003,
+ * });
+ *
+ * test('server exposes tools', async ({ mcp }) => {
+ *   const tools = await mcp.tools.list();
+ *   expect(tools).toContainTool('my-tool');
+ * });
+ *
+ * test('tool execution works', async ({ mcp }) => {
+ *   const result = await mcp.tools.call('my-tool', { input: 'test' });
+ *   expect(result).toBeSuccessful();
+ * });
+ * ```
+ *
+ * @example Manual Client Usage
+ * ```typescript
+ * import { McpTestClient, TestServer } from '@frontmcp/testing';
+ *
+ * const server = await TestServer.start({ command: 'npx tsx src/main.ts' });
+ * const client = await McpTestClient.create({ baseUrl: server.info.baseUrl })
+ *   .withTransport('streamable-http')
+ *   .buildAndConnect();
+ *
+ * const tools = await client.tools.list();
+ * console.log(tools);
+ *
+ * await client.disconnect();
+ * await server.stop();
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UIAssertions = exports.uiMatchers = exports.httpResponse = exports.httpMock = exports.interceptors = exports.mockResponse = exports.DefaultInterceptorChain = exports.DefaultMockRegistry = exports.mcpMatchers = exports.expect = exports.test = exports.AssertionError = exports.ServerStartError = exports.McpProtocolError = exports.TimeoutError = exports.ConnectionError = exports.TestClientError = exports.hasMimeType = exports.hasTextContent = exports.isError = exports.isSuccessful = exports.containsPrompt = exports.containsResourceTemplate = exports.containsResource = exports.containsTool = exports.McpAssertions = exports.TestServer = exports.createTestUser = exports.TestUsers = exports.AuthHeaders = exports.TestTokenFactory = exports.StreamableHttpTransport = exports.McpTestClientBuilder = exports.McpTestClient = void 0;
+// ═══════════════════════════════════════════════════════════════════
+// CLIENT
+// ═══════════════════════════════════════════════════════════════════
+var mcp_test_client_1 = require("./client/mcp-test-client");
+Object.defineProperty(exports, "McpTestClient", { enumerable: true, get: function () { return mcp_test_client_1.McpTestClient; } });
+var mcp_test_client_builder_1 = require("./client/mcp-test-client.builder");
+Object.defineProperty(exports, "McpTestClientBuilder", { enumerable: true, get: function () { return mcp_test_client_builder_1.McpTestClientBuilder; } });
+var streamable_http_transport_1 = require("./transport/streamable-http.transport");
+Object.defineProperty(exports, "StreamableHttpTransport", { enumerable: true, get: function () { return streamable_http_transport_1.StreamableHttpTransport; } });
+// ═══════════════════════════════════════════════════════════════════
+// AUTH
+// ═══════════════════════════════════════════════════════════════════
+var token_factory_1 = require("./auth/token-factory");
+Object.defineProperty(exports, "TestTokenFactory", { enumerable: true, get: function () { return token_factory_1.TestTokenFactory; } });
+var auth_headers_1 = require("./auth/auth-headers");
+Object.defineProperty(exports, "AuthHeaders", { enumerable: true, get: function () { return auth_headers_1.AuthHeaders; } });
+var user_fixtures_1 = require("./auth/user-fixtures");
+Object.defineProperty(exports, "TestUsers", { enumerable: true, get: function () { return user_fixtures_1.TestUsers; } });
+Object.defineProperty(exports, "createTestUser", { enumerable: true, get: function () { return user_fixtures_1.createTestUser; } });
+// ═══════════════════════════════════════════════════════════════════
+// SERVER
+// ═══════════════════════════════════════════════════════════════════
+var test_server_1 = require("./server/test-server");
+Object.defineProperty(exports, "TestServer", { enumerable: true, get: function () { return test_server_1.TestServer; } });
+// ═══════════════════════════════════════════════════════════════════
+// ASSERTIONS
+// ═══════════════════════════════════════════════════════════════════
+var mcp_assertions_1 = require("./assertions/mcp-assertions");
+Object.defineProperty(exports, "McpAssertions", { enumerable: true, get: function () { return mcp_assertions_1.McpAssertions; } });
+Object.defineProperty(exports, "containsTool", { enumerable: true, get: function () { return mcp_assertions_1.containsTool; } });
+Object.defineProperty(exports, "containsResource", { enumerable: true, get: function () { return mcp_assertions_1.containsResource; } });
+Object.defineProperty(exports, "containsResourceTemplate", { enumerable: true, get: function () { return mcp_assertions_1.containsResourceTemplate; } });
+Object.defineProperty(exports, "containsPrompt", { enumerable: true, get: function () { return mcp_assertions_1.containsPrompt; } });
+Object.defineProperty(exports, "isSuccessful", { enumerable: true, get: function () { return mcp_assertions_1.isSuccessful; } });
+Object.defineProperty(exports, "isError", { enumerable: true, get: function () { return mcp_assertions_1.isError; } });
+Object.defineProperty(exports, "hasTextContent", { enumerable: true, get: function () { return mcp_assertions_1.hasTextContent; } });
+Object.defineProperty(exports, "hasMimeType", { enumerable: true, get: function () { return mcp_assertions_1.hasMimeType; } });
+// ═══════════════════════════════════════════════════════════════════
+// ERRORS
+// ═══════════════════════════════════════════════════════════════════
+var index_1 = require("./errors/index");
+Object.defineProperty(exports, "TestClientError", { enumerable: true, get: function () { return index_1.TestClientError; } });
+Object.defineProperty(exports, "ConnectionError", { enumerable: true, get: function () { return index_1.ConnectionError; } });
+Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function () { return index_1.TimeoutError; } });
+Object.defineProperty(exports, "McpProtocolError", { enumerable: true, get: function () { return index_1.McpProtocolError; } });
+Object.defineProperty(exports, "ServerStartError", { enumerable: true, get: function () { return index_1.ServerStartError; } });
+Object.defineProperty(exports, "AssertionError", { enumerable: true, get: function () { return index_1.AssertionError; } });
+// ═══════════════════════════════════════════════════════════════════
+// FIXTURES (Primary API)
+// ═══════════════════════════════════════════════════════════════════
+var fixtures_1 = require("./fixtures");
+Object.defineProperty(exports, "test", { enumerable: true, get: function () { return fixtures_1.test; } });
+// ═══════════════════════════════════════════════════════════════════
+// EXPECT (Primary API)
+// ═══════════════════════════════════════════════════════════════════
+// Export the pre-typed expect with MCP matchers (Playwright-style approach)
+// This provides proper typing without relying on global namespace augmentation
+var expect_1 = require("./expect");
+Object.defineProperty(exports, "expect", { enumerable: true, get: function () { return expect_1.expect; } });
+// ═══════════════════════════════════════════════════════════════════
+// CUSTOM MATCHERS
+// ═══════════════════════════════════════════════════════════════════
+var matchers_1 = require("./matchers");
+Object.defineProperty(exports, "mcpMatchers", { enumerable: true, get: function () { return matchers_1.mcpMatchers; } });
+// ═══════════════════════════════════════════════════════════════════
+// INTERCEPTORS & MOCKING
+// ═══════════════════════════════════════════════════════════════════
+var interceptor_1 = require("./interceptor");
+Object.defineProperty(exports, "DefaultMockRegistry", { enumerable: true, get: function () { return interceptor_1.DefaultMockRegistry; } });
+Object.defineProperty(exports, "DefaultInterceptorChain", { enumerable: true, get: function () { return interceptor_1.DefaultInterceptorChain; } });
+Object.defineProperty(exports, "mockResponse", { enumerable: true, get: function () { return interceptor_1.mockResponse; } });
+Object.defineProperty(exports, "interceptors", { enumerable: true, get: function () { return interceptor_1.interceptors; } });
+// ═══════════════════════════════════════════════════════════════════
+// HTTP MOCKING (for offline testing)
+// ═══════════════════════════════════════════════════════════════════
+var http_mock_1 = require("./http-mock");
+Object.defineProperty(exports, "httpMock", { enumerable: true, get: function () { return http_mock_1.httpMock; } });
+Object.defineProperty(exports, "httpResponse", { enumerable: true, get: function () { return http_mock_1.httpResponse; } });
+// ═══════════════════════════════════════════════════════════════════
+// UI TESTING
+// ═══════════════════════════════════════════════════════════════════
+var ui_1 = require("./ui");
+Object.defineProperty(exports, "uiMatchers", { enumerable: true, get: function () { return ui_1.uiMatchers; } });
+Object.defineProperty(exports, "UIAssertions", { enumerable: true, get: function () { return ui_1.UIAssertions; } });
+//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;;;AAEH,sEAAsE;AACtE,SAAS;AACT,sEAAsE;AAEtE,4DAAyD;AAAhD,gHAAA,aAAa,OAAA;AACtB,4EAAwE;AAA/D,+HAAA,oBAAoB,OAAA;AAwB7B,mFAAgF;AAAvE,oIAAA,uBAAuB,OAAA;AAEhC,sEAAsE;AACtE,OAAO;AACP,sEAAsE;AAEtE,sDAAwD;AAA/C,iHAAA,gBAAgB,OAAA;AAEzB,oDAAkD;AAAzC,2GAAA,WAAW,OAAA;AACpB,sDAAiE;AAAxD,0GAAA,SAAS,OAAA;AAAE,+GAAA,cAAc,OAAA;AAGlC,sEAAsE;AACtE,SAAS;AACT,sEAAsE;AAEtE,oDAAkD;AAAzC,yGAAA,UAAU,OAAA;AAGnB,sEAAsE;AACtE,aAAa;AACb,sEAAsE;AAEtE,8DAUqC;AATnC,+GAAA,aAAa,OAAA;AACb,8GAAA,YAAY,OAAA;AACZ,kHAAA,gBAAgB,OAAA;AAChB,0HAAA,wBAAwB,OAAA;AACxB,gHAAA,cAAc,OAAA;AACd,8GAAA,YAAY,OAAA;AACZ,yGAAA,OAAO,OAAA;AACP,gHAAA,cAAc,OAAA;AACd,6GAAA,WAAW,OAAA;AAGb,sEAAsE;AACtE,SAAS;AACT,sEAAsE;AAEtE,wCAOwB;AANtB,wGAAA,eAAe,OAAA;AACf,wGAAA,eAAe,OAAA;AACf,qGAAA,YAAY,OAAA;AACZ,yGAAA,gBAAgB,OAAA;AAChB,yGAAA,gBAAgB,OAAA;AAChB,uGAAA,cAAc,OAAA;AAyBhB,sEAAsE;AACtE,yBAAyB;AACzB,sEAAsE;AAEtE,uCAAkC;AAAzB,gGAAA,IAAI,OAAA;AAWb,sEAAsE;AACtE,uBAAuB;AACvB,sEAAsE;AAEtE,4EAA4E;AAC5E,+EAA+E;AAC/E,mCAAkC;AAAzB,gGAAA,MAAM,OAAA;AAEf,sEAAsE;AACtE,kBAAkB;AAClB,sEAAsE;AAEtE,uCAAyC;AAAhC,uGAAA,WAAW,OAAA;AAGpB,sEAAsE;AACtE,yBAAyB;AACzB,sEAAsE;AAEtE,6CAAyG;AAAhG,kHAAA,mBAAmB,OAAA;AAAE,sHAAA,uBAAuB,OAAA;AAAE,2GAAA,YAAY,OAAA;AAAE,2GAAA,YAAY,OAAA;AAejF,sEAAsE;AACtE,qCAAqC;AACrC,sEAAsE;AAEtE,yCAAqD;AAA5C,qGAAA,QAAQ,OAAA;AAAE,yGAAA,YAAY,OAAA;AAa/B,sEAAsE;AACtE,aAAa;AACb,sEAAsE;AAEtE,2BAAgD;AAAvC,gGAAA,UAAU,OAAA;AAAE,kGAAA,YAAY,OAAA","sourcesContent":["/**\n * @file index.ts\n * @description Main barrel exports for @frontmcp/testing\n *\n * @example Quick Start with Fixtures\n * ```typescript\n * import { test, expect } from '@frontmcp/testing';\n *\n * test.use({\n *   server: './src/main.ts',\n *   port: 3003,\n * });\n *\n * test('server exposes tools', async ({ mcp }) => {\n *   const tools = await mcp.tools.list();\n *   expect(tools).toContainTool('my-tool');\n * });\n *\n * test('tool execution works', async ({ mcp }) => {\n *   const result = await mcp.tools.call('my-tool', { input: 'test' });\n *   expect(result).toBeSuccessful();\n * });\n * ```\n *\n * @example Manual Client Usage\n * ```typescript\n * import { McpTestClient, TestServer } from '@frontmcp/testing';\n *\n * const server = await TestServer.start({ command: 'npx tsx src/main.ts' });\n * const client = await McpTestClient.create({ baseUrl: server.info.baseUrl })\n *   .withTransport('streamable-http')\n *   .buildAndConnect();\n *\n * const tools = await client.tools.list();\n * console.log(tools);\n *\n * await client.disconnect();\n * await server.stop();\n * ```\n */\n\n// ═══════════════════════════════════════════════════════════════════\n// CLIENT\n// ═══════════════════════════════════════════════════════════════════\n\nexport { McpTestClient } from './client/mcp-test-client';\nexport { McpTestClientBuilder } from './client/mcp-test-client.builder';\nexport type {\n  McpTestClientConfig,\n  McpResponse,\n  McpErrorInfo,\n  TestTransportType,\n  TestAuthConfig,\n  ToolResultWrapper,\n  ResourceContentWrapper,\n  PromptResultWrapper,\n  LogEntry,\n  LogLevel,\n  RequestTrace,\n  NotificationEntry,\n  ProgressUpdate,\n  SessionInfo,\n  AuthState,\n} from './client/mcp-test-client.types';\n\n// ═══════════════════════════════════════════════════════════════════\n// TRANSPORT\n// ═══════════════════════════════════════════════════════════════════\n\nexport type { McpTransport, TransportConfig, TransportState } from './transport/transport.interface';\nexport { StreamableHttpTransport } from './transport/streamable-http.transport';\n\n// ═══════════════════════════════════════════════════════════════════\n// AUTH\n// ═══════════════════════════════════════════════════════════════════\n\nexport { TestTokenFactory } from './auth/token-factory';\nexport type { CreateTokenOptions, TokenFactoryOptions } from './auth/token-factory';\nexport { AuthHeaders } from './auth/auth-headers';\nexport { TestUsers, createTestUser } from './auth/user-fixtures';\nexport type { TestUserFixture } from './auth/user-fixtures';\n\n// ═══════════════════════════════════════════════════════════════════\n// SERVER\n// ═══════════════════════════════════════════════════════════════════\n\nexport { TestServer } from './server/test-server';\nexport type { TestServerOptions, TestServerInfo } from './server/test-server';\n\n// ═══════════════════════════════════════════════════════════════════\n// ASSERTIONS\n// ═══════════════════════════════════════════════════════════════════\n\nexport {\n  McpAssertions,\n  containsTool,\n  containsResource,\n  containsResourceTemplate,\n  containsPrompt,\n  isSuccessful,\n  isError,\n  hasTextContent,\n  hasMimeType,\n} from './assertions/mcp-assertions';\n\n// ═══════════════════════════════════════════════════════════════════\n// ERRORS\n// ═══════════════════════════════════════════════════════════════════\n\nexport {\n  TestClientError,\n  ConnectionError,\n  TimeoutError,\n  McpProtocolError,\n  ServerStartError,\n  AssertionError,\n} from './errors/index';\n\n// ═══════════════════════════════════════════════════════════════════\n// RE-EXPORTS FROM MCP SDK\n// ═══════════════════════════════════════════════════════════════════\n\nexport type {\n  InitializeResult,\n  ListToolsResult,\n  CallToolResult,\n  ListResourcesResult,\n  ReadResourceResult,\n  ListResourceTemplatesResult,\n  ListPromptsResult,\n  GetPromptResult,\n  Tool,\n  Resource,\n  ResourceTemplate,\n  Prompt,\n  // JSON-RPC types\n  JSONRPCRequest,\n  JSONRPCResponse,\n} from './client/mcp-test-client.types';\n\n// ═══════════════════════════════════════════════════════════════════\n// FIXTURES (Primary API)\n// ═══════════════════════════════════════════════════════════════════\n\nexport { test } from './fixtures';\nexport type {\n  TestConfig,\n  TestFixtures,\n  AuthFixture,\n  ServerFixture,\n  TestFn,\n  TestWithFixtures,\n  TestUser,\n} from './fixtures';\n\n// ═══════════════════════════════════════════════════════════════════\n// EXPECT (Primary API)\n// ═══════════════════════════════════════════════════════════════════\n\n// Export the pre-typed expect with MCP matchers (Playwright-style approach)\n// This provides proper typing without relying on global namespace augmentation\nexport { expect } from './expect';\n\n// ═══════════════════════════════════════════════════════════════════\n// CUSTOM MATCHERS\n// ═══════════════════════════════════════════════════════════════════\n\nexport { mcpMatchers } from './matchers';\nexport type { McpMatchers } from './matchers';\n\n// ═══════════════════════════════════════════════════════════════════\n// INTERCEPTORS & MOCKING\n// ═══════════════════════════════════════════════════════════════════\n\nexport { DefaultMockRegistry, DefaultInterceptorChain, mockResponse, interceptors } from './interceptor';\n\nexport type {\n  InterceptorContext,\n  InterceptorResult,\n  RequestInterceptor,\n  ResponseInterceptorContext,\n  ResponseInterceptorResult,\n  ResponseInterceptor,\n  MockDefinition,\n  MockRegistry,\n  MockHandle,\n  InterceptorChain,\n} from './interceptor';\n\n// ═══════════════════════════════════════════════════════════════════\n// HTTP MOCKING (for offline testing)\n// ═══════════════════════════════════════════════════════════════════\n\nexport { httpMock, httpResponse } from './http-mock';\n\nexport type {\n  HttpMethod,\n  HttpRequestMatcher,\n  HttpMockResponse,\n  HttpMockDefinition,\n  HttpRequestInfo,\n  HttpMockHandle,\n  HttpInterceptor,\n  HttpMockManager,\n} from './http-mock';\n\n// ═══════════════════════════════════════════════════════════════════\n// UI TESTING\n// ═══════════════════════════════════════════════════════════════════\n\nexport { uiMatchers, UIAssertions } from './ui';\n"]}

package/src/interceptor/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @file index.ts
+ * @description Barrel exports for interceptor module
+ */
+export type { InterceptorContext, InterceptorResult, RequestInterceptor, ResponseInterceptorContext, ResponseInterceptorResult, ResponseInterceptor, MockDefinition, MockRegistry, MockHandle, InterceptorChain, } from './interceptor.types';
+export { DefaultMockRegistry, mockResponse } from './mock-registry';
+export { DefaultInterceptorChain, interceptors } from './interceptor-chain';

package/src/interceptor/index.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * @file index.ts
+ * @description Barrel exports for interceptor module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interceptors = exports.DefaultInterceptorChain = exports.mockResponse = exports.DefaultMockRegistry = void 0;
+// Classes
+var mock_registry_1 = require("./mock-registry");
+Object.defineProperty(exports, "DefaultMockRegistry", { enumerable: true, get: function () { return mock_registry_1.DefaultMockRegistry; } });
+Object.defineProperty(exports, "mockResponse", { enumerable: true, get: function () { return mock_registry_1.mockResponse; } });
+var interceptor_chain_1 = require("./interceptor-chain");
+Object.defineProperty(exports, "DefaultInterceptorChain", { enumerable: true, get: function () { return interceptor_chain_1.DefaultInterceptorChain; } });
+Object.defineProperty(exports, "interceptors", { enumerable: true, get: function () { return interceptor_chain_1.interceptors; } });
+//# sourceMappingURL=index.js.map

package/src/interceptor/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/interceptor/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAgBH,UAAU;AACV,iDAAoE;AAA3D,oHAAA,mBAAmB,OAAA;AAAE,6GAAA,YAAY,OAAA;AAC1C,yDAA4E;AAAnE,4HAAA,uBAAuB,OAAA;AAAE,iHAAA,YAAY,OAAA","sourcesContent":["/**\n * @file index.ts\n * @description Barrel exports for interceptor module\n */\n\n// Types\nexport type {\n  InterceptorContext,\n  InterceptorResult,\n  RequestInterceptor,\n  ResponseInterceptorContext,\n  ResponseInterceptorResult,\n  ResponseInterceptor,\n  MockDefinition,\n  MockRegistry,\n  MockHandle,\n  InterceptorChain,\n} from './interceptor.types';\n\n// Classes\nexport { DefaultMockRegistry, mockResponse } from './mock-registry';\nexport { DefaultInterceptorChain, interceptors } from './interceptor-chain';\n"]}

package/src/interceptor/interceptor-chain.d.ts

@@ -0,0 +1,77 @@
+/**
+ * @file interceptor-chain.ts
+ * @description Interceptor chain for request/response interception
+ */
+import type { JsonRpcRequest, JsonRpcResponse } from '../transport/transport.interface';
+import type { InterceptorChain, RequestInterceptor, ResponseInterceptor, InterceptorContext, MockRegistry } from './interceptor.types';
+/**
+ * Default implementation of InterceptorChain
+ */
+export declare class DefaultInterceptorChain implements InterceptorChain {
+    request: RequestInterceptor[];
+    response: ResponseInterceptor[];
+    mocks: MockRegistry;
+    constructor();
+    /**
+     * Add a request interceptor
+     */
+    addRequestInterceptor(interceptor: RequestInterceptor): () => void;
+    /**
+     * Add a response interceptor
+     */
+    addResponseInterceptor(interceptor: ResponseInterceptor): () => void;
+    /**
+     * Process a request through the interceptor chain
+     * Returns either:
+     * - { type: 'continue', request } - continue with (possibly modified) request
+     * - { type: 'mock', response } - return mock response immediately
+     * - { type: 'error', error } - throw error
+     */
+    processRequest(request: JsonRpcRequest, meta: InterceptorContext['meta']): Promise<{
+        type: 'continue';
+        request: JsonRpcRequest;
+    } | {
+        type: 'mock';
+        response: JsonRpcResponse;
+    } | {
+        type: 'error';
+        error: Error;
+    }>;
+    /**
+     * Process a response through the interceptor chain
+     */
+    processResponse(request: JsonRpcRequest, response: JsonRpcResponse, durationMs: number): Promise<JsonRpcResponse>;
+    /**
+     * Clear all interceptors and mocks
+     */
+    clear(): void;
+}
+/**
+ * Convenience interceptor creators
+ */
+export declare const interceptors: {
+    /**
+     * Create an interceptor that logs all requests
+     */
+    logger(logFn?: (message: string, data?: unknown) => void): RequestInterceptor;
+    /**
+     * Create an interceptor that adds latency to all requests
+     */
+    delay(ms: number): RequestInterceptor;
+    /**
+     * Create an interceptor that fails requests matching a condition
+     */
+    failWhen(condition: (ctx: InterceptorContext) => boolean, error: Error | string): RequestInterceptor;
+    /**
+     * Create an interceptor that modifies specific methods
+     */
+    modifyMethod(method: string, modifier: (request: JsonRpcRequest) => JsonRpcRequest): RequestInterceptor;
+    /**
+     * Create a response interceptor that logs responses
+     */
+    responseLogger(logFn?: (message: string, data?: unknown) => void): ResponseInterceptor;
+    /**
+     * Create a response interceptor that modifies specific responses
+     */
+    modifyResponse(method: string, modifier: (response: JsonRpcResponse) => JsonRpcResponse): ResponseInterceptor;
+};