@cliangdev/flux-plugin 0.1.0 → 0.2.0-dev.dc5e2c4

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.",
+      );
+    });
+  });
+});

package/src/server/adapters/__tests__/dependency-ops.test.ts

@@ -0,0 +1,395 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+import type { HydratedIssue, LinearAdapter } from "../linear/adapter.js";
+import type { LinearConfig } from "../linear/types.js";
+
+/**
+ * Helper to create a mock HydratedIssue
+ */
+function createMockIssue(
+  overrides: Partial<HydratedIssue> = {},
+): HydratedIssue {
+  return {
+    id: "issue_abc123",
+    identifier: "ENG-42",
+    title: "Test Issue",
+    description: "Test description",
+    stateName: "Backlog",
+    stateType: "backlog",
+    labels: ["epic"],
+    parentIdentifier: undefined,
+    priority: 3,
+    createdAt: new Date("2024-01-01T00:00:00Z"),
+    updatedAt: new Date("2024-01-01T00:00:00Z"),
+    _raw: {},
+    ...overrides,
+  };
+}
+
+describe("LinearAdapter - Dependency Operations", () => {
+  const mockConfig: LinearConfig = {
+    apiKey: "lin_api_test123",
+    teamId: "team_abc",
+    projectId: "proj_container",
+    defaultLabels: {
+      prd: "prd",
+      epic: "epic",
+      task: "task",
+    },
+  };
+
+  let adapter: LinearAdapter;
+
+  beforeEach(async () => {
+    const { LinearAdapter: LA } = await import("../linear/adapter.js");
+    adapter = new LA(mockConfig);
+  });
+
+  describe("addDependency", () => {
+    test("creates blocked relation between two epics", async () => {
+      const blockerIssue = createMockIssue({
+        id: "issue_epic_1",
+        identifier: "ENG-42",
+        title: "Epic 1",
+        labels: ["epic"],
+        parentIdentifier: undefined,
+      });
+
+      const blockedIssue = createMockIssue({
+        id: "issue_epic_2",
+        identifier: "ENG-43",
+        title: "Epic 2",
+        labels: ["epic"],
+        parentIdentifier: undefined,
+      });
+
+      let fetchCallCount = 0;
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCallCount++;
+        if (fetchCallCount === 1) return blockedIssue;
+        return blockerIssue;
+      });
+
+      const mockCreateRelation = mock(async () => ({
+        id: "relation_1",
+        type: "blocks",
+      }));
+
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+        client: {
+          createIssueRelation: mockCreateRelation,
+        },
+      };
+
+      await adapter.addDependency("ENG-43", "ENG-42");
+
+      expect(mockCreateRelation).toHaveBeenCalledWith({
+        issueId: "issue_epic_1", // blocker
+        relatedIssueId: "issue_epic_2", // blocked
+        type: "blocks",
+      });
+    });
+
+    test("creates blocked relation between two tasks", async () => {
+      const blockerTask = createMockIssue({
+        id: "issue_task_1",
+        identifier: "ENG-44",
+        title: "Task 1",
+        labels: ["task"],
+        parentIdentifier: "ENG-42",
+      });
+
+      const blockedTask = createMockIssue({
+        id: "issue_task_2",
+        identifier: "ENG-45",
+        title: "Task 2",
+        labels: ["task"],
+        parentIdentifier: "ENG-42",
+      });
+
+      let fetchCallCount = 0;
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCallCount++;
+        if (fetchCallCount === 1) return blockedTask;
+        return blockerTask;
+      });
+
+      const mockCreateRelation = mock(async () => ({
+        id: "relation_2",
+        type: "blocks",
+      }));
+
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+        client: {
+          createIssueRelation: mockCreateRelation,
+        },
+      };
+
+      await adapter.addDependency("ENG-45", "ENG-44");
+
+      expect(mockCreateRelation).toHaveBeenCalledWith({
+        issueId: "issue_task_1",
+        relatedIssueId: "issue_task_2",
+        type: "blocks",
+      });
+    });
+
+    test("throws error if dependsOnRef issue not found", async () => {
+      const blockedIssue = createMockIssue({
+        id: "issue_epic_1",
+        identifier: "ENG-42",
+        labels: ["epic"],
+      });
+
+      let fetchCallCount = 0;
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCallCount++;
+        if (fetchCallCount === 1) return blockedIssue;
+        return null;
+      });
+
+      await expect(
+        adapter.addDependency("ENG-42", "INVALID-1"),
+      ).rejects.toThrow("Issue not found: INVALID-1");
+    });
+
+    test("throws error if entity types don't match (epic and task)", async () => {
+      const epicIssue = createMockIssue({
+        id: "issue_epic_1",
+        identifier: "ENG-42",
+        labels: ["epic"],
+        parentIdentifier: undefined,
+      });
+
+      const taskIssue = createMockIssue({
+        id: "issue_task_1",
+        identifier: "ENG-43",
+        labels: ["task"],
+        parentIdentifier: "ENG-42",
+      });
+
+      let fetchCallCount = 0;
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCallCount++;
+        if (fetchCallCount === 1) return epicIssue;
+        return taskIssue;
+      });
+
+      await expect(adapter.addDependency("ENG-42", "ENG-43")).rejects.toThrow(
+        "Cannot create dependency between different entity types (epic and task)",
+      );
+    });
+
+    test("throws error for self-dependency", async () => {
+      await expect(adapter.addDependency("ENG-42", "ENG-42")).rejects.toThrow(
+        "Entity cannot depend on itself",
+      );
+    });
+  });
+
+  describe("removeDependency", () => {
+    test("removes blocked relation between issues", async () => {
+      const mockDelete = mock(async () => ({ success: true }));
+      const mockRelation = {
+        id: "relation_1",
+        type: "blocks",
+        issue: { id: "issue_epic_1", identifier: "ENG-42" },
+        relatedIssue: { id: "issue_epic_2", identifier: "ENG-43" },
+        delete: mockDelete,
+      };
+
+      const blockerIssue = createMockIssue({
+        id: "issue_epic_1",
+        identifier: "ENG-42",
+      });
+
+      const blockedIssue = createMockIssue({
+        id: "issue_epic_2",
+        identifier: "ENG-43",
+        _raw: {
+          relations: mock(async () => ({
+            nodes: [mockRelation],
+          })),
+        },
+      });
+
+      let fetchCallCount = 0;
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCallCount++;
+        if (fetchCallCount === 1) return blockedIssue;
+        return blockerIssue;
+      });
+
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      await adapter.removeDependency("ENG-43", "ENG-42");
+
+      expect(mockDelete).toHaveBeenCalled();
+    });
+
+    test("throws error if dependsOnRef issue not found", async () => {
+      const blockedIssue = createMockIssue({
+        id: "issue_epic_1",
+        identifier: "ENG-42",
+        _raw: {
+          relations: mock(async () => ({ nodes: [] })),
+        },
+      });
+
+      let fetchCallCount = 0;
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCallCount++;
+        if (fetchCallCount === 1) return blockedIssue;
+        return null;
+      });
+
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      await expect(
+        adapter.removeDependency("ENG-42", "INVALID-1"),
+      ).rejects.toThrow("Issue not found: INVALID-1");
+    });
+
+    test("throws error if relation not found", async () => {
+      const blockerIssue = createMockIssue({
+        id: "issue_epic_1",
+        identifier: "ENG-42",
+      });
+
+      const blockedIssue = createMockIssue({
+        id: "issue_epic_2",
+        identifier: "ENG-43",
+        _raw: {
+          relations: mock(async () => ({
+            nodes: [], // No relations
+          })),
+        },
+      });
+
+      let fetchCallCount = 0;
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCallCount++;
+        if (fetchCallCount === 1) return blockedIssue;
+        return blockerIssue;
+      });
+
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      await expect(
+        adapter.removeDependency("ENG-43", "ENG-42"),
+      ).rejects.toThrow("Dependency not found between ENG-43 and ENG-42");
+    });
+  });
+
+  describe("getDependencies", () => {
+    test("returns list of blocking issue refs", async () => {
+      const mockIssue = createMockIssue({
+        id: "issue_epic_1",
+        identifier: "ENG-43",
+        _raw: {
+          relations: mock(async () => ({
+            nodes: [
+              {
+                id: "relation_1",
+                type: "blocks",
+                issue: { id: "issue_epic_2", identifier: "ENG-42" },
+                relatedIssue: { id: "issue_epic_1", identifier: "ENG-43" },
+              },
+              {
+                id: "relation_2",
+                type: "blocks",
+                issue: { id: "issue_epic_3", identifier: "ENG-44" },
+                relatedIssue: { id: "issue_epic_1", identifier: "ENG-43" },
+              },
+            ],
+          })),
+        },
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockIssue);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const dependencies = await adapter.getDependencies("ENG-43");
+
+      expect(dependencies).toEqual(["ENG-42", "ENG-44"]);
+    });
+
+    test("returns empty array if no dependencies", async () => {
+      const mockIssue = createMockIssue({
+        id: "issue_epic_1",
+        identifier: "ENG-42",
+        _raw: {
+          relations: mock(async () => ({
+            nodes: [],
+          })),
+        },
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockIssue);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const dependencies = await adapter.getDependencies("ENG-42");
+
+      expect(dependencies).toEqual([]);
+    });
+
+    test("filters out non-blocking relations", async () => {
+      const mockIssue = createMockIssue({
+        id: "issue_epic_1",
+        identifier: "ENG-43",
+        _raw: {
+          relations: mock(async () => ({
+            nodes: [
+              {
+                id: "relation_1",
+                type: "blocks",
+                issue: { id: "issue_epic_2", identifier: "ENG-42" },
+                relatedIssue: { id: "issue_epic_1", identifier: "ENG-43" },
+              },
+              {
+                id: "relation_2",
+                type: "duplicate",
+                issue: { id: "issue_epic_3", identifier: "ENG-44" },
+                relatedIssue: { id: "issue_epic_1", identifier: "ENG-43" },
+              },
+              {
+                id: "relation_3",
+                type: "related",
+                issue: { id: "issue_epic_4", identifier: "ENG-45" },
+                relatedIssue: { id: "issue_epic_1", identifier: "ENG-43" },
+              },
+            ],
+          })),
+        },
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockIssue);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const dependencies = await adapter.getDependencies("ENG-43");
+
+      expect(dependencies).toEqual(["ENG-42"]);
+    });
+
+    test("throws error if issue not found", async () => {
+      (adapter as any).fetchIssue = mock(async () => null);
+
+      await expect(adapter.getDependencies("INVALID-1")).rejects.toThrow(
+        "Issue not found: INVALID-1",
+      );
+    });
+  });
+});