@ricsam/isolate-test-utils 0.1.9 → 0.1.11

package/src/index.test.ts

@@ -1,472 +0,0 @@
-import { test, describe, afterEach } from "node:test";
-import assert from "node:assert";
-import {
-  createTestContext,
-  createCoreTestContext,
-  evalCode,
-  evalCodeAsync,
-  evalCodeJson,
-  evalCodeJsonAsync,
-  injectGlobals,
-  MockFileSystem,
-  createFsTestContext,
-  createRuntimeTestContext,
-  startIntegrationServer,
-  type TestContext,
-  type FsTestContext,
-  type RuntimeTestContext,
-  type IntegrationServer,
-} from "./index.ts";
-
-// ============================================================================
-// createTestContext tests
-// ============================================================================
-
-describe("createTestContext", () => {
-  let ctx: TestContext | undefined;
-
-  afterEach(() => {
-    ctx?.dispose();
-    ctx = undefined;
-  });
-
-  test("creates a basic context", async () => {
-    ctx = await createTestContext();
-    assert.ok(ctx.isolate);
-    assert.ok(ctx.context);
-    assert.ok(typeof ctx.dispose === "function");
-  });
-
-  test("can evaluate code in context", async () => {
-    ctx = await createTestContext();
-    const result = ctx.context.evalSync("1 + 1");
-    assert.strictEqual(result, 2);
-  });
-});
-
-describe("createCoreTestContext", () => {
-  let ctx: TestContext | undefined;
-
-  afterEach(() => {
-    ctx?.dispose();
-    ctx = undefined;
-  });
-
-  test("creates a context with core APIs", async () => {
-    ctx = await createCoreTestContext();
-    assert.ok(ctx.isolate);
-    assert.ok(ctx.context);
-  });
-
-  test("has Blob available", async () => {
-    ctx = await createCoreTestContext();
-    const result = ctx.context.evalSync("typeof Blob");
-    assert.strictEqual(result, "function");
-  });
-
-  test("has URL available", async () => {
-    ctx = await createCoreTestContext();
-    const result = ctx.context.evalSync(
-      "new URL('https://example.com').hostname"
-    );
-    assert.strictEqual(result, "example.com");
-  });
-});
-
-// ============================================================================
-// evalCode tests
-// ============================================================================
-
-describe("evalCode", () => {
-  let ctx: TestContext | undefined;
-
-  afterEach(() => {
-    ctx?.dispose();
-    ctx = undefined;
-  });
-
-  test("evaluates code synchronously", async () => {
-    ctx = await createTestContext();
-    const result = evalCode<number>(ctx.context, "2 + 3");
-    assert.strictEqual(result, 5);
-  });
-
-  test("returns string", async () => {
-    ctx = await createTestContext();
-    const result = evalCode<string>(ctx.context, '"hello"');
-    assert.strictEqual(result, "hello");
-  });
-});
-
-describe("evalCodeAsync", () => {
-  let ctx: TestContext | undefined;
-
-  afterEach(() => {
-    ctx?.dispose();
-    ctx = undefined;
-  });
-
-  test("evaluates async code", async () => {
-    ctx = await createTestContext();
-    const result = await evalCodeAsync<number>(
-      ctx.context,
-      "Promise.resolve(42)"
-    );
-    assert.strictEqual(result, 42);
-  });
-
-  test("handles async IIFE", async () => {
-    ctx = await createTestContext();
-    const result = await evalCodeAsync<string>(
-      ctx.context,
-      `(async () => { return "async result"; })()`
-    );
-    assert.strictEqual(result, "async result");
-  });
-});
-
-describe("evalCodeJson", () => {
-  let ctx: TestContext | undefined;
-
-  afterEach(() => {
-    ctx?.dispose();
-    ctx = undefined;
-  });
-
-  test("parses JSON result", async () => {
-    ctx = await createTestContext();
-    const result = evalCodeJson<{ name: string }>(
-      ctx.context,
-      'JSON.stringify({ name: "test" })'
-    );
-    assert.deepStrictEqual(result, { name: "test" });
-  });
-});
-
-describe("evalCodeJsonAsync", () => {
-  let ctx: TestContext | undefined;
-
-  afterEach(() => {
-    ctx?.dispose();
-    ctx = undefined;
-  });
-
-  test("parses async JSON result", async () => {
-    ctx = await createTestContext();
-    const result = await evalCodeJsonAsync<{ value: number }>(
-      ctx.context,
-      `(async () => JSON.stringify({ value: 123 }))()`
-    );
-    assert.deepStrictEqual(result, { value: 123 });
-  });
-});
-
-describe("injectGlobals", () => {
-  let ctx: TestContext | undefined;
-
-  afterEach(() => {
-    ctx?.dispose();
-    ctx = undefined;
-  });
-
-  test("injects primitive values", async () => {
-    ctx = await createTestContext();
-    await injectGlobals(ctx.context, {
-      testString: "hello",
-      testNumber: 42,
-      testBool: true,
-    });
-    assert.strictEqual(evalCode<string>(ctx.context, "testString"), "hello");
-    assert.strictEqual(evalCode<number>(ctx.context, "testNumber"), 42);
-    assert.strictEqual(evalCode<boolean>(ctx.context, "testBool"), true);
-  });
-
-  test("injects objects", async () => {
-    ctx = await createTestContext();
-    await injectGlobals(ctx.context, {
-      testConfig: { debug: true, level: 3 },
-    });
-    const result = evalCodeJson<{ debug: boolean; level: number }>(
-      ctx.context,
-      "JSON.stringify(testConfig)"
-    );
-    assert.deepStrictEqual(result, { debug: true, level: 3 });
-  });
-});
-
-// ============================================================================
-// MockFileSystem tests
-// ============================================================================
-
-describe("MockFileSystem", () => {
-  test("creates empty file system with root directory", () => {
-    const fs = new MockFileSystem();
-    assert.strictEqual(fs.directories.has("/"), true);
-    assert.strictEqual(fs.files.size, 0);
-  });
-
-  test("setFile creates file with content", async () => {
-    const fs = new MockFileSystem();
-    fs.setFile("/test.txt", "Hello, World!");
-
-    const file = await fs.readFile("/test.txt");
-    assert.strictEqual(new TextDecoder().decode(file.data), "Hello, World!");
-  });
-
-  test("getFile retrieves file content", () => {
-    const fs = new MockFileSystem();
-    fs.setFile("/test.txt", "content");
-
-    const data = fs.getFile("/test.txt");
-    assert.ok(data);
-    assert.strictEqual(new TextDecoder().decode(data), "content");
-  });
-
-  test("getFileAsString retrieves file as string", () => {
-    const fs = new MockFileSystem();
-    fs.setFile("/test.txt", "string content");
-
-    const content = fs.getFileAsString("/test.txt");
-    assert.strictEqual(content, "string content");
-  });
-
-  test("createDirectory creates nested directories", () => {
-    const fs = new MockFileSystem();
-    fs.createDirectory("/a/b/c");
-
-    assert.strictEqual(fs.directories.has("/a"), true);
-    assert.strictEqual(fs.directories.has("/a/b"), true);
-    assert.strictEqual(fs.directories.has("/a/b/c"), true);
-  });
-
-  test("reset clears all files and directories", async () => {
-    const fs = new MockFileSystem();
-    fs.setFile("/test.txt", "content");
-    fs.createDirectory("/dir");
-
-    fs.reset();
-
-    assert.strictEqual(fs.files.size, 0);
-    assert.strictEqual(fs.directories.size, 1); // Only root
-    assert.strictEqual(fs.directories.has("/"), true);
-  });
-
-  test("getFileHandle throws NotFoundError for missing file", async () => {
-    const fs = new MockFileSystem();
-    await assert.rejects(
-      fs.getFileHandle("/missing.txt"),
-      /NotFoundError/
-    );
-  });
-
-  test("getFileHandle creates file with create option", async () => {
-    const fs = new MockFileSystem();
-    await fs.getFileHandle("/new.txt", { create: true });
-    assert.strictEqual(fs.files.has("/new.txt"), true);
-  });
-
-  test("readDirectory lists files and directories", async () => {
-    const fs = new MockFileSystem();
-    fs.setFile("/file1.txt", "content");
-    fs.setFile("/file2.txt", "content");
-    fs.createDirectory("/subdir");
-
-    const entries = await fs.readDirectory("/");
-    assert.strictEqual(entries.length, 3);
-
-    const names = entries.map((e) => e.name).sort();
-    assert.deepStrictEqual(names, ["file1.txt", "file2.txt", "subdir"]);
-  });
-});
-
-// ============================================================================
-// createFsTestContext tests
-// ============================================================================
-
-describe("createFsTestContext", () => {
-  let ctx: FsTestContext | undefined;
-
-  afterEach(() => {
-    ctx?.dispose();
-    ctx = undefined;
-  });
-
-  test("creates context with file system APIs", async () => {
-    ctx = await createFsTestContext();
-    assert.ok(ctx.isolate);
-    assert.ok(ctx.context);
-    assert.ok(ctx.mockFs);
-  });
-
-  test("mockFs is connected to context", async () => {
-    ctx = await createFsTestContext();
-
-    // Create a file in mockFs
-    ctx.mockFs.setFile("/test.txt", "Hello from test!");
-
-    // Read it from the isolate
-    const result = await ctx.context.eval(
-      `
-      (async () => {
-        const root = await getDirectory('/');
-        const fileHandle = await root.getFileHandle("test.txt");
-        const file = await fileHandle.getFile();
-        return await file.text();
-      })()
-    `,
-      { promise: true }
-    );
-
-    assert.strictEqual(result, "Hello from test!");
-  });
-});
-
-// ============================================================================
-// createRuntimeTestContext tests
-// ============================================================================
-
-describe("createRuntimeTestContext", () => {
-  let ctx: RuntimeTestContext | undefined;
-
-  afterEach(async () => {
-    await ctx?.dispose();
-    ctx = undefined;
-  });
-
-  test("creates full runtime context", async () => {
-    ctx = await createRuntimeTestContext();
-    assert.ok(typeof ctx.eval === "function");
-    assert.ok(typeof ctx.clearTimers === "function");
-    assert.ok(typeof ctx.dispatchRequest === "function");
-    assert.ok(typeof ctx.dispose === "function");
-    assert.ok(Array.isArray(ctx.logs));
-    assert.ok(Array.isArray(ctx.fetchCalls));
-  });
-
-  test("captures console logs", async () => {
-    ctx = await createRuntimeTestContext();
-
-    await ctx.eval('console.log("test message")');
-    await ctx.eval('console.warn("warning message")');
-
-    assert.strictEqual(ctx.logs.length, 2);
-    assert.strictEqual(ctx.logs[0]!.level, "log");
-    assert.deepStrictEqual(ctx.logs[0]!.args, ["test message"]);
-    assert.strictEqual(ctx.logs[1]!.level, "warn");
-    assert.deepStrictEqual(ctx.logs[1]!.args, ["warning message"]);
-  });
-
-  test("captures and mocks fetch calls", async () => {
-    ctx = await createRuntimeTestContext();
-
-    ctx.setMockResponse({
-      status: 200,
-      body: '{"data": "test"}',
-      headers: { "Content-Type": "application/json" },
-    });
-
-    await ctx.eval(`
-      const response = await fetch("https://api.example.com/data");
-      const json = await response.json();
-      setResult({ status: response.status, data: json });
-    `);
-
-    const result = ctx.getResult<{ status: number; data: { data: string } }>();
-    assert.strictEqual(result?.status, 200);
-    assert.deepStrictEqual(result?.data, { data: "test" });
-
-    assert.strictEqual(ctx.fetchCalls.length, 1);
-    assert.strictEqual(ctx.fetchCalls[0]!.url, "https://api.example.com/data");
-    assert.strictEqual(ctx.fetchCalls[0]!.method, "GET");
-  });
-
-  test("timers fire automatically with real time", async () => {
-    ctx = await createRuntimeTestContext();
-
-    await ctx.eval(`
-      globalThis.timerFired = false;
-      setTimeout(() => { globalThis.timerFired = true; }, 20);
-    `);
-
-    // Timer should not have fired yet - check via setResult
-    await ctx.eval('setResult(globalThis.timerFired)');
-    assert.strictEqual(ctx.getResult<boolean>(), false);
-    ctx.clearResult();
-
-    // Wait for real time to pass
-    await new Promise((r) => setTimeout(r, 50));
-
-    // Timer should have fired
-    await ctx.eval('setResult(globalThis.timerFired)');
-    assert.strictEqual(ctx.getResult<boolean>(), true);
-  });
-});
-
-// ============================================================================
-// startIntegrationServer tests
-// ============================================================================
-
-describe("startIntegrationServer", () => {
-  let server: IntegrationServer | undefined;
-
-  afterEach(async () => {
-    await server?.close();
-    server = undefined;
-  });
-
-  test("starts server on available port", async () => {
-    server = await startIntegrationServer();
-    assert.ok(server.port > 0);
-    assert.ok(server.url.startsWith("http://localhost:"));
-  });
-
-  test("responds with configured response", async () => {
-    server = await startIntegrationServer();
-    server.setResponse("/api/test", {
-      status: 200,
-      body: '{"message": "hello"}',
-      headers: { "Content-Type": "application/json" },
-    });
-
-    const response = await fetch(`${server.url}/api/test`);
-    assert.strictEqual(response.status, 200);
-    const data = await response.json();
-    assert.deepStrictEqual(data, { message: "hello" });
-  });
-
-  test("records requests", async () => {
-    server = await startIntegrationServer();
-    server.setDefaultResponse({ status: 200, body: "OK" });
-
-    await fetch(`${server.url}/api/endpoint`, {
-      method: "POST",
-      headers: { "X-Custom": "value" },
-      body: "request body",
-    });
-
-    const requests = server.getRequests();
-    assert.strictEqual(requests.length, 1);
-    assert.strictEqual(requests[0]!.method, "POST");
-    assert.strictEqual(requests[0]!.path, "/api/endpoint");
-    assert.strictEqual(requests[0]!.headers["x-custom"], "value");
-    assert.strictEqual(requests[0]!.body, "request body");
-  });
-
-  test("clears requests", async () => {
-    server = await startIntegrationServer();
-    server.setDefaultResponse({ status: 200 });
-
-    await fetch(`${server.url}/test`);
-    assert.strictEqual(server.getRequests().length, 1);
-
-    server.clearRequests();
-    assert.strictEqual(server.getRequests().length, 0);
-  });
-
-  test("returns 404 for unmatched paths", async () => {
-    server = await startIntegrationServer();
-
-    const response = await fetch(`${server.url}/unknown`);
-    assert.strictEqual(response.status, 404);
-  });
-});

