@cliangdev/flux-plugin 0.0.0-dev.cbdf207 → 0.0.0-dev.df3e9bb

package/src/server/adapters/__tests__/a-client-linear.test.ts

@@ -0,0 +1,197 @@
+import { describe, expect, test } from "bun:test";
+import { LinearApiError, LinearClient } from "../linear/client.js";
+
+const config = {
+  apiKey: "lin_api_test123",
+  teamId: "TEAM-123",
+  projectId: "proj_container",
+  defaultLabels: { prd: "prd", epic: "epic", task: "task" },
+};
+
+describe("LinearClient", () => {
+  describe("constructor", () => {
+    test("creates client with valid config", () => {
+      const client = new LinearClient(config);
+
+      expect(client).toBeDefined();
+      expect(client.client).toBeDefined();
+    });
+
+    test("accepts custom retry options", () => {
+      const client = new LinearClient(config, {
+        maxRetries: 5,
+        baseDelay: 500,
+      });
+
+      expect(client).toBeDefined();
+    });
+  });
+
+  describe("execute - retry logic", () => {
+    test("returns result on successful operation", async () => {
+      const client = new LinearClient(config);
+      let callCount = 0;
+      const operation = () => {
+        callCount++;
+        return Promise.resolve({ data: "success" });
+      };
+
+      const result = await client.execute(operation);
+
+      expect(result).toEqual({ data: "success" });
+      expect(callCount).toBe(1);
+    });
+
+    test("retries on network error and succeeds", async () => {
+      const client = new LinearClient(config, { maxRetries: 3, baseDelay: 10 });
+      let attempts = 0;
+      const operation = () => {
+        attempts++;
+        if (attempts < 3) {
+          const error: any = new Error("Network error");
+          error.code = "ECONNRESET";
+          return Promise.reject(error);
+        }
+        return Promise.resolve({ data: "success" });
+      };
+
+      const result = await client.execute(operation);
+
+      expect(result).toEqual({ data: "success" });
+      expect(attempts).toBe(3);
+    });
+
+    test("retries on rate limit error (429) and succeeds", async () => {
+      const client = new LinearClient(config, { maxRetries: 3, baseDelay: 10 });
+      let attempts = 0;
+      const operation = () => {
+        attempts++;
+        if (attempts < 2) {
+          const error: any = new Error("Rate limited");
+          error.status = 429;
+          return Promise.reject(error);
+        }
+        return Promise.resolve({ data: "success" });
+      };
+
+      const result = await client.execute(operation);
+
+      expect(result).toEqual({ data: "success" });
+      expect(attempts).toBe(2);
+    });
+
+    test("throws LinearApiError after max retries exhausted (rate limit)", async () => {
+      const client = new LinearClient(config, { maxRetries: 2, baseDelay: 10 });
+      const operation = () => {
+        const error: any = new Error("Rate limited");
+        error.status = 429;
+        return Promise.reject(error);
+      };
+
+      await expect(client.execute(operation)).rejects.toThrow(LinearApiError);
+      await expect(client.execute(operation)).rejects.toThrow(
+        "Rate limited after 2 retries",
+      );
+    });
+
+    test("throws LinearApiError after max retries exhausted (network error)", async () => {
+      const client = new LinearClient(config, { maxRetries: 2, baseDelay: 10 });
+      const operation = () => {
+        const error: any = new Error("Connection failed");
+        error.code = "ECONNREFUSED";
+        return Promise.reject(error);
+      };
+
+      await expect(client.execute(operation)).rejects.toThrow(LinearApiError);
+      await expect(client.execute(operation)).rejects.toThrow(
+        "Network error after 2 retries",
+      );
+    });
+
+    test("throws immediately on unauthorized error (401)", async () => {
+      const client = new LinearClient(config);
+      const operation = () => {
+        const error: any = new Error("Unauthorized");
+        error.status = 401;
+        return Promise.reject(error);
+      };
+
+      await expect(client.execute(operation)).rejects.toThrow(LinearApiError);
+      await expect(client.execute(operation)).rejects.toThrow(
+        "Unauthorized: Invalid API key",
+      );
+    });
+
+    test("throws immediately on other API errors", async () => {
+      const client = new LinearClient(config);
+      let callCount = 0;
+      const operation = () => {
+        callCount++;
+        const error: any = new Error("Bad request");
+        error.status = 400;
+        return Promise.reject(error);
+      };
+
+      await expect(client.execute(operation)).rejects.toThrow(LinearApiError);
+      expect(callCount).toBe(1); // No retries for non-retryable errors
+    });
+  });
+
+  describe("LinearApiError", () => {
+    test("creates error with all properties", () => {
+      const originalError = new Error("Original error");
+      const error = new LinearApiError(
+        "Test error message",
+        "TEST_CODE",
+        500,
+        originalError,
+      );
+
+      expect(error).toBeInstanceOf(Error);
+      expect(error.name).toBe("LinearApiError");
+      expect(error.message).toBe("Test error message");
+      expect(error.code).toBe("TEST_CODE");
+      expect(error.statusCode).toBe(500);
+      expect(error.originalError).toBe(originalError);
+    });
+
+    test("creates error without optional fields", () => {
+      const error = new LinearApiError("Test error", "TEST_CODE");
+
+      expect(error.message).toBe("Test error");
+      expect(error.code).toBe("TEST_CODE");
+      expect(error.statusCode).toBeUndefined();
+      expect(error.originalError).toBeUndefined();
+    });
+  });
+
+  describe("exponential backoff", () => {
+    test("applies exponential backoff with jitter", async () => {
+      const client = new LinearClient(config, {
+        maxRetries: 3,
+        baseDelay: 100,
+      });
+      const startTime = Date.now();
+      let attempts = 0;
+
+      const operation = () => {
+        attempts++;
+        if (attempts <= 3) {
+          const error: any = new Error("Rate limited");
+          error.status = 429;
+          return Promise.reject(error);
+        }
+        return Promise.resolve({ data: "success" });
+      };
+
+      const result = await client.execute(operation);
+
+      const elapsed = Date.now() - startTime;
+
+      // Expected delays: ~100ms, ~200ms, ~400ms (with jitter ±10%)
+      // Total: ~700ms minimum
+      expect(elapsed).toBeGreaterThanOrEqual(630); // 700ms - 10% jitter
+      expect(result).toEqual({ data: "success" });
+    });
+  });
+});

