@cliangdev/flux-plugin 0.2.0 → 0.3.0

package/src/server/adapters/__tests__/linear-epic-crud.test.ts

@@ -0,0 +1,496 @@
+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: "ENG-1",
+    priority: 3,
+    createdAt: new Date("2024-01-01T00:00:00Z"),
+    updatedAt: new Date("2024-01-01T00:00:00Z"),
+    _raw: {},
+    ...overrides,
+  };
+}
+
+describe("LinearAdapter - Epic CRUD", () => {
+  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("createEpic", () => {
+    test("creates Linear issue with epic label under PRD parent", async () => {
+      const mockPrdIssue = createMockIssue({
+        id: "prd_issue_123",
+        identifier: "ENG-1",
+        title: "Test PRD",
+        labels: ["prd"],
+      });
+
+      const mockCreatedEpic = createMockIssue({
+        id: "issue_epic_123",
+        identifier: "ENG-42",
+        title: "User Authentication",
+        description: "Implement user auth",
+        stateName: "Backlog",
+        labels: ["epic"],
+        parentIdentifier: "ENG-1",
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockPrdIssue);
+      (adapter as any).getLabelId = mock(async () => "label_epic_123");
+      (adapter as any).getStateId = mock(async () => "state_todo_123");
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+        client: {
+          createIssue: mock(async () => ({ issue: { id: "issue_epic_123" } })),
+        },
+      };
+      (adapter as any).hydrateIssue = mock(async () => mockCreatedEpic);
+
+      const epic = await adapter.createEpic({
+        prdRef: "ENG-1",
+        title: "User Authentication",
+        description: "Implement user auth",
+      });
+
+      expect(epic.ref).toBe("ENG-42");
+      expect(epic.title).toBe("User Authentication");
+      expect(epic.description).toBe("Implement user auth");
+      expect(epic.status).toBe("PENDING");
+      expect(epic.prdId).toBe("ENG-1");
+    });
+
+    test("creates epic with acceptance criteria embedded in description", async () => {
+      const mockPrdIssue = createMockIssue({
+        id: "prd_issue_123",
+        identifier: "ENG-1",
+        labels: ["prd"],
+      });
+
+      const mockCreatedEpic = createMockIssue({
+        id: "issue_epic_124",
+        identifier: "ENG-43",
+        title: "API Development",
+        description:
+          "Build REST API\n\n## Acceptance Criteria\n\n- [ ] Endpoint returns 200\n- [ ] Response is JSON",
+        stateName: "Backlog",
+        labels: ["epic"],
+        parentIdentifier: "ENG-1",
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockPrdIssue);
+      (adapter as any).getLabelId = mock(async () => "label_epic_123");
+      (adapter as any).getStateId = mock(async () => "state_todo_123");
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+        client: {
+          createIssue: mock(async () => ({ issue: { id: "issue_epic_124" } })),
+        },
+      };
+      (adapter as any).hydrateIssue = mock(async () => mockCreatedEpic);
+
+      const epic = await adapter.createEpic({
+        prdRef: "ENG-1",
+        title: "API Development",
+        description: "Build REST API",
+        acceptanceCriteria: ["Endpoint returns 200", "Response is JSON"],
+      });
+
+      expect(epic.description).toContain("## Acceptance Criteria");
+      expect(epic.description).toContain("- [ ] Endpoint returns 200");
+    });
+
+    test("throws error if PRD not found", async () => {
+      (adapter as any).fetchIssue = mock(async () => null);
+
+      await expect(
+        adapter.createEpic({
+          prdRef: "INVALID-1",
+          title: "Test Epic",
+        }),
+      ).rejects.toThrow("PRD not found: INVALID-1");
+    });
+
+    test("throws error if PRD issue is not a PRD (no prd label)", async () => {
+      const mockNotPrdIssue = createMockIssue({
+        identifier: "ENG-1",
+        labels: ["epic"], // epic label, not prd
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockNotPrdIssue);
+
+      await expect(
+        adapter.createEpic({
+          prdRef: "ENG-1",
+          title: "Test Epic",
+        }),
+      ).rejects.toThrow("Issue ENG-1 is not a PRD");
+    });
+
+    test("throws error if epic label not found", async () => {
+      const mockPrdIssue = createMockIssue({
+        id: "prd_issue_123",
+        identifier: "ENG-1",
+        labels: ["prd"],
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockPrdIssue);
+      (adapter as any).getLabelId = mock(async () => {
+        throw new Error('Label "epic" not found in team');
+      });
+
+      await expect(
+        adapter.createEpic({
+          prdRef: "ENG-1",
+          title: "Test Epic",
+        }),
+      ).rejects.toThrow('Label "epic" not found in team');
+    });
+  });
+
+  describe("getEpic", () => {
+    test("retrieves epic by ref", async () => {
+      const mockEpic = createMockIssue({
+        id: "issue_epic_123",
+        identifier: "ENG-42",
+        title: "User Authentication",
+        description: "Implement user auth",
+        stateName: "Backlog",
+        labels: ["epic"],
+        parentIdentifier: "ENG-1",
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockEpic);
+
+      const epic = await adapter.getEpic("ENG-42");
+
+      expect(epic).not.toBeNull();
+      expect(epic?.ref).toBe("ENG-42");
+      expect(epic?.title).toBe("User Authentication");
+      expect(epic?.status).toBe("PENDING");
+    });
+
+    test("returns null if epic not found", async () => {
+      (adapter as any).fetchIssue = mock(async () => null);
+
+      const epic = await adapter.getEpic("INVALID-1");
+
+      expect(epic).toBeNull();
+    });
+
+    test("returns null if issue is not an epic", async () => {
+      const mockTaskIssue = createMockIssue({
+        identifier: "ENG-42",
+        labels: ["task"],
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockTaskIssue);
+
+      const epic = await adapter.getEpic("ENG-42");
+
+      expect(epic).toBeNull();
+    });
+  });
+
+  describe("updateEpic", () => {
+    test("updates epic title", async () => {
+      const mockEpic = createMockIssue({
+        identifier: "ENG-42",
+        title: "Old Title",
+        labels: ["epic"],
+        _raw: { update: mock(async () => ({})) },
+      });
+
+      const mockUpdatedEpic = createMockIssue({
+        identifier: "ENG-42",
+        title: "New Title",
+        labels: ["epic"],
+        parentIdentifier: "ENG-1",
+      });
+
+      // fetchIssue returns original first, then updated
+      let fetchCount = 0;
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCount++;
+        return fetchCount === 1 ? mockEpic : mockUpdatedEpic;
+      });
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const epic = await adapter.updateEpic("ENG-42", {
+        title: "New Title",
+      });
+
+      expect(epic.title).toBe("New Title");
+    });
+
+    test("updates epic status", async () => {
+      const mockEpic = createMockIssue({
+        identifier: "ENG-42",
+        stateName: "Backlog",
+        labels: ["epic"],
+        _raw: { update: mock(async () => ({})) },
+      });
+
+      const mockUpdatedEpic = createMockIssue({
+        identifier: "ENG-42",
+        stateName: "In Progress",
+        stateType: "started",
+        labels: ["epic"],
+        parentIdentifier: "ENG-1",
+      });
+
+      // fetchIssue returns original first, then updated
+      let fetchCount = 0;
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCount++;
+        return fetchCount === 1 ? mockEpic : mockUpdatedEpic;
+      });
+      (adapter as any).getStateId = mock(async () => "state_in_progress");
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const epic = await adapter.updateEpic("ENG-42", {
+        status: "IN_PROGRESS",
+      });
+
+      expect(epic.status).toBe("IN_PROGRESS");
+    });
+
+    test("throws error if epic not found", async () => {
+      (adapter as any).fetchIssue = mock(async () => null);
+
+      await expect(
+        adapter.updateEpic("INVALID-1", { title: "New Title" }),
+      ).rejects.toThrow("Epic not found: INVALID-1");
+    });
+  });
+
+  describe("listEpics", () => {
+    test("returns paginated list of epics filtered by PRD", async () => {
+      const mockPrdIssue = createMockIssue({
+        id: "prd_issue_123",
+        identifier: "ENG-1",
+        labels: ["prd"],
+      });
+
+      const mockEpics = [
+        createMockIssue({
+          id: "issue_epic_1",
+          identifier: "ENG-42",
+          title: "Epic 1",
+          stateName: "Backlog",
+          labels: ["epic"],
+          parentIdentifier: "ENG-1",
+        }),
+        createMockIssue({
+          id: "issue_epic_2",
+          identifier: "ENG-43",
+          title: "Epic 2",
+          stateName: "In Progress",
+          stateType: "started",
+          labels: ["epic"],
+          parentIdentifier: "ENG-1",
+        }),
+      ];
+
+      // fetchIssue called for PRD lookup
+      (adapter as any).fetchIssue = mock(async () => mockPrdIssue);
+      (adapter as any).fetchIssues = mock(async () => mockEpics);
+
+      const result = await adapter.listEpics(
+        { prdRef: "ENG-1" },
+        { limit: 10, offset: 0 },
+      );
+
+      expect(result.items.length).toBe(2);
+      expect(result.total).toBe(2);
+      expect(result.items[0].ref).toBe("ENG-42");
+      expect(result.items[1].ref).toBe("ENG-43");
+      expect(result.hasMore).toBe(false);
+    });
+
+    test("filters epics by status", async () => {
+      const mockEpics = [
+        createMockIssue({
+          id: "issue_epic_1",
+          identifier: "ENG-42",
+          title: "Epic 1",
+          stateName: "Backlog",
+          labels: ["epic"],
+        }),
+      ];
+
+      (adapter as any).fetchIssues = mock(async () => mockEpics);
+
+      const result = await adapter.listEpics(
+        { status: "PENDING" },
+        { limit: 10, offset: 0 },
+      );
+
+      expect(result.items.length).toBe(1);
+      expect(result.items[0].status).toBe("PENDING");
+    });
+
+    test("returns empty list when no epics match filters", async () => {
+      // When prdRef is provided, fetchIssue is called to look up the PRD
+      (adapter as any).fetchIssue = mock(async () =>
+        createMockIssue({
+          id: "prd_issue_123",
+          identifier: "ENG-1",
+          labels: ["prd"],
+        }),
+      );
+      (adapter as any).fetchIssues = mock(async () => []);
+
+      const result = await adapter.listEpics(
+        { prdRef: "ENG-1" },
+        { limit: 10, offset: 0 },
+      );
+
+      expect(result.items).toEqual([]);
+      expect(result.total).toBe(0);
+      expect(result.hasMore).toBe(false);
+    });
+
+    test("handles pagination correctly", async () => {
+      const mockEpics = Array.from({ length: 15 }, (_, i) =>
+        createMockIssue({
+          id: `issue_epic_${i}`,
+          identifier: `ENG-${i}`,
+          title: `Epic ${i}`,
+          labels: ["epic"],
+        }),
+      );
+
+      (adapter as any).fetchIssues = mock(async () => mockEpics);
+
+      const result = await adapter.listEpics({}, { limit: 10, offset: 0 });
+
+      expect(result.items.length).toBe(10);
+      expect(result.total).toBe(15);
+      expect(result.hasMore).toBe(true);
+      expect(result.offset).toBe(0);
+      expect(result.limit).toBe(10);
+    });
+
+    test("filters out non-epic issues", async () => {
+      const mockIssues = [
+        createMockIssue({
+          id: "issue_epic_1",
+          identifier: "ENG-42",
+          title: "Real Epic",
+          labels: ["epic"],
+        }),
+        createMockIssue({
+          id: "issue_task_1",
+          identifier: "ENG-43",
+          title: "This is a task",
+          labels: ["task"],
+        }),
+      ];
+
+      (adapter as any).fetchIssues = mock(async () => mockIssues);
+
+      const result = await adapter.listEpics({}, { limit: 10, offset: 0 });
+
+      expect(result.items.length).toBe(1);
+      expect(result.items[0].ref).toBe("ENG-42");
+    });
+  });
+
+  describe("deleteEpic", () => {
+    test("archives epic and returns cascade info", async () => {
+      const mockArchive = mock(async () => ({ success: true }));
+      const mockEpic = createMockIssue({
+        id: "issue_epic_123",
+        identifier: "ENG-42",
+        labels: ["epic"],
+        _raw: {
+          archive: mockArchive,
+          children: mock(async () => ({ nodes: [] })),
+        },
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockEpic);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const result = await adapter.deleteEpic("ENG-42");
+
+      expect(result.deleted).toBe("ENG-42");
+      expect(result.cascade).toBeDefined();
+      expect(result.cascade.tasks).toBe(0);
+      expect(mockArchive).toHaveBeenCalled();
+    });
+
+    test("archives epic and its child tasks", async () => {
+      const mockTaskArchive = mock(async () => ({ success: true }));
+      const mockEpicArchive = mock(async () => ({ success: true }));
+
+      const mockEpic = createMockIssue({
+        id: "issue_epic_123",
+        identifier: "ENG-42",
+        labels: ["epic"],
+        _raw: {
+          archive: mockEpicArchive,
+          children: mock(async () => ({
+            nodes: [
+              { id: "task_1", archive: mockTaskArchive },
+              { id: "task_2", archive: mockTaskArchive },
+            ],
+          })),
+        },
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockEpic);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const result = await adapter.deleteEpic("ENG-42");
+
+      expect(result.deleted).toBe("ENG-42");
+      expect(result.cascade.tasks).toBe(2);
+      expect(mockEpicArchive).toHaveBeenCalled();
+    });
+
+    test("throws error if epic not found", async () => {
+      (adapter as any).fetchIssue = mock(async () => null);
+
+      await expect(adapter.deleteEpic("INVALID-1")).rejects.toThrow(
+        "Epic not found: INVALID-1",
+      );
+    });
+  });
+});