@ricsam/isolate-test-utils 0.1.10 → 0.1.12

package/src/runtime-context.ts

@@ -1,148 +0,0 @@
-import { MockFileSystem } from "./mock-fs.ts";
-
-export interface MockResponse {
-  status?: number;
-  body?: string;
-  headers?: Record<string, string>;
-}
-
-export interface RuntimeTestContextOptions {
-  /** Enable file system APIs with mock file system */
-  fs?: boolean;
-}
-
-export interface RuntimeTestContext {
-  /** Execute code in the runtime (ES module mode, supports top-level await) */
-  eval(code: string): Promise<void>;
-  /** Clear all pending timers */
-  clearTimers(): void;
-  /** Dispatch an HTTP request to the serve() handler */
-  dispatchRequest(request: Request): Promise<Response>;
-  /** Dispose all resources */
-  dispose(): Promise<void>;
-  /** Captured console.log calls */
-  logs: Array<{ level: string; stdout: string }>;
-  /** Captured fetch calls */
-  fetchCalls: Array<{ url: string; method: string; headers: [string, string][] }>;
-  /** Set the mock response for the next fetch call */
-  setMockResponse(response: MockResponse): void;
-  /** Mock file system (only available if fs option is true) */
-  mockFs: MockFileSystem;
-  /**
-   * Get a result from the isolate. Call `await setResult(value)` in your eval code
-   * to pass a value back to the host.
-   */
-  getResult<T = unknown>(): T | undefined;
-  /** Clear the stored result */
-  clearResult(): void;
-}
-
-/**
- * Create a full runtime test context with all APIs set up.
- * Includes console logging capture, fetch mocking, and optionally file system.
- *
- * @example
- * const ctx = await createRuntimeTestContext({ fs: true });
- *
- * // Set up mock response for fetch
- * ctx.setMockResponse({ status: 200, body: '{"data": "test"}' });
- *
- * // Run code and pass result back via setResult
- * await ctx.eval(`
- *   console.log("Starting fetch...");
- *   const response = await fetch("https://api.example.com/data");
- *   const data = await response.json();
- *   console.log("Got data:", data);
- *   setResult(data);
- * `);
- *
- * // Get the result
- * console.log(ctx.getResult()); // { data: "test" }
- *
- * // Check logs
- * console.log(ctx.logs); // [{ level: "log", stdout: "Starting fetch..." }, ...]
- *
- * // Check fetch calls
- * console.log(ctx.fetchCalls); // [{ url: "https://api.example.com/data", method: "GET", ... }]
- *
- * await ctx.dispose();
- */
-export async function createRuntimeTestContext(
-  options?: RuntimeTestContextOptions
-): Promise<RuntimeTestContext> {
-  const opts = options ?? {};
-  const { createRuntime } = await import("@ricsam/isolate-runtime");
-  const { clearAllInstanceState } = await import("@ricsam/isolate-core");
-
-  // Clear any previous instance state
-  clearAllInstanceState();
-
-  // State for capturing logs and fetch calls
-  const logs: Array<{ level: string; stdout: string }> = [];
-  const fetchCalls: Array<{
-    url: string;
-    method: string;
-    headers: [string, string][];
-  }> = [];
-
-  let mockResponse: MockResponse = { status: 200, body: "" };
-  let storedResult: unknown = undefined;
-
-  // Create mock file system
-  const mockFs = new MockFileSystem();
-
-  // Create runtime with configured handlers
-  const runtime = await createRuntime({
-    console: {
-      onEntry: (entry) => {
-        if (entry.type === "output") {
-          logs.push({ level: entry.level, stdout: entry.stdout });
-        } else if (entry.type === "assert") {
-          logs.push({ level: "error", stdout: entry.stdout });
-        }
-      },
-    },
-    fetch: async (request: Request) => {
-      // Capture fetch call
-      fetchCalls.push({
-        url: request.url,
-        method: request.method,
-        headers: [...request.headers.entries()],
-      });
-
-      // Return mock response
-      return new Response(mockResponse.body ?? "", {
-        status: mockResponse.status ?? 200,
-        headers: mockResponse.headers,
-      });
-    },
-    fs: opts.fs ? { getDirectory: async () => mockFs } : undefined,
-    customFunctions: {
-      setResult: {
-        fn: (value: unknown) => {
-          storedResult = value;
-        },
-        type: 'sync',
-      },
-    },
-  });
-
-  return {
-    eval: runtime.eval.bind(runtime),
-    clearTimers: runtime.timers.clearAll.bind(runtime.timers),
-    dispatchRequest: runtime.fetch.dispatchRequest.bind(runtime.fetch),
-    dispose: runtime.dispose.bind(runtime),
-    logs,
-    fetchCalls,
-    setMockResponse(response: MockResponse) {
-      mockResponse = response;
-    },
-    mockFs,
-    getResult<T = unknown>(): T | undefined {
-      return storedResult as T | undefined;
-    },
-    clearResult() {
-      storedResult = undefined;
-    },
-  };
-}

