wraptc 1.0.2 → 1.0.4

package/src/core/__tests__/unit/plugin/registry.test.ts

@@ -0,0 +1,356 @@
+/**
+ * PluginRegistry Unit Tests
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { PluginRegistry } from "../../../plugin/registry";
+import type { ManagedProvider, PluginDefinition } from "../../../plugin/types";
+import type { Provider } from "../../../providers";
+import type { CodingEvent, ProviderErrorContext } from "../../../types";
+
+// Mock provider for testing
+class MockProvider implements Provider {
+  readonly id: string;
+  readonly displayName: string;
+  readonly supportsStreaming = false;
+  readonly prefersJson = false;
+  initCalled = false;
+  shutdownCalled = false;
+
+  constructor(config: { id: string }) {
+    this.id = config.id;
+    this.displayName = `Mock ${config.id}`;
+  }
+
+  async runOnce() {
+    return { text: "mock response" };
+  }
+
+  async *runStream(): AsyncGenerator<CodingEvent> {
+    yield { type: "start", provider: this.id, requestId: "req-1" };
+    yield { type: "complete", provider: this.id, text: "mock" };
+  }
+
+  classifyError(): "UNKNOWN" {
+    return "UNKNOWN";
+  }
+
+  getInfo() {
+    return {
+      id: this.id,
+      displayName: this.displayName,
+      supportsStreaming: false,
+      prefersJson: false,
+    };
+  }
+
+  async init() {
+    this.initCalled = true;
+  }
+
+  async shutdown() {
+    this.shutdownCalled = true;
+  }
+}
+
+function createMockPlugin(
+  type: string,
+  options?: {
+    onRegister?: () => Promise<void>;
+    onUnregister?: () => Promise<void>;
+  },
+): PluginDefinition {
+  return {
+    type,
+    displayName: `Mock ${type}`,
+    hasLifecycle: false,
+    factory: (config: any) => new MockProvider({ id: type, ...config }),
+    onRegister: options?.onRegister,
+    onUnregister: options?.onUnregister,
+  };
+}
+
+describe("PluginRegistry", () => {
+  let registry: PluginRegistry;
+
+  beforeEach(() => {
+    PluginRegistry.resetInstance();
+    registry = PluginRegistry.getInstance();
+  });
+
+  afterEach(async () => {
+    await registry.clear();
+  });
+
+  describe("singleton pattern", () => {
+    test("should return same instance", () => {
+      const instance1 = PluginRegistry.getInstance();
+      const instance2 = PluginRegistry.getInstance();
+      expect(instance1).toBe(instance2);
+    });
+
+    test("should reset instance", () => {
+      const instance1 = PluginRegistry.getInstance();
+      PluginRegistry.resetInstance();
+      const instance2 = PluginRegistry.getInstance();
+      expect(instance1).not.toBe(instance2);
+    });
+  });
+
+  describe("registration", () => {
+    test("should register a plugin", async () => {
+      const plugin = createMockPlugin("test");
+      const result = await registry.register(plugin);
+
+      expect(result.success).toBe(true);
+      expect(result.type).toBe("test");
+      expect(registry.has("test")).toBe(true);
+    });
+
+    test("should reject duplicate registration", async () => {
+      const plugin = createMockPlugin("test");
+      await registry.register(plugin);
+      const result = await registry.register(plugin);
+
+      expect(result.success).toBe(false);
+      expect(result.message).toContain("already registered");
+    });
+
+    test("should allow overwrite", async () => {
+      const plugin1 = createMockPlugin("test");
+      const plugin2 = createMockPlugin("test");
+      plugin2.displayName = "New Test";
+
+      await registry.register(plugin1);
+      const result = await registry.register(plugin2, { overwrite: true });
+
+      expect(result.success).toBe(true);
+      expect(registry.get("test")?.displayName).toBe("New Test");
+    });
+
+    test("should call onRegister hook", async () => {
+      let registerCalled = false;
+      const plugin = createMockPlugin("test", {
+        onRegister: async () => {
+          registerCalled = true;
+        },
+      });
+
+      await registry.register(plugin);
+      expect(registerCalled).toBe(true);
+    });
+
+    test("should rollback on onRegister failure", async () => {
+      const plugin = createMockPlugin("test", {
+        onRegister: async () => {
+          throw new Error("Registration failed");
+        },
+      });
+
+      const result = await registry.register(plugin);
+
+      expect(result.success).toBe(false);
+      expect(result.message).toContain("Registration failed");
+      expect(registry.has("test")).toBe(false);
+    });
+  });
+
+  describe("sync registration", () => {
+    test("should register synchronously", () => {
+      const plugin = createMockPlugin("test");
+      const result = registry.registerSync(plugin);
+
+      expect(result.success).toBe(true);
+      expect(registry.has("test")).toBe(true);
+    });
+
+    test("should not call lifecycle hooks for sync registration", () => {
+      let hookCalled = false;
+      const plugin = createMockPlugin("test", {
+        onRegister: async () => {
+          hookCalled = true;
+        },
+      });
+
+      registry.registerSync(plugin);
+      expect(hookCalled).toBe(false);
+    });
+  });
+
+  describe("unregistration", () => {
+    test("should unregister a plugin", async () => {
+      const plugin = createMockPlugin("test");
+      await registry.register(plugin);
+
+      const result = await registry.unregister("test");
+
+      expect(result).toBe(true);
+      expect(registry.has("test")).toBe(false);
+    });
+
+    test("should return false for non-existent plugin", async () => {
+      const result = await registry.unregister("non-existent");
+      expect(result).toBe(false);
+    });
+
+    test("should call onUnregister hook", async () => {
+      let unregisterCalled = false;
+      const plugin = createMockPlugin("test", {
+        onUnregister: async () => {
+          unregisterCalled = true;
+        },
+      });
+
+      await registry.register(plugin);
+      await registry.unregister("test");
+
+      expect(unregisterCalled).toBe(true);
+    });
+  });
+
+  describe("queries", () => {
+    test("should get all types", async () => {
+      await registry.register(createMockPlugin("a"));
+      await registry.register(createMockPlugin("b"));
+      await registry.register(createMockPlugin("c"));
+
+      const types = registry.getTypes();
+
+      expect(types).toHaveLength(3);
+      expect(types).toContain("a");
+      expect(types).toContain("b");
+      expect(types).toContain("c");
+    });
+
+    test("should get plugin definition", async () => {
+      const plugin = createMockPlugin("test");
+      plugin.description = "Test plugin";
+
+      await registry.register(plugin);
+
+      const retrieved = registry.get("test");
+      expect(retrieved?.displayName).toBe("Mock test");
+      expect(retrieved?.description).toBe("Test plugin");
+    });
+
+    test("should list plugins", async () => {
+      await registry.register(createMockPlugin("a"));
+      await registry.register(createMockPlugin("b"));
+
+      const plugins = registry.listPlugins();
+
+      expect(plugins).toHaveLength(2);
+      expect(plugins[0].type).toBe("a");
+      expect(plugins[1].type).toBe("b");
+    });
+  });
+
+  describe("provider creation", () => {
+    test("should create provider from plugin", async () => {
+      const plugin = createMockPlugin("test");
+      await registry.register(plugin);
+
+      const provider = registry.createProvider("test", { id: "test" });
+
+      expect(provider.id).toBe("test");
+    });
+
+    test("should throw for unknown type", () => {
+      expect(() => registry.createProvider("unknown", {})).toThrow(
+        "No plugin registered for type 'unknown'",
+      );
+    });
+
+    test("should pass config to factory", async () => {
+      const plugin: PluginDefinition = {
+        type: "test",
+        displayName: "Test",
+        hasLifecycle: false,
+        factory: (config: any) => new MockProvider({ id: config.customId }),
+      };
+      await registry.register(plugin);
+
+      const provider = registry.createProvider("test", { customId: "custom" });
+
+      expect(provider.id).toBe("custom");
+    });
+  });
+
+  describe("lifecycle management", () => {
+    test("should initialize and track provider", async () => {
+      const plugin: PluginDefinition = {
+        type: "test",
+        displayName: "Test",
+        hasLifecycle: true,
+        factory: () => new MockProvider({ id: "test" }),
+      };
+      await registry.register(plugin);
+
+      const provider = (await registry.createAndInitProvider("test", {})) as MockProvider;
+
+      expect(provider.initCalled).toBe(true);
+    });
+
+    test("should shutdown all providers", async () => {
+      const provider1 = new MockProvider({ id: "a" });
+      const provider2 = new MockProvider({ id: "b" });
+
+      const plugin1: PluginDefinition = {
+        type: "a",
+        displayName: "A",
+        hasLifecycle: true,
+        factory: () => provider1,
+      };
+      const plugin2: PluginDefinition = {
+        type: "b",
+        displayName: "B",
+        hasLifecycle: true,
+        factory: () => provider2,
+      };
+
+      await registry.register(plugin1);
+      await registry.register(plugin2);
+
+      await registry.createAndInitProvider("a", {});
+      await registry.createAndInitProvider("b", {});
+
+      await registry.shutdownAll();
+
+      expect(provider1.shutdownCalled).toBe(true);
+      expect(provider2.shutdownCalled).toBe(true);
+    });
+  });
+
+  describe("built-in tracking", () => {
+    test("should track built-in plugins", async () => {
+      const plugin = createMockPlugin("builtin");
+      await registry.register(plugin, { builtIn: true });
+
+      const info = registry.listPlugins().find((p) => p.type === "builtin");
+      expect(info?.isBuiltIn).toBe(true);
+    });
+
+    test("should not mark regular plugins as built-in", async () => {
+      const plugin = createMockPlugin("regular");
+      await registry.register(plugin);
+
+      const info = registry.listPlugins().find((p) => p.type === "regular");
+      expect(info?.isBuiltIn).toBe(false);
+    });
+  });
+
+  describe("size", () => {
+    test("should return number of registered plugins", async () => {
+      expect(registry.size).toBe(0);
+
+      await registry.register(createMockPlugin("a"));
+      expect(registry.size).toBe(1);
+
+      await registry.register(createMockPlugin("b"));
+      expect(registry.size).toBe(2);
+
+      await registry.unregister("a");
+      expect(registry.size).toBe(1);
+    });
+  });
+});

package/src/core/__tests__/unit/providers/codex.test.ts

@@ -0,0 +1,173 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { CodexProvider } from "../../../providers/codex";
+import type { CodingRequest, ProviderConfig } from "../../../types";
+
+describe("CodexProvider", () => {
+  let provider: CodexProvider;
+  let config: ProviderConfig;
+
+  beforeEach(() => {
+    config = {
+      binary: "codex",
+      args: [],
+      jsonMode: "none",
+      streamingMode: "line",
+      capabilities: ["generate", "edit", "test"],
+    };
+    provider = new CodexProvider(config);
+  });
+
+  describe("constructor", () => {
+    test("should initialize with correct id and display name", () => {
+      expect(provider.id).toBe("codex");
+      expect(provider.displayName).toBe("Codex CLI");
+    });
+
+    test("should set binary path from config", () => {
+      const customConfig = { ...config, binary: "/custom/codex" };
+      const customProvider = new CodexProvider(customConfig);
+      expect(customProvider.binaryPath).toBe("/custom/codex");
+    });
+
+    test("should set default binary if not provided", () => {
+      const defaultConfig = { ...config, binary: "" };
+      const defaultProvider = new CodexProvider(defaultConfig);
+      expect(defaultProvider.binaryPath).toBe("codex");
+    });
+
+    test("should set streaming support based on config", () => {
+      expect(provider.supportsStreaming).toBe(true);
+
+      const noStreamConfig = { ...config, streamingMode: "none" as const };
+      const noStreamProvider = new CodexProvider(noStreamConfig);
+      expect(noStreamProvider.supportsStreaming).toBe(false);
+    });
+  });
+
+  describe("buildArgs", () => {
+    test("should use exec subcommand with prompt", () => {
+      const req: CodingRequest = { prompt: "Write hello world" };
+      const args = provider.buildArgs(req, {});
+
+      expect(args[0]).toBe("exec");
+      expect(args).toContain("Write hello world");
+    });
+
+    test("should include config args", () => {
+      const configWithArgs = { ...config, args: ["--model", "gpt-4"] };
+      const providerWithArgs = new CodexProvider(configWithArgs);
+      const req: CodingRequest = { prompt: "test" };
+      const args = providerWithArgs.buildArgs(req, {});
+
+      expect(args).toContain("--model");
+      expect(args).toContain("gpt-4");
+    });
+
+    test("should place prompt after config args", () => {
+      const configWithArgs = { ...config, args: ["--verbose"] };
+      const providerWithArgs = new CodexProvider(configWithArgs);
+      const req: CodingRequest = { prompt: "test prompt" };
+      const args = providerWithArgs.buildArgs(req, {});
+
+      // exec, --verbose, test prompt
+      expect(args[0]).toBe("exec");
+      expect(args[1]).toBe("--verbose");
+      expect(args[2]).toBe("test prompt");
+    });
+  });
+
+  describe("getStdinInput", () => {
+    test("should return undefined for Codex (uses positional args)", () => {
+      const result = provider.getStdinInput();
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe("classifyError", () => {
+    test("classifies 'plan limit' as OUT_OF_CREDITS", () => {
+      const error = provider.classifyError({ stderr: "You've hit your plan limit" });
+      expect(error).toBe("OUT_OF_CREDITS");
+    });
+
+    test("classifies 'subscription required' as OUT_OF_CREDITS", () => {
+      const error = provider.classifyError({ stderr: "Subscription required for this feature" });
+      expect(error).toBe("OUT_OF_CREDITS");
+    });
+
+    test("classifies 'rate limit' as RATE_LIMIT", () => {
+      const error = provider.classifyError({ stderr: "Rate limit exceeded" });
+      expect(error).toBe("RATE_LIMIT");
+    });
+
+    test("classifies '401 unauthorized' as UNAUTHORIZED", () => {
+      const error = provider.classifyError({ stderr: "401 unauthorized" });
+      expect(error).toBe("UNAUTHORIZED");
+    });
+
+    test("classifies '500 internal error' as INTERNAL", () => {
+      const error = provider.classifyError({ stderr: "500 internal server error" });
+      expect(error).toBe("INTERNAL");
+    });
+
+    test("classifies 'timeout' as TIMEOUT", () => {
+      const error = provider.classifyError({ stderr: "Request timeout" });
+      expect(error).toBe("TIMEOUT");
+    });
+
+    test("classifies unknown errors as TRANSIENT", () => {
+      const error = provider.classifyError({ stderr: "Something unexpected happened" });
+      expect(error).toBe("TRANSIENT");
+    });
+
+    test("should combine stdout and stderr for classification", () => {
+      const result = provider.classifyError({
+        stderr: "some stderr",
+        stdout: "plan limit reached",
+      });
+      expect(result).toBe("OUT_OF_CREDITS");
+    });
+  });
+
+  describe("getInfo", () => {
+    test("should return provider information", () => {
+      const info = provider.getInfo();
+
+      expect(info).toEqual({
+        id: "codex",
+        displayName: "Codex CLI",
+        supportsStreaming: true,
+        prefersJson: false,
+        capabilities: ["generate", "edit", "test"],
+      });
+    });
+  });
+
+  describe("runOnce (integration)", () => {
+    test("should throw when binary not found", async () => {
+      // Use a non-existent binary path
+      const nonExistentConfig = { ...config, binary: "/nonexistent/path/to/codex-xyz-999" };
+      const nonExistentProvider = new CodexProvider(nonExistentConfig);
+      const req: CodingRequest = { prompt: "test" };
+      await expect(nonExistentProvider.runOnce(req, {})).rejects.toThrow(/Binary not found/);
+    });
+  });
+
+  describe("runStream (integration)", () => {
+    test("should throw when binary not found", async () => {
+      // Use a non-existent binary path
+      const nonExistentConfig = { ...config, binary: "/nonexistent/path/to/codex-xyz-999" };
+      const nonExistentProvider = new CodexProvider(nonExistentConfig);
+      const req: CodingRequest = { prompt: "test" };
+
+      try {
+        for await (const _event of nonExistentProvider.runStream(req, {})) {
+          // Should not get here
+        }
+        expect(true).toBe(false); // Fail if we get here
+      } catch (error) {
+        expect(error).toBeDefined();
+        expect((error as Error).message).toMatch(/Binary not found/);
+      }
+    });
+  });
+});