@cliangdev/flux-plugin 0.2.0 → 0.3.0

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

@@ -0,0 +1,429 @@
+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",
+        // Linear SDK returns promises for lazy-loaded related objects
+        issue: Promise.resolve({ id: "issue_epic_1", identifier: "ENG-42" }),
+        relatedIssue: Promise.resolve({
+          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: {
+          inverseRelations: 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: {
+          inverseRelations: 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: {
+          inverseRelations: 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: {
+          inverseRelations: mock(async () => ({
+            nodes: [
+              {
+                id: "relation_1",
+                type: "blocks",
+                issue: Promise.resolve({
+                  id: "issue_epic_2",
+                  identifier: "ENG-42",
+                }),
+                relatedIssue: Promise.resolve({
+                  id: "issue_epic_1",
+                  identifier: "ENG-43",
+                }),
+              },
+              {
+                id: "relation_2",
+                type: "blocks",
+                issue: Promise.resolve({
+                  id: "issue_epic_3",
+                  identifier: "ENG-44",
+                }),
+                relatedIssue: Promise.resolve({
+                  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: {
+          inverseRelations: 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: {
+          inverseRelations: mock(async () => ({
+            nodes: [
+              {
+                id: "relation_1",
+                type: "blocks",
+                issue: Promise.resolve({
+                  id: "issue_epic_2",
+                  identifier: "ENG-42",
+                }),
+                relatedIssue: Promise.resolve({
+                  id: "issue_epic_1",
+                  identifier: "ENG-43",
+                }),
+              },
+              {
+                id: "relation_2",
+                type: "duplicate",
+                issue: Promise.resolve({
+                  id: "issue_epic_3",
+                  identifier: "ENG-44",
+                }),
+                relatedIssue: Promise.resolve({
+                  id: "issue_epic_1",
+                  identifier: "ENG-43",
+                }),
+              },
+              {
+                id: "relation_3",
+                type: "related",
+                issue: Promise.resolve({
+                  id: "issue_epic_4",
+                  identifier: "ENG-45",
+                }),
+                relatedIssue: Promise.resolve({
+                  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",
+      );
+    });
+  });
+});