wraptc 1.0.2 → 1.0.4

package/src/core/__tests__/integration/integration.test.ts

@@ -0,0 +1,241 @@
+import { describe, expect, mock, test } from "bun:test";
+import { mkdir, unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { ConfigLoader } from "../../config";
+import { Router } from "../../router";
+import { StateManager } from "../../state";
+import type { CodingRequest } from "../../types";
+
+// Mock Provider for testing
+class MockProvider {
+  readonly id: string;
+  readonly displayName: string;
+  readonly supportsStreaming: boolean = false;
+  readonly prefersJson: boolean = false;
+  readonly capabilities?: string[] = ["generate", "edit", "explain", "test"];
+
+  private responseText: string;
+  private shouldFail = false;
+
+  constructor(id: string, displayName: string, responseText: string) {
+    this.id = id;
+    this.displayName = displayName;
+    this.responseText = responseText;
+  }
+
+  setShouldFail(fail: boolean) {
+    this.shouldFail = fail;
+  }
+
+  async runOnce(req: CodingRequest, opts: any): Promise<{ text: string; usage?: any }> {
+    if (this.shouldFail) {
+      throw new Error(`${this.id} failed`);
+    }
+    return {
+      text: this.responseText,
+      usage: { inputTokens: 10, outputTokens: 20 },
+    };
+  }
+
+  async *runStream(req: CodingRequest, opts: any): AsyncGenerator<any> {
+    if (this.shouldFail) {
+      throw new Error(`${this.id} failed`);
+    }
+    yield {
+      type: "complete",
+      text: this.responseText,
+      usage: { inputTokens: 10, outputTokens: 20 },
+    };
+  }
+
+  classifyError(error: any): import("../../types").ProviderErrorKind {
+    return "TRANSIENT";
+  }
+
+  getInfo(): import("../../types").ProviderInfo {
+    return {
+      id: this.id,
+      displayName: this.displayName,
+      supportsStreaming: this.supportsStreaming,
+      prefersJson: this.prefersJson,
+      capabilities: this.capabilities,
+    };
+  }
+}
+
+describe("Integration Tests", () => {
+  test("Router and StateManager integration", async () => {
+    // Create components with proper integration
+    const providers = new Map([
+      ["provider1", new MockProvider("provider1", "Provider 1", "Response from provider1")],
+      ["provider2", new MockProvider("provider2", "Provider 2", "Response from provider2")],
+    ]);
+
+    const config = {
+      routing: { defaultOrder: ["provider1", "provider2"] },
+      providers: {},
+      credits: { providers: {} },
+    };
+
+    const stateManager = new StateManager();
+    await stateManager.initialize();
+
+    const router = new Router(providers, {
+      config,
+      stateManager,
+    });
+
+    // Test basic routing
+    const request: CodingRequest = {
+      prompt: "Test prompt",
+      mode: "generate",
+      stream: false,
+    };
+
+    const response = await router.route(request);
+
+    expect(response.provider).toBe("provider1");
+    expect(response.text).toBe("Response from provider1");
+    expect(response.usage).toEqual({ inputTokens: 10, outputTokens: 20 });
+  });
+
+  test("Provider fallback on failure", async () => {
+    // Create providers where first one fails
+    const provider1 = new MockProvider("provider1", "Provider 1", "Response from provider1");
+    provider1.setShouldFail(true);
+
+    const provider2 = new MockProvider("provider2", "Provider 2", "Response from provider2");
+
+    const providers = new Map([
+      ["provider1", provider1],
+      ["provider2", provider2],
+    ]);
+
+    const config = {
+      routing: { defaultOrder: ["provider1", "provider2"] },
+      providers: {},
+      credits: { providers: {} },
+    };
+
+    const stateManager = new StateManager();
+    await stateManager.initialize();
+
+    const router = new Router(providers, {
+      config,
+      stateManager,
+    });
+
+    const request: CodingRequest = {
+      prompt: "Test prompt",
+      mode: "generate",
+      stream: false,
+    };
+
+    const response = await router.route(request);
+
+    // Should fallback to provider2
+    expect(response.provider).toBe("provider2");
+    expect(response.text).toBe("Response from provider2");
+  });
+
+  test("Config loading and provider configuration", async () => {
+    // Create temporary config file
+    const tempDir = `/tmp/test-${Date.now()}`;
+    await mkdir(tempDir, { recursive: true });
+    const configPath = join(tempDir, "config.json");
+
+    const testConfig = {
+      routing: { defaultOrder: ["test-provider"] },
+      providers: {
+        "test-provider": {
+          binary: "test-binary",
+          args: ["--test"],
+          jsonMode: "none",
+          streamingMode: "line",
+          capabilities: ["generate"],
+        },
+      },
+      credits: { providers: {} },
+    };
+
+    await writeFile(configPath, JSON.stringify(testConfig, null, 2));
+
+    // Load config
+    const configLoader = new ConfigLoader({ projectConfigPath: configPath });
+    const config = await configLoader.loadConfig();
+
+    // Verify config loaded correctly
+    expect(config.routing.defaultOrder).toEqual(["test-provider"]);
+    expect(config.providers["test-provider"]).toBeDefined();
+    expect(config.providers["test-provider"].binary).toBe("test-binary");
+
+    // Cleanup
+    await unlink(configPath);
+    await unlink(tempDir).catch(() => {});
+  });
+
+  test.skip("State persistence across sessions - SKIP: timing issues", async () => {
+    const tempDir = `/tmp/test-${Date.now()}`;
+    await mkdir(tempDir, { recursive: true });
+    const statePath = join(tempDir, "state.json");
+
+    // First session - record success
+    const stateManager1 = new StateManager({ statePath });
+    await stateManager1.initialize();
+    await stateManager1.recordSuccess("test-provider");
+    await stateManager1.save(); // Force immediate save
+
+    // Second session - load state
+    const stateManager2 = new StateManager({ statePath });
+    await stateManager2.initialize();
+    const providerState = await stateManager2.getProviderState("test-provider");
+
+    // Verify state persisted (should be 1 since we recorded in first session)
+    expect(providerState.requestsToday).toBe(1);
+
+    // Cleanup
+    await unlink(statePath);
+    await unlink(tempDir).catch(() => {});
+  });
+
+  test("Full routing with real components", async () => {
+    const providers = new Map([
+      ["primary", new MockProvider("primary", "Primary Provider", "Primary response")],
+      ["secondary", new MockProvider("secondary", "Secondary Provider", "Secondary response")],
+    ]);
+
+    const config = {
+      routing: { defaultOrder: ["primary", "secondary"] },
+      providers: {},
+      credits: {
+        providers: {
+          primary: { dailyRequestLimit: 100, resetHourUtc: 0 },
+          secondary: { dailyRequestLimit: 50, resetHourUtc: 0 },
+        },
+      },
+    };
+
+    const stateManager = new StateManager();
+    await stateManager.initialize();
+
+    const router = new Router(providers, {
+      config,
+      stateManager,
+    });
+
+    // Test multiple requests
+    const requests: CodingRequest[] = [
+      { prompt: "Request 1", mode: "generate", stream: false },
+      { prompt: "Request 2", mode: "edit", stream: false },
+      { prompt: "Request 3", mode: "explain", stream: false },
+    ];
+
+    const responses = await Promise.all(requests.map((req) => router.route(req)));
+
+    // All should use primary provider
+    responses.forEach((response) => {
+      expect(response.provider).toBe("primary");
+      expect(response.text).toBe("Primary response");
+    });
+  });
+});

package/src/core/__tests__/integration/mock-coder-adapter.test.ts

@@ -0,0 +1,243 @@
+/**
+ * Mock Coder Adapter Integration Tests
+ *
+ * Tests the full adapter system end-to-end using a bash script mock coder.
+ * This validates that the adapter wrapper can properly:
+ * - Execute the underlying binary
+ * - Pass input via stdin, positional args, or flags
+ * - Parse output (text or JSON)
+ * - Handle streaming output
+ * - Classify errors correctly
+ */
+
+import { beforeAll, describe, expect, test } from "bun:test";
+import {
+  mockCoderFlag,
+  mockCoderJson,
+  mockCoderPositional,
+  mockCoderRateLimit,
+  mockCoderStdin,
+  mockCoderStreamJson,
+  mockCoderStreamText,
+  mockCoderUnauthorized,
+} from "../../adapters/builtin/mock-coder";
+import { AdapterProviderBridge } from "../../adapters/provider-bridge";
+import { AdapterError, AdapterRunner } from "../../adapters/runner";
+
+// Ensure mock-coder.sh is executable
+beforeAll(async () => {
+  const mockCoderPath = new URL("../../../test-fixtures/mock-coder.sh", import.meta.url).pathname;
+
+  // Make executable if not already
+  const proc = Bun.spawn(["chmod", "+x", mockCoderPath]);
+  await proc.exited;
+});
+
+describe("Mock Coder Adapter - Input Methods", () => {
+  test("should handle stdin input", async () => {
+    const runner = new AdapterRunner(mockCoderStdin);
+    const result = await runner.run("hello world", {});
+
+    expect(result.text).toContain("Mock Coder");
+    expect(result.text).toContain("Hello");
+  });
+
+  test("should handle positional input", async () => {
+    const runner = new AdapterRunner(mockCoderPositional);
+    const result = await runner.run("hello", {});
+
+    expect(result.text).toContain("Mock Coder");
+  });
+
+  test("should handle flag input", async () => {
+    const runner = new AdapterRunner(mockCoderFlag);
+    const result = await runner.run("hello", {});
+
+    expect(result.text).toContain("Mock Coder");
+  });
+});
+
+describe("Mock Coder Adapter - Output Formats", () => {
+  test("should parse text output", async () => {
+    const runner = new AdapterRunner(mockCoderPositional);
+    const result = await runner.run("explain something", {});
+
+    expect(result.text).toBeTruthy();
+    expect(typeof result.text).toBe("string");
+  });
+
+  test("should parse JSON output", async () => {
+    const runner = new AdapterRunner(mockCoderJson);
+    const result = await runner.run("hello", {});
+
+    expect(result.text).toContain("Mock Coder");
+    expect(result.usage).toBeDefined();
+    expect(result.usage?.inputTokens).toBeGreaterThan(0);
+    expect(result.usage?.outputTokens).toBeGreaterThan(0);
+  });
+});
+
+describe("Mock Coder Adapter - Streaming", () => {
+  test("should stream text output line by line", async () => {
+    const runner = new AdapterRunner(mockCoderStreamText);
+    const chunks: string[] = [];
+
+    for await (const chunk of runner.runStream("hello", {})) {
+      if (chunk.type === "text") {
+        chunks.push(chunk.content);
+      }
+    }
+
+    expect(chunks.length).toBeGreaterThan(0);
+    const fullText = chunks.join("");
+    expect(fullText).toContain("Mock Coder");
+  });
+
+  test("should stream JSON output as JSONL", async () => {
+    const runner = new AdapterRunner(mockCoderStreamJson);
+    const chunks: unknown[] = [];
+
+    for await (const chunk of runner.runStream("hello", {})) {
+      if (chunk.type === "json") {
+        chunks.push(chunk.data);
+      }
+    }
+
+    expect(chunks.length).toBeGreaterThan(0);
+  });
+});
+
+describe("Mock Coder Adapter - Error Handling", () => {
+  test("should classify rate limit error", async () => {
+    const runner = new AdapterRunner(mockCoderRateLimit);
+
+    try {
+      await runner.run("test", {});
+      expect.unreachable("Should have thrown");
+    } catch (error) {
+      expect(error).toBeInstanceOf(AdapterError);
+      const adapterError = error as AdapterError;
+      expect(adapterError.kind).toBe("RATE_LIMIT");
+      expect(adapterError.isRetryable).toBe(true);
+    }
+  });
+
+  test("should classify unauthorized error", async () => {
+    const runner = new AdapterRunner(mockCoderUnauthorized);
+
+    try {
+      await runner.run("test", {});
+      expect.unreachable("Should have thrown");
+    } catch (error) {
+      expect(error).toBeInstanceOf(AdapterError);
+      const adapterError = error as AdapterError;
+      expect(adapterError.kind).toBe("UNAUTHORIZED");
+      expect(adapterError.isRetryable).toBe(false);
+      expect(adapterError.isUserError).toBe(true);
+    }
+  });
+});
+
+describe("Mock Coder Adapter - Provider Bridge", () => {
+  test("should work through provider bridge (runOnce)", async () => {
+    const bridge = new AdapterProviderBridge(mockCoderPositional);
+
+    expect(bridge.id).toBe("mock-coder-positional");
+    expect(bridge.displayName).toBe("Mock Coder (positional)");
+
+    const result = await bridge.runOnce({ prompt: "hello", mode: "generate" }, {});
+
+    expect(result.text).toContain("Mock Coder");
+  });
+
+  test("should work through provider bridge (runStream)", async () => {
+    const bridge = new AdapterProviderBridge(mockCoderStreamText);
+
+    expect(bridge.supportsStreaming).toBe(true);
+
+    const events: string[] = [];
+    for await (const event of bridge.runStream({ prompt: "hello", mode: "generate" }, {})) {
+      events.push(event.type);
+      if (event.type === "text_delta") {
+        expect(event.text).toBeTruthy();
+      }
+    }
+
+    expect(events).toContain("start");
+    expect(events).toContain("text_delta");
+    expect(events).toContain("complete");
+  });
+
+  test("should classify errors through bridge", () => {
+    const bridge = new AdapterProviderBridge(mockCoderStdin);
+
+    expect(
+      bridge.classifyError({
+        error: new Error("Rate limit exceeded"),
+        stderr: "Error 429: Rate limit exceeded",
+        exitCode: 1,
+      }),
+    ).toBe("RATE_LIMIT");
+
+    expect(
+      bridge.classifyError({
+        error: new Error("Auth failed"),
+        stderr: "Error 401: Unauthorized",
+        exitCode: 1,
+      }),
+    ).toBe("UNAUTHORIZED");
+  });
+
+  test("should report capabilities through getInfo", () => {
+    const bridge = new AdapterProviderBridge(mockCoderStdin);
+    const info = bridge.getInfo();
+
+    expect(info.capabilities).toContain("generate");
+    expect(info.capabilities).toContain("edit");
+    expect(info.capabilities).toContain("explain");
+    expect(info.supportsStreaming).toBe(false);
+  });
+});
+
+describe("Mock Coder Adapter - Different Prompts", () => {
+  test("should handle code generation prompt", async () => {
+    const runner = new AdapterRunner(mockCoderPositional);
+    const result = await runner.run("write a function to greet", {});
+
+    expect(result.text).toContain("function");
+    expect(result.text).toContain("greet");
+  });
+
+  test("should handle explanation prompt", async () => {
+    const runner = new AdapterRunner(mockCoderPositional);
+    const result = await runner.run("explain this code", {});
+
+    expect(result.text).toContain("code does the following");
+  });
+
+  test("should handle generic prompt", async () => {
+    const runner = new AdapterRunner(mockCoderPositional);
+    const result = await runner.run("do something random", {});
+
+    expect(result.text).toContain("I received your prompt");
+  });
+});
+
+describe("Mock Coder Adapter - Runner Info", () => {
+  test("should expose adapter info", () => {
+    const runner = new AdapterRunner(mockCoderStdin);
+    const info = runner.getInfo();
+
+    expect(info.id).toBe("mock-coder-stdin");
+    expect(info.displayName).toBe("Mock Coder (stdin)");
+    expect(info.supportsStreaming).toBe(false);
+    expect(info.capabilities).toContain("generate");
+  });
+
+  test("should report streaming capability", () => {
+    const runner = new AdapterRunner(mockCoderStreamText);
+    const info = runner.getInfo();
+
+    expect(info.supportsStreaming).toBe(true);
+  });
+});

package/src/core/__tests__/test-utils.ts

@@ -0,0 +1,136 @@
+import { mock } from "bun:test";
+// Test utilities for reliable and consistent testing
+import { mkdir, rm } from "node:fs/promises";
+import type { CodingRequest, Config } from "../types";
+
+export interface TestEnvironment {
+  tempDir: string;
+  cleanup: () => Promise<void>;
+}
+
+/**
+ * Create a unique temporary directory for testing
+ */
+export async function createTestEnvironment(prefix = "test"): Promise<TestEnvironment> {
+  const testId = `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  const tempDir = `/tmp/${prefix}-${testId}`;
+
+  await mkdir(tempDir, { recursive: true });
+
+  return {
+    tempDir,
+    cleanup: async () => {
+      try {
+        await rm(tempDir, { recursive: true, force: true });
+      } catch (error) {
+        // Ignore cleanup errors in tests
+      }
+    },
+  };
+}
+
+/**
+ * Create mock providers for testing
+ */
+export function createMockProvider(
+  id: string,
+  displayName: string,
+  options: {
+    shouldFail?: boolean;
+    failWith?: Error;
+    supportsStreaming?: boolean;
+  } = {},
+) {
+  const { shouldFail = false, failWith, supportsStreaming = false } = options;
+
+  let currentShouldFail = shouldFail;
+  let currentFailWith = failWith;
+
+  return {
+    id,
+    displayName,
+    supportsStreaming,
+    prefersJson: true,
+    capabilities: ["generate", "edit", "explain", "test"],
+
+    setShouldFail: (fail: boolean, error?: Error) => {
+      currentShouldFail = fail;
+      currentFailWith = error || new Error("Mock failure");
+    },
+
+    runOnce: mock(async (_req: CodingRequest) => {
+      if (currentShouldFail && currentFailWith) {
+        throw currentFailWith;
+      }
+      return {
+        text: `Response from ${id}`,
+        usage: { inputTokens: 10, outputTokens: 20 },
+      };
+    }),
+
+    runStream: mock(async function* (_req: CodingRequest) {
+      if (currentShouldFail && currentFailWith) {
+        throw currentFailWith;
+      }
+      yield {
+        type: "complete" as const,
+        provider: id,
+        text: `Response from ${id}`,
+        usage: { inputTokens: 10, outputTokens: 20 },
+      };
+    }),
+
+    classifyError: mock(() => "TRANSIENT"),
+  };
+}
+
+/**
+ * Create mock state manager for testing
+ */
+export function createMockStateManager() {
+  return {
+    initialize: mock(async () => {}),
+    getProviderState: mock(async () => ({
+      requestsToday: 0,
+      lastErrors: [],
+      outOfCreditsUntil: undefined,
+      lastUsedAt: undefined,
+      lastReset: undefined,
+    })),
+    recordSuccess: mock(async () => {}),
+    recordError: mock(async () => {}),
+    markOutOfCredits: mock(async () => {}),
+    resetProvider: mock(async () => {}),
+    resetAll: mock(async () => {}),
+    getState: mock(() => ({ version: "1.0.0", providers: {} })),
+    getStatePath: mock(() => "/tmp/mock-state.json"),
+    save: mock(async () => {}),
+  };
+}
+
+/**
+ * Create mock config for testing
+ */
+export function createMockConfig(overrides: Partial<Config> = {}) {
+  return {
+    routing: {
+      defaultOrder: ["provider1", "provider2", "provider3"],
+      perModeOverride: {},
+      ...overrides.routing,
+    },
+    providers: {
+      provider1: {
+        binary: "provider1",
+        args: [],
+        jsonMode: "none",
+        streamingMode: "line",
+        capabilities: ["generate"],
+      },
+      ...overrides.providers,
+    },
+    credits: {
+      providers: {},
+      ...overrides.credits,
+    },
+  };
+}