package/src/index.ts

@@ -1,177 +0,0 @@
-import type ivm from "isolated-vm";
-
-// ============================================================================
-// Types
-// ============================================================================
-
-export interface TestContext {
-  isolate: ivm.Isolate;
-  context: ivm.Context;
-  dispose(): void;
-}
-
-export interface TestResult<T> {
-  result: T;
-  logs: Array<{ level: string; args: unknown[] }>;
-}
-
-// ============================================================================
-// Context Creation
-// ============================================================================
-
-/**
- * Create a basic test context for isolated-vm tests.
- * This creates a bare context without any APIs set up.
- */
-export async function createTestContext(): Promise<TestContext> {
-  const ivm = await import("isolated-vm");
-  const isolate = new ivm.default.Isolate();
-  const context = await isolate.createContext();
-
-  return {
-    isolate,
-    context,
-    dispose() {
-      context.release();
-      isolate.dispose();
-    },
-  };
-}
-
-/**
- * Create a test context with core APIs set up (Blob, File, URL, streams, etc.)
- */
-export async function createCoreTestContext(): Promise<TestContext> {
-  const ivm = await import("isolated-vm");
-  const { setupCore } = await import("@ricsam/isolate-core");
-
-  const isolate = new ivm.default.Isolate();
-  const context = await isolate.createContext();
-  const coreHandle = await setupCore(context);
-
-  return {
-    isolate,
-    context,
-    dispose() {
-      coreHandle.dispose();
-      context.release();
-      isolate.dispose();
-    },
-  };
-}
-
-// ============================================================================
-// Code Evaluation Helpers
-// ============================================================================
-
-/**
- * Synchronously evaluate code and return typed result.
- * Use this for simple expressions that don't involve promises.
- *
- * @example
- * const result = evalCode<number>(ctx.context, "1 + 1");
- * // result === 2
- */
-export function evalCode<T = unknown>(context: ivm.Context, code: string): T {
-  return context.evalSync(code) as T;
-}
-
-/**
- * Asynchronously evaluate code that may return promises.
- * Automatically wraps code to handle promise resolution.
- *
- * @example
- * const result = await evalCodeAsync<string>(ctx.context, `
- *   (async () => {
- *     return "hello";
- *   })()
- * `);
- */
-export async function evalCodeAsync<T = unknown>(
-  context: ivm.Context,
-  code: string
-): Promise<T> {
-  return (await context.eval(code, { promise: true })) as T;
-}
-
-/**
- * Evaluate code and return the result as JSON (for complex objects).
- * Useful when you need to extract structured data from the isolate.
- *
- * @example
- * const data = evalCodeJson<{ name: string }>(ctx.context, `
- *   JSON.stringify({ name: "test" })
- * `);
- */
-export function evalCodeJson<T = unknown>(context: ivm.Context, code: string): T {
-  const jsonString = context.evalSync(code) as string;
-  return JSON.parse(jsonString) as T;
-}
-
-/**
- * Evaluate async code and return the result as JSON (for complex objects).
- *
- * @example
- * const data = await evalCodeJsonAsync<{ status: number }>(ctx.context, `
- *   (async () => {
- *     const response = await fetch("...");
- *     return JSON.stringify({ status: response.status });
- *   })()
- * `);
- */
-export async function evalCodeJsonAsync<T = unknown>(
-  context: ivm.Context,
-  code: string
-): Promise<T> {
-  const jsonString = (await context.eval(code, { promise: true })) as string;
-  return JSON.parse(jsonString) as T;
-}
-
-/**
- * Inject values into the isolate's global scope before running code.
- *
- * @example
- * await injectGlobals(ctx.context, {
- *   testInput: "hello",
- *   testConfig: { debug: true }
- * });
- * const result = evalCode<string>(ctx.context, "testInput");
- */
-export async function injectGlobals(
-  context: ivm.Context,
-  values: Record<string, unknown>
-): Promise<void> {
-  const global = context.global;
-
-  for (const [key, value] of Object.entries(values)) {
-    if (typeof value === "function") {
-      const ivm = await import("isolated-vm");
-      global.setSync(key, new ivm.default.Callback(value as (...args: unknown[]) => unknown));
-    } else if (typeof value === "object" && value !== null) {
-      // For objects, serialize as JSON and inject
-      context.evalSync(`globalThis.${key} = ${JSON.stringify(value)}`);
-    } else {
-      // For primitives, set directly
-      global.setSync(key, value);
-    }
-  }
-}
-
-// ============================================================================
-// Exports from other modules
-// ============================================================================
-
-export { MockFileSystem } from "./mock-fs.ts";
-export { createFsTestContext } from "./fs-context.ts";
-export type { FsTestContext } from "./fs-context.ts";
-export { createRuntimeTestContext } from "./runtime-context.ts";
-export type { RuntimeTestContext } from "./runtime-context.ts";
-export { startIntegrationServer } from "./server.ts";
-export type { IntegrationServer } from "./server.ts";
-export { runTestCode } from "./native-input-test.ts";
-export type { TestRunner, TestRuntime } from "./native-input-test.ts";
-export { createFetchTestContext } from "./fetch-context.ts";
-export type { FetchTestContext } from "./fetch-context.ts";
-
-// Re-export useful types
-export type { FileSystemHandler } from "@ricsam/isolate-fs";