@outfitter/testing 0.2.4 → 0.2.5

package/README.md

@@ -93,6 +93,7 @@ const config = createConfig({
 ```
 
 Notes:
+
 - Arrays are replaced, not merged.
 - `undefined` override values are ignored (defaults remain).
 
@@ -198,7 +199,7 @@ const server: McpServer = {
     },
   ],
   async invoke(toolName, input) {
-    const tool = this.tools.find(t => t.name === toolName);
+    const tool = this.tools.find((t) => t.name === toolName);
     if (!tool) throw new Error(`Tool not found: ${toolName}`);
     return tool.handler(input);
   },
@@ -260,7 +261,11 @@ Import specific modules directly for smaller bundles:
 
 ```typescript
 // Just fixtures
-import { createFixture, withTempDir, withEnv } from "@outfitter/testing/fixtures";
+import {
+  createFixture,
+  withTempDir,
+  withEnv,
+} from "@outfitter/testing/fixtures";
 ```
 
 All harness utilities are available from the main package export:
@@ -273,29 +278,29 @@ import { createCliHarness, createMcpHarness } from "@outfitter/testing";
 
 ### Fixtures
 
-| Export | Description |
-|--------|-------------|
-| `createFixture<T>(defaults)` | Create a fixture factory with deep merge support |
-| `withTempDir<T>(fn)` | Run callback with auto-cleaned temp directory |
-| `withEnv<T>(vars, fn)` | Run callback with temporary environment variables |
+| Export                       | Description                                       |
+| ---------------------------- | ------------------------------------------------- |
+| `createFixture<T>(defaults)` | Create a fixture factory with deep merge support  |
+| `withTempDir<T>(fn)`         | Run callback with auto-cleaned temp directory     |
+| `withEnv<T>(vars, fn)`       | Run callback with temporary environment variables |
 
 ### CLI Harness
 
-| Export | Description |
-|--------|-------------|
-| `createCliHarness(command)` | Create a CLI test harness |
-| `CliHarness` | Interface for CLI harness |
-| `CliResult` | Interface for command execution result |
+| Export                      | Description                            |
+| --------------------------- | -------------------------------------- |
+| `createCliHarness(command)` | Create a CLI test harness              |
+| `CliHarness`                | Interface for CLI harness              |
+| `CliResult`                 | Interface for command execution result |
 
 ### MCP Harness
 
-| Export | Description |
-|--------|-------------|
-| `createMcpHarness(server)` | Create an MCP test harness |
-| `McpHarness` | Interface for MCP harness |
-| `McpServer` | Interface for MCP server |
-| `McpTool` | Interface for tool definition |
-| `McpToolHandler` | Type for tool handler functions |
+| Export                     | Description                     |
+| -------------------------- | ------------------------------- |
+| `createMcpHarness(server)` | Create an MCP test harness      |
+| `McpHarness`               | Interface for MCP harness       |
+| `McpServer`                | Interface for MCP server        |
+| `McpTool`                  | Interface for tool definition   |
+| `McpToolHandler`           | Type for tool handler functions |
 
 ## Related Packages
 

package/dist/cli-harness.js

@@ -1,7 +1,30 @@
 // @bun
-import {
-  createCliHarness
-} from "./shared/@outfitter/testing-wfp5f7pq.js";
+// packages/testing/src/cli-harness.ts
+function createCliHarness(command) {
+  return {
+    async run(args) {
+      const child = Bun.spawn([command, ...args], {
+        stdin: "pipe",
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      child.stdin?.end();
+      const stdoutPromise = child.stdout ? new Response(child.stdout).text() : Promise.resolve("");
+      const stderrPromise = child.stderr ? new Response(child.stderr).text() : Promise.resolve("");
+      const exitCodePromise = child.exited;
+      const [stdout, stderr, exitCode] = await Promise.all([
+        stdoutPromise,
+        stderrPromise,
+        exitCodePromise
+      ]);
+      return {
+        stdout,
+        stderr,
+        exitCode: typeof exitCode === "number" ? exitCode : 1
+      };
+    }
+  };
+}
 export {
   createCliHarness
 };

package/dist/cli-helpers.js

@@ -1,8 +1,95 @@
 // @bun
-import {
-  captureCLI,
-  mockStdin
-} from "./shared/@outfitter/testing-xsfjh1n3.js";
+// packages/testing/src/cli-helpers.ts
+class ExitError extends Error {
+  code;
+  constructor(code) {
+    super(`Process exited with code ${code}`);
+    this.code = code;
+  }
+}
+async function captureCLI(fn) {
+  const stdoutChunks = [];
+  const stderrChunks = [];
+  const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+  const originalStderrWrite = process.stderr.write.bind(process.stderr);
+  const originalExit = process.exit.bind(process);
+  const originalConsoleLog = console.log;
+  const originalConsoleError = console.error;
+  process.stdout.write = (chunk, _encoding, cb) => {
+    stdoutChunks.push(typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk);
+    if (typeof cb === "function")
+      cb();
+    return true;
+  };
+  process.stderr.write = (chunk, _encoding, cb) => {
+    stderrChunks.push(typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk);
+    if (typeof cb === "function")
+      cb();
+    return true;
+  };
+  console.log = (...args) => {
+    const line = `${args.map(String).join(" ")}
+`;
+    stdoutChunks.push(new TextEncoder().encode(line));
+  };
+  console.error = (...args) => {
+    const line = `${args.map(String).join(" ")}
+`;
+    stderrChunks.push(new TextEncoder().encode(line));
+  };
+  process.exit = (code) => {
+    throw new ExitError(code ?? 0);
+  };
+  let exitCode = 0;
+  try {
+    await fn();
+  } catch (error) {
+    if (error instanceof ExitError) {
+      exitCode = error.code;
+    } else {
+      exitCode = 1;
+    }
+  } finally {
+    process.stdout.write = originalStdoutWrite;
+    process.stderr.write = originalStderrWrite;
+    process.exit = originalExit;
+    console.log = originalConsoleLog;
+    console.error = originalConsoleError;
+  }
+  const decoder = new TextDecoder("utf-8");
+  return {
+    stdout: decoder.decode(concatChunks(stdoutChunks)),
+    stderr: decoder.decode(concatChunks(stderrChunks)),
+    exitCode
+  };
+}
+function mockStdin(input) {
+  const originalStdin = process.stdin;
+  const encoded = new TextEncoder().encode(input);
+  const mockStream = {
+    async* [Symbol.asyncIterator]() {
+      yield encoded;
+    },
+    fd: 0,
+    isTTY: false
+  };
+  process.stdin = mockStream;
+  return {
+    restore: () => {
+      process.stdin = originalStdin;
+    }
+  };
+}
+function concatChunks(chunks) {
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
 export {
   mockStdin,
   captureCLI

package/dist/index.d.ts

@@ -1,268 +1,6 @@
-/**
-* Deep partial type that makes all nested properties optional.
-* Used for fixture overrides.
-*/
-type DeepPartial<T> = T extends object ? { [P in keyof T]? : DeepPartial<T[P]> } : T;
-/**
-* Creates a fixture factory for generating test data with defaults.
-*
-* The factory returns a new object each time it's called, preventing
-* test pollution from shared mutable state. Supports deep merging
-* for nested objects.
-*
-* @typeParam T - The shape of the fixture object
-* @param defaults - Default values for the fixture
-* @returns A factory function that creates fixtures with optional overrides
-*
-* @example
-* ```typescript
-* const createUser = createFixture({
-*   id: 1,
-*   name: "John Doe",
-*   email: "john@example.com",
-*   settings: { theme: "dark", notifications: true }
-* });
-*
-* // Use defaults
-* const user1 = createUser();
-*
-* // Override specific fields
-* const user2 = createUser({ name: "Jane Doe", settings: { theme: "light" } });
-* ```
-*/
-declare function createFixture<T extends object>(defaults: T): (overrides?: DeepPartial<T>) => T;
-/**
-* Runs a function with a temporary directory, cleaning up after.
-*
-* Creates a unique temporary directory before invoking the callback,
-* and removes it (including all contents) after the callback completes.
-* Cleanup occurs even if the callback throws an error.
-*
-* @typeParam T - Return type of the callback
-* @param fn - Async function that receives the temp directory path
-* @returns The value returned by the callback
-*
-* @example
-* ```typescript
-* const result = await withTempDir(async (dir) => {
-*   await Bun.write(join(dir, "test.txt"), "content");
-*   return await processFiles(dir);
-* });
-* // Directory is automatically cleaned up
-* ```
-*/
-declare function withTempDir<T>(fn: (dir: string) => Promise<T>): Promise<T>;
-/**
-* Runs a function with temporary environment variables, restoring after.
-*
-* Sets the specified environment variables before invoking the callback,
-* then restores the original values after the callback completes.
-* Restoration occurs even if the callback throws an error.
-*
-* @typeParam T - Return type of the callback
-* @param vars - Environment variables to set
-* @param fn - Async function to run with the modified environment
-* @returns The value returned by the callback
-*
-* @example
-* ```typescript
-* await withEnv({ API_KEY: "test-key", DEBUG: "true" }, async () => {
-*   // process.env.API_KEY is "test-key"
-*   // process.env.DEBUG is "true"
-*   await runTests();
-* });
-* // Original environment is restored
-* ```
-*/
-declare function withEnv<T>(vars: Record<string, string>, fn: () => Promise<T>): Promise<T>;
-interface LoadFixtureOptions {
-	/**
-	* Base fixtures directory.
-	* Defaults to `${process.cwd()}/__fixtures__`.
-	*/
-	readonly fixturesDir?: string;
-}
-/**
-* Load a fixture from the fixtures directory.
-*
-* JSON fixtures are parsed automatically; all other file types are returned as strings.
-*
-* @example
-* ```typescript
-* const note = loadFixture<{ id: string }>("mcp/notes.json");
-* const config = loadFixture("mcp/config.toml");
-* ```
-*/
-declare function loadFixture2<T = string>(name: string, options?: LoadFixtureOptions): T;
-/**
-* @outfitter/testing - CLI Harness
-*
-* Test harness for executing and capturing CLI command output.
-* Provides a simple interface for running CLI commands in tests
-* and capturing their stdout, stderr, and exit code.
-*
-* @packageDocumentation
-*/
-/**
-* Result of a CLI command execution.
-*
-* Contains the captured output streams and exit code from the command.
-*/
-interface CliResult {
-	/** Exit code from the command (0 typically indicates success) */
-	exitCode: number;
-	/** Standard error output from the command */
-	stderr: string;
-	/** Standard output from the command */
-	stdout: string;
-}
-/**
-* Harness for executing CLI commands in tests.
-*
-* Provides a simple interface to run a pre-configured command
-* with various arguments and capture the results.
-*/
-interface CliHarness {
-	/**
-	* Runs the command with the given arguments.
-	*
-	* @param args - Command-line arguments to pass to the command
-	* @returns Promise resolving to the execution result
-	*/
-	run(args: string[]): Promise<CliResult>;
-}
-/**
-* Creates a CLI harness for testing command-line tools.
-*
-* The harness wraps a command and provides a simple interface for
-* executing it with different arguments, capturing stdout, stderr,
-* and exit code for assertions.
-*
-* @param command - The command to execute (e.g., "echo", "node", "./bin/cli")
-* @returns A CliHarness instance for running the command
-*
-* @example
-* ```typescript
-* const harness = createCliHarness("./bin/my-cli");
-*
-* // Test help output
-* const helpResult = await harness.run(["--help"]);
-* expect(helpResult.stdout).toContain("Usage:");
-* expect(helpResult.exitCode).toBe(0);
-*
-* // Test error case
-* const errorResult = await harness.run(["--invalid-flag"]);
-* expect(errorResult.stderr).toContain("Unknown option");
-* expect(errorResult.exitCode).toBe(1);
-* ```
-*/
-declare function createCliHarness(command: string): CliHarness;
-/**
-* @outfitter/testing - CLI Helpers
-*
-* Utilities for capturing CLI output and mocking stdin in tests.
-*
-* @packageDocumentation
-*/
-interface CliTestResult {
-	/** Process exit code */
-	exitCode: number;
-	/** Captured stderr */
-	stderr: string;
-	/** Captured stdout */
-	stdout: string;
-}
-/**
-* Capture stdout/stderr and exit code from an async CLI function.
-*/
-declare function captureCLI(fn: () => Promise<void> | void): Promise<CliTestResult>;
-/**
-* Mock stdin with provided input.
-*
-* Returns a restore function for convenience.
-*/
-declare function mockStdin(input: string): {
-	restore: () => void;
-};
-import { OutfitterError, Result } from "@outfitter/contracts";
-import { McpError, McpServer, SerializedTool, ToolDefinition } from "@outfitter/mcp";
-/**
-* MCP tool response content.
-* Matches the MCP protocol shape used in the spec.
-*/
-interface McpToolResponse {
-	content: Array<{
-		type: "text" | "image";
-		text?: string;
-		data?: string;
-	}>;
-	isError?: boolean;
-}
-/**
-* Test harness for MCP servers.
-*/
-interface McpHarness {
-	/**
-	* Call a tool by name with input parameters.
-	* Returns the MCP-formatted response.
-	*/
-	callTool(name: string, input: Record<string, unknown>): Promise<Result<McpToolResponse, InstanceType<typeof McpError>>>;
-	/**
-	* List all registered tools with schemas.
-	*/
-	listTools(): SerializedTool[];
-	/**
-	* Load fixture data by name (relative to __fixtures__).
-	*/
-	loadFixture<T = string>(name: string): T;
-	/**
-	* Reset harness state between tests.
-	*/
-	reset(): void;
-	/**
-	* Search tools by name or description (case-insensitive).
-	*/
-	searchTools(query: string): SerializedTool[];
-}
-interface McpHarnessOptions {
-	/** Base fixtures directory (defaults to `${process.cwd()}/__fixtures__`). */
-	readonly fixturesDir?: string;
-}
-interface McpTestHarnessOptions {
-	/** Base fixtures directory (defaults to `${process.cwd()}/__fixtures__`). */
-	readonly fixturesDir?: string;
-	/** Optional server name for diagnostics. */
-	readonly name?: string;
-	/** Tools to register on the test MCP server. */
-	readonly tools: ToolDefinition<unknown, unknown, OutfitterError>[];
-	/** Optional server version for diagnostics. */
-	readonly version?: string;
-}
-/**
-* Creates an MCP test harness from an MCP server.
-*/
-declare function createMcpHarness(server: McpServer, options?: McpHarnessOptions): McpHarness;
-/**
-* Creates an MCP test harness from tool definitions.
-*
-* This is a spec-compatible wrapper that builds a test server,
-* registers tools, and returns the standard MCP harness.
-*/
-declare function createMCPTestHarness(options: McpTestHarnessOptions): McpHarness;
-import { HandlerContext, Logger, ResolvedConfig } from "@outfitter/contracts";
-import { z } from "zod";
-interface LogEntry {
-	data?: Record<string, unknown>;
-	level: "trace" | "debug" | "info" | "warn" | "error" | "fatal";
-	message: string;
-}
-interface TestLogger extends Logger {
-	/** Clear captured logs */
-	clear(): void;
-	/** Captured log entries for assertions */
-	logs: LogEntry[];
-}
-declare function createTestLogger(context?: Record<string, unknown>): TestLogger;
-declare function createTestConfig<T>(schema: z.ZodType<T>, values: Partial<T>): ResolvedConfig;
-declare function createTestContext(overrides?: Partial<HandlerContext>): HandlerContext;
-export { withTempDir, withEnv, mockStdin, loadFixture2 as loadFixture, createTestLogger, createTestContext, createTestConfig, createMCPTestHarness as createMcpTestHarness, createMcpHarness, createMCPTestHarness, createFixture, createCliHarness, captureCLI, TestLogger, McpToolResponse, McpTestHarnessOptions, McpHarness, LogEntry, CliTestResult, CliResult, CliHarness };
+import { CliTestResult, captureCLI, mockStdin } from "./shared/@outfitter/testing-fyjbwn80.js";
+import { createFixture, loadFixture, withEnv, withTempDir } from "./shared/@outfitter/testing-98fsks4n.js";
+import { McpHarness, McpTestHarnessOptions, McpToolResponse, createMCPTestHarness, createMcpHarness } from "./shared/@outfitter/testing-5gdrv3f5.js";
+import { LogEntry, TestLogger, createTestConfig, createTestContext, createTestLogger } from "./shared/@outfitter/testing-jdfrrv33.js";
+import { CliHarness, CliResult, createCliHarness } from "./shared/@outfitter/testing-xaxkt6c9.js";
+export { withTempDir, withEnv, mockStdin, loadFixture, createTestLogger, createTestContext, createTestConfig, createMCPTestHarness as createMcpTestHarness, createMcpHarness, createMCPTestHarness, createFixture, createCliHarness, captureCLI, TestLogger, McpToolResponse, McpTestHarnessOptions, McpHarness, LogEntry, CliTestResult, CliResult, CliHarness };