@cliangdev/flux-plugin 0.2.0 → 0.3.0

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

@@ -0,0 +1,534 @@
+/**
+ * Task CRUD Tests for LinearAdapter
+ *
+ * Tests createTask, getTask, updateTask, listTasks, deleteTask operations.
+ * Uses the simplified mocking approach with fetchIssue/fetchIssues/hydrateIssue.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+import type { HydratedIssue, LinearAdapter } from "../linear/adapter.js";
+import type { LinearConfig } from "../linear/types.js";
+import type { CreateTaskInput, UpdateTaskInput } from "../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: ["task"],
+    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 - Task CRUD", () => {
+  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 () => {
+    const { LinearAdapter: LA } = await import("../linear/adapter.js");
+    adapter = new LA(mockConfig);
+  });
+
+  describe("createTask", () => {
+    test("creates child Issue under epic with required fields", async () => {
+      const mockEpic = createMockIssue({
+        id: "epic_abc123",
+        identifier: "ENG-42",
+        title: "Auth Epic",
+        labels: ["epic"],
+      });
+
+      const mockCreatedTask = createMockIssue({
+        id: "task_xyz789",
+        identifier: "ENG-43",
+        title: "Implement login API",
+        stateName: "Backlog",
+        labels: ["task"],
+        parentIdentifier: "ENG-42",
+        priority: 3,
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockEpic);
+      (adapter as any).getLabelId = mock(async () => "label_task_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: "task_xyz789" } })),
+        },
+      };
+      (adapter as any).hydrateIssue = mock(async () => mockCreatedTask);
+
+      const input: CreateTaskInput = {
+        epicRef: "ENG-42",
+        title: "Implement login API",
+      };
+
+      const result = await adapter.createTask(input);
+
+      expect(result.id).toBe("task_xyz789");
+      expect(result.epicId).toBe("ENG-42");
+      expect(result.ref).toBe("ENG-43");
+      expect(result.title).toBe("Implement login API");
+      expect(result.status).toBe("PENDING");
+      expect(result.priority).toBe("MEDIUM");
+    });
+
+    test("creates task with description and priority", async () => {
+      const mockEpic = createMockIssue({
+        id: "epic_abc123",
+        identifier: "ENG-42",
+        labels: ["epic"],
+      });
+
+      const mockCreatedTask = createMockIssue({
+        id: "task_xyz790",
+        identifier: "ENG-44",
+        title: "Implement logout API",
+        description: "Add logout endpoint",
+        stateName: "Backlog",
+        labels: ["task"],
+        parentIdentifier: "ENG-42",
+        priority: 2, // HIGH
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockEpic);
+      (adapter as any).getLabelId = mock(async () => "label_task_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: "task_xyz790" } })),
+        },
+      };
+      (adapter as any).hydrateIssue = mock(async () => mockCreatedTask);
+
+      const input: CreateTaskInput = {
+        epicRef: "ENG-42",
+        title: "Implement logout API",
+        description: "Add logout endpoint",
+        priority: "HIGH",
+      };
+
+      const result = await adapter.createTask(input);
+
+      expect(result.description).toBe("Add logout endpoint");
+      expect(result.priority).toBe("HIGH");
+    });
+
+    test("creates task with acceptance criteria embedded in description", async () => {
+      const mockEpic = createMockIssue({
+        id: "epic_abc123",
+        identifier: "ENG-42",
+        labels: ["epic"],
+      });
+
+      const expectedDescription =
+        "## Acceptance Criteria\n\n- [ ] Email validation works\n- [ ] Password strength check";
+
+      const mockCreatedTask = createMockIssue({
+        id: "task_xyz791",
+        identifier: "ENG-45",
+        title: "Implement user registration",
+        description: expectedDescription,
+        labels: ["task"],
+        parentIdentifier: "ENG-42",
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockEpic);
+      (adapter as any).getLabelId = mock(async () => "label_task_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: "task_xyz791" } })),
+        },
+      };
+      (adapter as any).hydrateIssue = mock(async () => mockCreatedTask);
+
+      const input: CreateTaskInput = {
+        epicRef: "ENG-42",
+        title: "Implement user registration",
+        acceptanceCriteria: [
+          "Email validation works",
+          "Password strength check",
+        ],
+      };
+
+      const result = await adapter.createTask(input);
+
+      expect(result.description).toContain("## Acceptance Criteria");
+      expect(result.description).toContain("Email validation works");
+    });
+
+    test("throws error if epic not found", async () => {
+      (adapter as any).fetchIssue = mock(async () => null);
+
+      const input: CreateTaskInput = {
+        epicRef: "ENG-999",
+        title: "Task for missing epic",
+      };
+
+      await expect(adapter.createTask(input)).rejects.toThrow(
+        "Epic not found: ENG-999",
+      );
+    });
+  });
+
+  describe("getTask", () => {
+    test("retrieves task by ref (identifier)", async () => {
+      const mockTask = createMockIssue({
+        id: "task_xyz789",
+        identifier: "ENG-43",
+        title: "Implement login API",
+        description: "Add authentication endpoint",
+        stateName: "In Progress",
+        stateType: "started",
+        labels: ["task"],
+        parentIdentifier: "ENG-42",
+        priority: 2,
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockTask);
+
+      const result = await adapter.getTask("ENG-43");
+
+      expect(result).not.toBeNull();
+      expect(result?.id).toBe("task_xyz789");
+      expect(result?.epicId).toBe("ENG-42");
+      expect(result?.ref).toBe("ENG-43");
+      expect(result?.title).toBe("Implement login API");
+      expect(result?.status).toBe("IN_PROGRESS");
+      expect(result?.priority).toBe("HIGH");
+    });
+
+    test("returns null if task not found", async () => {
+      (adapter as any).fetchIssue = mock(async () => null);
+
+      const result = await adapter.getTask("ENG-999");
+
+      expect(result).toBeNull();
+    });
+
+    test("returns task if issue has parentIdentifier (even without task label)", async () => {
+      const mockTask = createMockIssue({
+        id: "task_xyz789",
+        identifier: "ENG-43",
+        labels: [], // No labels
+        parentIdentifier: "ENG-42", // But has parent
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockTask);
+
+      const result = await adapter.getTask("ENG-43");
+
+      expect(result).not.toBeNull();
+      expect(result?.epicId).toBe("ENG-42");
+    });
+  });
+
+  describe("updateTask", () => {
+    test("updates task title", async () => {
+      const mockTask = createMockIssue({
+        id: "task_xyz789",
+        identifier: "ENG-43",
+        title: "Old Title",
+        labels: ["task"],
+        parentIdentifier: "ENG-42",
+        _raw: { update: mock(async () => ({})) },
+      });
+
+      const mockUpdatedTask = createMockIssue({
+        id: "task_xyz789",
+        identifier: "ENG-43",
+        title: "Updated login API",
+        labels: ["task"],
+        parentIdentifier: "ENG-42",
+        updatedAt: new Date("2024-01-04T00:00:00Z"),
+      });
+
+      // fetchIssue returns original first, then updated
+      let fetchCount = 0;
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCount++;
+        return fetchCount === 1 ? mockTask : mockUpdatedTask;
+      });
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const input: UpdateTaskInput = {
+        title: "Updated login API",
+      };
+
+      const result = await adapter.updateTask("ENG-43", input);
+
+      expect(result.title).toBe("Updated login API");
+    });
+
+    test("updates task status", async () => {
+      const mockTask = createMockIssue({
+        id: "task_xyz789",
+        identifier: "ENG-43",
+        stateName: "Backlog",
+        labels: ["task"],
+        parentIdentifier: "ENG-42",
+        _raw: { update: mock(async () => ({})) },
+      });
+
+      const mockUpdatedTask = createMockIssue({
+        id: "task_xyz789",
+        identifier: "ENG-43",
+        stateName: "In Progress",
+        stateType: "started",
+        labels: ["task"],
+        parentIdentifier: "ENG-42",
+      });
+
+      // fetchIssue returns original first, then updated
+      let fetchCount = 0;
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCount++;
+        return fetchCount === 1 ? mockTask : mockUpdatedTask;
+      });
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+        client: {
+          team: mock(async () => ({
+            states: mock(async () => ({
+              nodes: [
+                { id: "state_1", name: "Backlog" },
+                { id: "state_2", name: "In Progress" },
+                { id: "state_3", name: "Done" },
+              ],
+            })),
+          })),
+        },
+      };
+
+      const input: UpdateTaskInput = {
+        status: "IN_PROGRESS",
+      };
+
+      const result = await adapter.updateTask("ENG-43", input);
+
+      expect(result.status).toBe("IN_PROGRESS");
+    });
+
+    test("updates task priority", async () => {
+      const mockTask = createMockIssue({
+        id: "task_xyz789",
+        identifier: "ENG-43",
+        priority: 3,
+        labels: ["task"],
+        parentIdentifier: "ENG-42",
+        _raw: { update: mock(async () => ({})) },
+      });
+
+      const mockUpdatedTask = createMockIssue({
+        id: "task_xyz789",
+        identifier: "ENG-43",
+        priority: 2, // HIGH
+        labels: ["task"],
+        parentIdentifier: "ENG-42",
+      });
+
+      // fetchIssue returns original first, then updated
+      let fetchCount = 0;
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCount++;
+        return fetchCount === 1 ? mockTask : mockUpdatedTask;
+      });
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const input: UpdateTaskInput = {
+        priority: "HIGH",
+      };
+
+      const result = await adapter.updateTask("ENG-43", input);
+
+      expect(result.priority).toBe("HIGH");
+    });
+
+    test("throws error if task not found", async () => {
+      (adapter as any).fetchIssue = mock(async () => null);
+
+      const input: UpdateTaskInput = {
+        title: "Updated title",
+      };
+
+      await expect(adapter.updateTask("ENG-999", input)).rejects.toThrow(
+        "Task not found: ENG-999",
+      );
+    });
+  });
+
+  describe("listTasks", () => {
+    test("returns paginated tasks filtered by epicRef", async () => {
+      const mockEpic = createMockIssue({
+        id: "epic_abc123",
+        identifier: "ENG-42",
+        labels: ["epic"],
+      });
+
+      const mockTasks = [
+        createMockIssue({
+          id: "task_1",
+          identifier: "ENG-43",
+          title: "Task 1",
+          stateName: "Backlog",
+          labels: ["task"],
+          parentIdentifier: "ENG-42",
+        }),
+        createMockIssue({
+          id: "task_2",
+          identifier: "ENG-44",
+          title: "Task 2",
+          stateName: "In Progress",
+          stateType: "started",
+          labels: ["task"],
+          parentIdentifier: "ENG-42",
+          priority: 2,
+        }),
+      ];
+
+      (adapter as any).fetchIssue = mock(async () => mockEpic);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+        client: {
+          issues: mock(async () => ({
+            nodes: mockTasks.map((t) => ({ ...t })),
+            pageInfo: { hasNextPage: false },
+          })),
+        },
+      };
+      (adapter as any).hydrateIssue = mock(async (issue: any) => {
+        return mockTasks.find((t) => t.id === issue.id) || mockTasks[0];
+      });
+
+      const result = await adapter.listTasks(
+        { epicRef: "ENG-42" },
+        { limit: 50, offset: 0 },
+      );
+
+      expect(result.items).toHaveLength(2);
+      expect(result.total).toBe(2);
+      expect(result.limit).toBe(50);
+      expect(result.offset).toBe(0);
+
+      expect(result.items[0].ref).toBe("ENG-43");
+      expect(result.items[0].epicId).toBe("ENG-42");
+      expect(result.items[1].ref).toBe("ENG-44");
+    });
+
+    test("returns empty result when no tasks found", async () => {
+      const mockEpic = createMockIssue({
+        id: "epic_abc123",
+        identifier: "ENG-42",
+        labels: ["epic"],
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockEpic);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+        client: {
+          issues: mock(async () => ({
+            nodes: [],
+            pageInfo: { hasNextPage: false },
+          })),
+        },
+      };
+
+      const result = await adapter.listTasks({ epicRef: "ENG-42" });
+
+      expect(result.items).toHaveLength(0);
+      expect(result.total).toBe(0);
+      expect(result.hasMore).toBe(false);
+    });
+
+    test("throws error if epic not found", async () => {
+      (adapter as any).fetchIssue = mock(async () => null);
+
+      await expect(adapter.listTasks({ epicRef: "ENG-999" })).rejects.toThrow(
+        "Epic not found: ENG-999",
+      );
+    });
+
+    test("uses default pagination when not specified", async () => {
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+        client: {
+          issues: mock(async () => ({
+            nodes: [],
+            pageInfo: { hasNextPage: false },
+          })),
+        },
+      };
+
+      const result = await adapter.listTasks();
+
+      expect(result.limit).toBe(50);
+      expect(result.offset).toBe(0);
+    });
+  });
+
+  describe("deleteTask", () => {
+    test("archives task and returns deleted ref", async () => {
+      const mockArchive = mock(async () => ({ success: true }));
+      const mockTask = createMockIssue({
+        id: "task_xyz789",
+        identifier: "ENG-43",
+        labels: ["task"],
+        parentIdentifier: "ENG-42",
+        _raw: { archive: mockArchive },
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockTask);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const result = await adapter.deleteTask("ENG-43");
+
+      expect(result.deleted).toBe("ENG-43");
+      expect(result.cascade.criteria).toBe(0);
+      expect(result.cascade.tasks).toBe(0);
+      expect(result.cascade.epics).toBe(0);
+      expect(result.cascade.dependencies).toBe(0);
+      expect(mockArchive).toHaveBeenCalled();
+    });
+
+    test("throws error if task not found", async () => {
+      (adapter as any).fetchIssue = mock(async () => null);
+
+      await expect(adapter.deleteTask("ENG-999")).rejects.toThrow(
+        "Task not found: ENG-999",
+      );
+    });
+  });
+});