@cliangdev/flux-plugin 0.2.0 → 0.3.0

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

@@ -0,0 +1,620 @@
+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 with PRD defaults
+ */
+function createMockPrdIssue(
+  overrides: Partial<HydratedIssue> = {},
+): HydratedIssue {
+  return {
+    id: "issue_abc123",
+    identifier: "ENG-42",
+    title: "Test PRD",
+    description: "Test description",
+    stateName: "Backlog",
+    stateType: "backlog",
+    labels: ["prd"],
+    parentIdentifier: undefined,
+    priority: 3,
+    createdAt: new Date("2024-01-01T00:00:00Z"),
+    updatedAt: new Date("2024-01-01T00:00:00Z"),
+    _raw: {},
+    ...overrides,
+  };
+}
+
+describe("LinearAdapter - PRD CRUD Operations", () => {
+  const mockConfig: LinearConfig = {
+    apiKey: "lin_api_test123",
+    teamId: "team_123",
+    projectId: "proj_container",
+    defaultLabels: {
+      prd: "prd",
+      epic: "epic",
+      task: "task",
+    },
+  };
+
+  let adapter: LinearAdapter;
+
+  beforeEach(async () => {
+    // Dynamic import to avoid module caching issues
+    const { LinearAdapter: LA } = await import("../linear/adapter.js");
+    adapter = new LA(mockConfig);
+  });
+
+  describe("createPrd", () => {
+    test("creates Linear Issue with prd label and returns Prd", async () => {
+      const mockCreatedIssue = createMockPrdIssue({
+        id: "issue_abc123",
+        identifier: "ENG-42",
+        title: "User Authentication",
+        description: "Implement user login and registration",
+        stateName: "Backlog",
+      });
+
+      // Mock getLabelId
+      (adapter as any).getLabelId = mock(async () => "label_prd_123");
+
+      // Mock client.execute and createIssue
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+        client: {
+          createIssue: mock(async () => ({ issue: { id: "issue_abc123" } })),
+        },
+      };
+
+      // Mock hydrateIssue to return our prepared result
+      (adapter as any).hydrateIssue = mock(async () => mockCreatedIssue);
+
+      const prd = await adapter.createPrd({
+        title: "User Authentication",
+        description: "Implement user login and registration",
+      });
+
+      expect(prd.id).toBe("issue_abc123");
+      expect(prd.projectId).toBe("proj_container");
+      expect(prd.ref).toBe("ENG-42");
+      expect(prd.title).toBe("User Authentication");
+      expect(prd.description).toBe("Implement user login and registration");
+      expect(prd.status).toBe("DRAFT"); // Backlog -> DRAFT
+    });
+
+    test("creates PRD without optional description", async () => {
+      const mockCreatedIssue = createMockPrdIssue({
+        id: "issue_xyz",
+        identifier: "ENG-99",
+        title: "Minimal PRD",
+        description: undefined,
+      });
+
+      (adapter as any).getLabelId = mock(async () => "label_prd_123");
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+        client: {
+          createIssue: mock(async () => ({ issue: { id: "issue_xyz" } })),
+        },
+      };
+      (adapter as any).hydrateIssue = mock(async () => mockCreatedIssue);
+
+      const prd = await adapter.createPrd({
+        title: "Minimal PRD",
+      });
+
+      expect(prd.title).toBe("Minimal PRD");
+      expect(prd.description).toBeUndefined();
+      expect(prd.status).toBe("DRAFT");
+    });
+  });
+
+  describe("getPrd", () => {
+    test("returns Prd when issue exists and has prd label", async () => {
+      const mockIssue = createMockPrdIssue({
+        id: "issue_abc123",
+        identifier: "ENG-42",
+        title: "User Authentication",
+        description: "Implement user login",
+        stateName: "In Progress",
+        stateType: "started",
+        labels: ["prd"],
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockIssue);
+
+      const prd = await adapter.getPrd("ENG-42");
+
+      expect(prd).not.toBeNull();
+      expect(prd?.id).toBe("issue_abc123");
+      expect(prd?.ref).toBe("ENG-42");
+      expect(prd?.title).toBe("User Authentication");
+      expect(prd?.status).toBe("APPROVED"); // In Progress -> APPROVED
+    });
+
+    test("returns null when issue does not exist", async () => {
+      (adapter as any).fetchIssue = mock(async () => null);
+
+      const prd = await adapter.getPrd("ENG-999");
+
+      expect(prd).toBeNull();
+    });
+
+    test("returns null when issue exists but lacks prd label", async () => {
+      const mockIssue = createMockPrdIssue({
+        identifier: "ENG-42",
+        labels: ["epic"], // epic label, not prd
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockIssue);
+
+      const prd = await adapter.getPrd("ENG-42");
+
+      expect(prd).toBeNull();
+    });
+  });
+
+  describe("updatePrd", () => {
+    test("updates issue and returns updated Prd", async () => {
+      const mockIssue = createMockPrdIssue({
+        identifier: "ENG-42",
+        title: "Old Title",
+        labels: ["prd"],
+        _raw: {
+          update: mock(async () => ({})),
+        },
+      });
+
+      const mockUpdatedIssue = createMockPrdIssue({
+        identifier: "ENG-42",
+        title: "User Authentication v2",
+        description: "Updated description",
+        stateName: "In Progress",
+        stateType: "started",
+        labels: ["prd"],
+      });
+
+      // fetchIssue returns original first, then updated
+      let fetchCount = 0;
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCount++;
+        return fetchCount === 1 ? mockIssue : mockUpdatedIssue;
+      });
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const prd = await adapter.updatePrd("ENG-42", {
+        title: "User Authentication v2",
+        description: "Updated description",
+      });
+
+      expect(prd.title).toBe("User Authentication v2");
+      expect(prd.description).toBe("Updated description");
+      expect(prd.status).toBe("APPROVED"); // In Progress -> APPROVED
+    });
+
+    test("throws error when PRD not found", async () => {
+      (adapter as any).fetchIssue = mock(async () => null);
+
+      await expect(
+        adapter.updatePrd("ENG-999", { title: "New Title" }),
+      ).rejects.toThrow("PRD not found: ENG-999");
+    });
+
+    test("throws error when issue is not a PRD", async () => {
+      const mockIssue = createMockPrdIssue({
+        identifier: "ENG-42",
+        labels: ["epic"], // Not a PRD
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockIssue);
+
+      await expect(
+        adapter.updatePrd("ENG-42", { title: "New Title" }),
+      ).rejects.toThrow("Issue ENG-42 is not a PRD");
+    });
+  });
+
+  describe("listPrds", () => {
+    test("returns paginated list of PRDs filtered by prd label", async () => {
+      const mockIssues = [
+        createMockPrdIssue({
+          id: "issue_1",
+          identifier: "ENG-1",
+          title: "PRD 1",
+          description: "Description 1",
+          stateName: "Backlog",
+          labels: ["prd"],
+        }),
+        createMockPrdIssue({
+          id: "issue_2",
+          identifier: "ENG-2",
+          title: "PRD 2",
+          description: "Description 2",
+          stateName: "In Progress",
+          labels: ["prd"],
+        }),
+      ];
+
+      (adapter as any).fetchIssues = mock(async () => mockIssues);
+
+      const result = await adapter.listPrds({}, { limit: 2, offset: 0 });
+
+      expect(result.items.length).toBe(2);
+      expect(result.items[0].ref).toBe("ENG-1");
+      expect(result.items[0].title).toBe("PRD 1");
+      expect(result.items[0].status).toBe("DRAFT");
+      expect(result.items[1].ref).toBe("ENG-2");
+      expect(result.items[1].title).toBe("PRD 2");
+      expect(result.items[1].status).toBe("APPROVED");
+      expect(result.limit).toBe(2);
+      expect(result.offset).toBe(0);
+    });
+
+    test("returns empty list when no PRDs exist", async () => {
+      (adapter as any).fetchIssues = mock(async () => []);
+
+      const result = await adapter.listPrds({}, { limit: 10, offset: 0 });
+
+      expect(result.items.length).toBe(0);
+      expect(result.total).toBe(0);
+      expect(result.hasMore).toBe(false);
+    });
+
+    test("uses default pagination when not specified", async () => {
+      (adapter as any).fetchIssues = mock(async () => []);
+
+      const result = await adapter.listPrds();
+
+      expect(result.limit).toBe(50); // default limit
+      expect(result.offset).toBe(0); // default offset
+    });
+
+    test("filters out non-PRD issues", async () => {
+      const mockIssues = [
+        createMockPrdIssue({
+          id: "issue_1",
+          identifier: "ENG-1",
+          title: "PRD 1",
+          labels: ["prd"],
+        }),
+        createMockPrdIssue({
+          id: "issue_2",
+          identifier: "ENG-2",
+          title: "Epic (not a PRD)",
+          labels: ["epic"], // This should be filtered out
+        }),
+      ];
+
+      (adapter as any).fetchIssues = mock(async () => mockIssues);
+
+      const result = await adapter.listPrds({}, { limit: 10, offset: 0 });
+
+      expect(result.items.length).toBe(1);
+      expect(result.items[0].ref).toBe("ENG-1");
+    });
+  });
+
+  describe("deletePrd", () => {
+    test("archives PRD issue and its children", async () => {
+      const mockTaskArchive = mock(async () => ({ success: true }));
+      const mockEpicArchive = mock(async () => ({ success: true }));
+      const mockPrdArchive = mock(async () => ({ success: true }));
+
+      const mockChildEpic = createMockPrdIssue({
+        id: "epic_1",
+        identifier: "ENG-2",
+        labels: ["epic"],
+        _raw: {
+          archive: mockEpicArchive,
+          children: mock(async () => ({
+            nodes: [
+              {
+                id: "task_1",
+                archive: mockTaskArchive,
+              },
+            ],
+          })),
+        },
+      });
+
+      const mockPrdIssue = createMockPrdIssue({
+        id: "issue_abc123",
+        identifier: "ENG-1",
+        labels: ["prd"],
+        _raw: {
+          archive: mockPrdArchive,
+          children: mock(async () => ({
+            nodes: [mockChildEpic._raw],
+          })),
+        },
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockPrdIssue);
+      (adapter as any).hydrateIssue = mock(async () => mockChildEpic);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const result = await adapter.deletePrd("ENG-1");
+
+      expect(result.deleted).toBe("ENG-1");
+      expect(result.cascade.epics).toBe(1);
+      expect(result.cascade.tasks).toBe(1);
+      expect(mockPrdArchive).toHaveBeenCalled();
+    });
+
+    test("throws error when PRD does not exist", async () => {
+      (adapter as any).fetchIssue = mock(async () => null);
+
+      await expect(adapter.deletePrd("ENG-999")).rejects.toThrow(
+        "PRD not found: ENG-999",
+      );
+    });
+
+    test("handles PRD with no children", async () => {
+      const mockPrdArchive = mock(async () => ({ success: true }));
+      const mockPrdIssue = createMockPrdIssue({
+        id: "issue_abc123",
+        identifier: "ENG-1",
+        labels: ["prd"],
+        _raw: {
+          archive: mockPrdArchive,
+          children: mock(async () => ({ nodes: [] })),
+        },
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockPrdIssue);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const result = await adapter.deletePrd("ENG-1");
+
+      expect(result.deleted).toBe("ENG-1");
+      expect(result.cascade.epics).toBe(0);
+      expect(result.cascade.tasks).toBe(0);
+      expect(mockPrdArchive).toHaveBeenCalled();
+    });
+  });
+
+  describe("PRD Tag Support", () => {
+    test("createPrd with tag adds milestone label", async () => {
+      const mockCreatedIssue = createMockPrdIssue({
+        id: "issue_abc123",
+        identifier: "ENG-42",
+        title: "MVP Feature",
+        labels: ["prd", "flux:milestone:mvp-phase-1"],
+      });
+
+      let capturedCreateInput: any = null;
+      (adapter as any).getLabelId = mock(async () => "label_prd_123");
+      (adapter as any).getOrCreateLabel = mock(async (name: string) => {
+        if (name === "flux:milestone:mvp-phase-1") return "label_milestone_123";
+        return "label_other";
+      });
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+        client: {
+          createIssue: mock(async (input: any) => {
+            capturedCreateInput = input;
+            return { issue: { id: "issue_abc123" } };
+          }),
+        },
+      };
+      (adapter as any).hydrateIssue = mock(async () => mockCreatedIssue);
+
+      const prd = await adapter.createPrd({
+        title: "MVP Feature",
+        tag: "mvp-phase-1",
+      });
+
+      expect(prd.tag).toBe("mvp-phase-1");
+      expect(capturedCreateInput.labelIds).toContain("label_prd_123");
+      expect(capturedCreateInput.labelIds).toContain("label_milestone_123");
+    });
+
+    test("createPrd without tag does not add milestone label", async () => {
+      const mockCreatedIssue = createMockPrdIssue({
+        id: "issue_abc123",
+        identifier: "ENG-42",
+        title: "No Tag PRD",
+        labels: ["prd"],
+      });
+
+      let capturedCreateInput: any = null;
+      (adapter as any).getLabelId = mock(async () => "label_prd_123");
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+        client: {
+          createIssue: mock(async (input: any) => {
+            capturedCreateInput = input;
+            return { issue: { id: "issue_abc123" } };
+          }),
+        },
+      };
+      (adapter as any).hydrateIssue = mock(async () => mockCreatedIssue);
+
+      const prd = await adapter.createPrd({
+        title: "No Tag PRD",
+      });
+
+      expect(prd.tag).toBeUndefined();
+      expect(capturedCreateInput.labelIds).toHaveLength(1);
+      expect(capturedCreateInput.labelIds).toContain("label_prd_123");
+    });
+
+    test("getPrd extracts tag from milestone label", async () => {
+      const mockIssue = createMockPrdIssue({
+        id: "issue_abc123",
+        identifier: "ENG-42",
+        title: "Tagged PRD",
+        labels: ["prd", "flux:milestone:q1-release"],
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockIssue);
+
+      const prd = await adapter.getPrd("ENG-42");
+
+      expect(prd).not.toBeNull();
+      expect(prd?.tag).toBe("q1-release");
+    });
+
+    test("updatePrd can update tag", async () => {
+      const mockIssue = createMockPrdIssue({
+        identifier: "ENG-42",
+        title: "Test PRD",
+        labels: ["prd", "flux:milestone:old-tag"],
+        _raw: {
+          update: mock(async () => ({})),
+        },
+      });
+
+      const mockUpdatedIssue = createMockPrdIssue({
+        identifier: "ENG-42",
+        title: "Test PRD",
+        labels: ["prd", "flux:milestone:new-tag"],
+      });
+
+      let fetchCount = 0;
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCount++;
+        return fetchCount === 1 ? mockIssue : mockUpdatedIssue;
+      });
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+      (adapter as any).getOrCreateLabel = mock(async (name: string) => {
+        if (name === "prd") return "label_prd";
+        if (name === "flux:milestone:new-tag") return "label_new_tag";
+        return `label_${name}`;
+      });
+
+      const prd = await adapter.updatePrd("ENG-42", {
+        tag: "new-tag",
+      });
+
+      expect(prd.tag).toBe("new-tag");
+    });
+
+    test("updatePrd can remove tag by setting to null", async () => {
+      const mockIssue = createMockPrdIssue({
+        identifier: "ENG-42",
+        title: "Test PRD",
+        labels: ["prd", "flux:milestone:old-tag"],
+        _raw: {
+          update: mock(async () => ({})),
+        },
+      });
+
+      const mockUpdatedIssue = createMockPrdIssue({
+        identifier: "ENG-42",
+        title: "Test PRD",
+        labels: ["prd"], // No milestone label
+      });
+
+      let fetchCount = 0;
+      const capturedLabelIds: string[] = [];
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCount++;
+        return fetchCount === 1 ? mockIssue : mockUpdatedIssue;
+      });
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+      (adapter as any).getOrCreateLabel = mock(async (name: string) => {
+        const id = `label_${name.replace(/[^a-z]/g, "_")}`;
+        capturedLabelIds.push(id);
+        return id;
+      });
+
+      const prd = await adapter.updatePrd("ENG-42", {
+        tag: null as any, // Explicitly setting to null removes the tag
+      });
+
+      expect(prd.tag).toBeUndefined();
+      // Should not contain any milestone label IDs
+      expect(capturedLabelIds.some((id) => id.includes("milestone"))).toBe(
+        false,
+      );
+    });
+
+    test("updatePrd preserves tag when only updating status", async () => {
+      const mockIssue = createMockPrdIssue({
+        identifier: "ENG-42",
+        title: "Test PRD",
+        stateName: "Backlog",
+        labels: ["prd", "flux:milestone:mvp"],
+        _raw: {
+          update: mock(async () => ({})),
+        },
+      });
+
+      const mockUpdatedIssue = createMockPrdIssue({
+        identifier: "ENG-42",
+        title: "Test PRD",
+        stateName: "In Progress",
+        labels: ["prd", "flux:milestone:mvp"],
+      });
+
+      let fetchCount = 0;
+      const labelNames: string[] = [];
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCount++;
+        return fetchCount === 1 ? mockIssue : mockUpdatedIssue;
+      });
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+      (adapter as any).getStateId = mock(async () => "state_in_progress");
+      (adapter as any).getOrCreateLabel = mock(async (name: string) => {
+        labelNames.push(name);
+        return `label_${name.replace(/[^a-z]/g, "_")}`;
+      });
+
+      const prd = await adapter.updatePrd("ENG-42", {
+        status: "APPROVED",
+      });
+
+      expect(prd.tag).toBe("mvp");
+      // Milestone label should be preserved
+      expect(labelNames).toContain("flux:milestone:mvp");
+    });
+
+    test("listPrds filters by tag", async () => {
+      const mockIssues = [
+        createMockPrdIssue({
+          id: "issue_1",
+          identifier: "ENG-1",
+          title: "MVP PRD",
+          labels: ["prd", "flux:milestone:mvp"],
+        }),
+        createMockPrdIssue({
+          id: "issue_2",
+          identifier: "ENG-2",
+          title: "Q2 PRD",
+          labels: ["prd", "flux:milestone:q2-release"],
+        }),
+      ];
+
+      let capturedFilter: any = null;
+      (adapter as any).fetchIssues = mock(async (filter: any) => {
+        capturedFilter = filter;
+        // Return only the MVP PRD when filtering by tag
+        return mockIssues.filter((i) =>
+          i.labels.includes("flux:milestone:mvp"),
+        );
+      });
+
+      const result = await adapter.listPrds({ tag: "mvp" });
+
+      expect(result.items.length).toBe(1);
+      expect(result.items[0].ref).toBe("ENG-1");
+      expect(result.items[0].tag).toBe("mvp");
+      // Verify the filter was constructed with AND condition
+      expect(capturedFilter.labels.and).toBeDefined();
+      expect(capturedFilter.labels.and).toHaveLength(2);
+    });
+  });
+});