package/src/server.ts

@@ -1,150 +0,0 @@
-import { createServer, type Server, type IncomingMessage, type ServerResponse } from "node:http";
-
-export interface MockServerResponse {
-  status?: number;
-  body?: string;
-  headers?: Record<string, string>;
-}
-
-export interface RecordedRequest {
-  method: string;
-  path: string;
-  headers: Record<string, string>;
-  body?: string;
-}
-
-export interface IntegrationServer {
-  /** The base URL of the server (e.g., "http://localhost:3000") */
-  url: string;
-  /** The port the server is listening on */
-  port: number;
-  /** Close the server */
-  close(): Promise<void>;
-  /** Set the response for a specific path */
-  setResponse(path: string, response: MockServerResponse): void;
-  /** Set a default response for any unmatched path */
-  setDefaultResponse(response: MockServerResponse): void;
-  /** Get all recorded requests */
-  getRequests(): RecordedRequest[];
-  /** Clear all recorded requests */
-  clearRequests(): void;
-  /** Clear all configured responses */
-  clearResponses(): void;
-}
-
-/**
- * Start an HTTP server for integration tests.
- * Useful for testing fetch operations against a real server.
- *
- * @example
- * const server = await startIntegrationServer();
- *
- * server.setResponse("/api/data", {
- *   status: 200,
- *   body: JSON.stringify({ message: "Hello" }),
- *   headers: { "Content-Type": "application/json" }
- * });
- *
- * // In your test
- * const response = await fetch(`${server.url}/api/data`);
- * const data = await response.json();
- *
- * // Check what requests were made
- * const requests = server.getRequests();
- * console.log(requests[0].path); // "/api/data"
- *
- * await server.close();
- */
-export async function startIntegrationServer(
-  port?: number
-): Promise<IntegrationServer> {
-  const responses = new Map<string, MockServerResponse>();
-  const requests: RecordedRequest[] = [];
-  let defaultResponse: MockServerResponse = { status: 404, body: "Not Found" };
-
-  const server: Server = createServer(
-    async (req: IncomingMessage, res: ServerResponse) => {
-      const path = req.url ?? "/";
-      const method = req.method ?? "GET";
-
-      // Read request body
-      const chunks: Buffer[] = [];
-      for await (const chunk of req) {
-        chunks.push(chunk as Buffer);
-      }
-      const body = chunks.length > 0 ? Buffer.concat(chunks).toString() : undefined;
-
-      // Record the request
-      const headers: Record<string, string> = {};
-      for (const [key, value] of Object.entries(req.headers)) {
-        if (typeof value === "string") {
-          headers[key] = value;
-        } else if (Array.isArray(value)) {
-          headers[key] = value.join(", ");
-        }
-      }
-      requests.push({ method, path, headers, body });
-
-      // Find and send response
-      const mockResponse = responses.get(path) ?? defaultResponse;
-
-      res.statusCode = mockResponse.status ?? 200;
-
-      if (mockResponse.headers) {
-        for (const [key, value] of Object.entries(mockResponse.headers)) {
-          res.setHeader(key, value);
-        }
-      }
-
-      res.end(mockResponse.body ?? "");
-    }
-  );
-
-  // Find an available port
-  const actualPort = await new Promise<number>((resolve, reject) => {
-    server.listen(port ?? 0, () => {
-      const address = server.address();
-      if (address && typeof address === "object") {
-        resolve(address.port);
-      } else {
-        reject(new Error("Failed to get server address"));
-      }
-    });
-    server.on("error", reject);
-  });
-
-  return {
-    url: `http://localhost:${actualPort}`,
-    port: actualPort,
-
-    async close() {
-      return new Promise((resolve, reject) => {
-        server.close((err) => {
-          if (err) reject(err);
-          else resolve();
-        });
-      });
-    },
-
-    setResponse(path: string, response: MockServerResponse) {
-      responses.set(path, response);
-    },
-
-    setDefaultResponse(response: MockServerResponse) {
-      defaultResponse = response;
-    },
-
-    getRequests() {
-      return [...requests];
-    },
-
-    clearRequests() {
-      requests.length = 0;
-    },
-
-    clearResponses() {
-      responses.clear();
-      defaultResponse = { status: 404, body: "Not Found" };
-    },
-  };
-}