package/src/server/adapters/__tests__/adapter-factory.test.ts

@@ -0,0 +1,230 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+  existsSync,
+  mkdirSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+
+describe("Adapter Factory", () => {
+  const originalEnv = process.env.FLUX_PROJECT_ROOT;
+  const TEST_DIR = `${realpathSync(tmpdir())}/flux-factory-test-${Date.now()}`;
+  const FLUX_DIR = `${TEST_DIR}/.flux`;
+  const PROJECT_JSON_PATH = `${FLUX_DIR}/project.json`;
+  const LINEAR_CONFIG_PATH = `${FLUX_DIR}/linear-config.json`;
+
+  beforeEach(async () => {
+    // Clean up any previous test directory
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true });
+    }
+
+    // Create test directory structure
+    mkdirSync(FLUX_DIR, { recursive: true });
+
+    // Set project root to test directory
+    process.env.FLUX_PROJECT_ROOT = TEST_DIR;
+
+    // Clear caches
+    const { config } = await import("../../config.js");
+    config.clearCache();
+
+    const { clearAdapterCache } = await import("../factory.js");
+    clearAdapterCache();
+  });
+
+  afterEach(async () => {
+    // Restore original env
+    if (originalEnv !== undefined) {
+      process.env.FLUX_PROJECT_ROOT = originalEnv;
+    } else {
+      delete process.env.FLUX_PROJECT_ROOT;
+    }
+
+    // Clear caches
+    const { config } = await import("../../config.js");
+    config.clearCache();
+
+    const { clearAdapterCache } = await import("../factory.js");
+    clearAdapterCache();
+
+    // Clean up test directory
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true });
+    }
+  });
+
+  describe("getAdapter with default configuration", () => {
+    test("returns LocalAdapter when no project.json exists", async () => {
+      const { getAdapter } = await import("../factory.js");
+      const { LocalAdapter } = await import("../local-adapter.js");
+
+      const adapter = getAdapter();
+
+      expect(adapter).toBeInstanceOf(LocalAdapter);
+    });
+
+    test("returns LocalAdapter when project.json has no adapter config", async () => {
+      writeFileSync(
+        PROJECT_JSON_PATH,
+        JSON.stringify({
+          name: "test-project",
+          // No adapter config - should default to local
+        }),
+      );
+
+      const { getAdapter } = await import("../factory.js");
+      const { LocalAdapter } = await import("../local-adapter.js");
+
+      const adapter = getAdapter(true); // Force new adapter to pick up config
+
+      expect(adapter).toBeInstanceOf(LocalAdapter);
+    });
+
+    test("returns LocalAdapter when project.json explicitly sets adapter.type='local'", async () => {
+      writeFileSync(
+        PROJECT_JSON_PATH,
+        JSON.stringify({
+          name: "test-project",
+          adapter: { type: "local" },
+        }),
+      );
+
+      const { getAdapter } = await import("../factory.js");
+      const { LocalAdapter } = await import("../local-adapter.js");
+
+      const adapter = getAdapter(true);
+
+      expect(adapter).toBeInstanceOf(LocalAdapter);
+    });
+  });
+
+  describe("getAdapter with Linear configuration", () => {
+    test("returns LinearAdapter when project.json has adapter.type='linear' and config exists", async () => {
+      // Create project.json with Linear adapter
+      writeFileSync(
+        PROJECT_JSON_PATH,
+        JSON.stringify({
+          name: "test-project",
+          adapter: { type: "linear" },
+        }),
+      );
+
+      // Create Linear config file
+      writeFileSync(
+        LINEAR_CONFIG_PATH,
+        JSON.stringify({
+          apiKey: "lin_api_test_key",
+          teamId: "TEAM-123",
+          projectId: "proj_container",
+          defaultLabels: {
+            prd: "prd",
+            epic: "epic",
+            task: "task",
+          },
+        }),
+      );
+
+      const { getAdapter } = await import("../factory.js");
+      const { LinearAdapter } = await import("../linear/adapter.js");
+
+      const adapter = getAdapter(true);
+
+      expect(adapter).toBeInstanceOf(LinearAdapter);
+    });
+
+    test("throws error when adapter.type='linear' but no config file exists", async () => {
+      // Create project.json with Linear adapter
+      writeFileSync(
+        PROJECT_JSON_PATH,
+        JSON.stringify({
+          name: "test-project",
+          adapter: { type: "linear" },
+        }),
+      );
+
+      // Don't create Linear config file
+
+      const { getAdapter } = await import("../factory.js");
+
+      expect(() => getAdapter(true)).toThrow(
+        "Linear adapter configured but no configuration found. Run configure_linear tool first.",
+      );
+    });
+  });
+
+  describe("adapter caching", () => {
+    test("returns same instance when called multiple times without forceNew", async () => {
+      const { getAdapter } = await import("../factory.js");
+
+      const adapter1 = getAdapter();
+      const adapter2 = getAdapter();
+
+      expect(adapter1).toBe(adapter2);
+    });
+
+    test("returns new instance when forceNew=true", async () => {
+      const { getAdapter } = await import("../factory.js");
+
+      const adapter1 = getAdapter();
+      const adapter2 = getAdapter(true);
+
+      expect(adapter1).not.toBe(adapter2);
+    });
+
+    test("clearAdapterCache forces new instance on next getAdapter call", async () => {
+      const { getAdapter, clearAdapterCache } = await import("../factory.js");
+
+      const adapter1 = getAdapter();
+      clearAdapterCache();
+      const adapter2 = getAdapter();
+
+      expect(adapter1).not.toBe(adapter2);
+    });
+  });
+
+  describe("createAdapter with explicit config", () => {
+    test("creates LocalAdapter when type='local'", async () => {
+      const { createAdapter } = await import("../factory.js");
+      const { LocalAdapter } = await import("../local-adapter.js");
+
+      const adapter = createAdapter({ type: "local" });
+
+      expect(adapter).toBeInstanceOf(LocalAdapter);
+    });
+
+    test("creates LinearAdapter when type='linear' and config exists", async () => {
+      // Create Linear config file
+      writeFileSync(
+        LINEAR_CONFIG_PATH,
+        JSON.stringify({
+          apiKey: "lin_api_test_key",
+          teamId: "TEAM-123",
+          projectId: "proj_container",
+          defaultLabels: {
+            prd: "prd",
+            epic: "epic",
+            task: "task",
+          },
+        }),
+      );
+
+      const { createAdapter } = await import("../factory.js");
+      const { LinearAdapter } = await import("../linear/adapter.js");
+
+      const adapter = createAdapter({ type: "linear" });
+
+      expect(adapter).toBeInstanceOf(LinearAdapter);
+    });
+
+    test("throws error when type='linear' but no config exists", async () => {
+      const { createAdapter } = await import("../factory.js");
+
+      expect(() => createAdapter({ type: "linear" })).toThrow(
+        "Linear adapter configured but no configuration found. Run configure_linear tool first.",
+      );
+    });
+  });
+});