@cliangdev/flux-plugin 0.2.0 → 0.3.0

package/src/server/adapters/__tests__/linear-stats.test.ts

@@ -0,0 +1,450 @@
+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: [],
+    parentIdentifier: undefined,
+    priority: 3,
+    createdAt: new Date("2024-01-01T00:00:00Z"),
+    updatedAt: new Date("2024-01-01T00:00:00Z"),
+    _raw: {},
+    ...overrides,
+  };
+}
+
+describe("LinearAdapter - getStats (Label-based)", () => {
+  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("PRD stats (issue-based)", () => {
+    test("aggregates PRD counts by workflow state", async () => {
+      const mockIssues = [
+        createMockIssue({
+          id: "issue_1",
+          identifier: "ENG-1",
+          labels: ["prd"],
+          stateName: "Backlog",
+          stateType: "backlog",
+        }),
+        createMockIssue({
+          id: "issue_2",
+          identifier: "ENG-2",
+          labels: ["prd"],
+          stateName: "Backlog",
+          stateType: "backlog",
+        }),
+        createMockIssue({
+          id: "issue_3",
+          identifier: "ENG-3",
+          labels: ["prd"],
+          stateName: "In Progress",
+          stateType: "started",
+        }),
+        createMockIssue({
+          id: "issue_4",
+          identifier: "ENG-4",
+          labels: ["prd"],
+          stateName: "In Progress",
+          stateType: "started",
+        }),
+        createMockIssue({
+          id: "issue_5",
+          identifier: "ENG-5",
+          labels: ["prd"],
+          stateName: "Done",
+          stateType: "completed",
+        }),
+        createMockIssue({
+          id: "issue_6",
+          identifier: "ENG-6",
+          labels: ["prd"],
+          stateName: "Canceled",
+          stateType: "canceled",
+        }),
+      ];
+
+      (adapter as any).fetchIssues = mock(async () => mockIssues);
+
+      const stats = await adapter.getStats();
+
+      expect(stats.prds.total).toBe(6);
+      expect(stats.prds.draft).toBe(2); // Backlog
+      expect(stats.prds.approved).toBe(2); // In Progress
+      expect(stats.prds.completed).toBe(1); // Done
+      expect(stats.prds.archived).toBe(1); // Canceled
+    });
+
+    test("returns zero counts when no PRDs exist", async () => {
+      (adapter as any).fetchIssues = mock(async () => []);
+
+      const stats = await adapter.getStats();
+
+      expect(stats.prds.total).toBe(0);
+      expect(stats.prds.draft).toBe(0);
+      expect(stats.prds.approved).toBe(0);
+      expect(stats.prds.completed).toBe(0);
+      expect(stats.prds.archived).toBe(0);
+    });
+  });
+
+  describe("Epic stats (label-based)", () => {
+    test("aggregates epic counts by workflow state type", async () => {
+      const mockIssues = [
+        createMockIssue({
+          id: "issue_1",
+          identifier: "ENG-1",
+          labels: ["epic"],
+          stateType: "backlog",
+        }),
+        createMockIssue({
+          id: "issue_2",
+          identifier: "ENG-2",
+          labels: ["epic"],
+          stateType: "unstarted",
+        }),
+        createMockIssue({
+          id: "issue_3",
+          identifier: "ENG-3",
+          labels: ["epic"],
+          stateType: "started",
+        }),
+        createMockIssue({
+          id: "issue_4",
+          identifier: "ENG-4",
+          labels: ["epic"],
+          stateType: "started",
+        }),
+        createMockIssue({
+          id: "issue_5",
+          identifier: "ENG-5",
+          labels: ["epic"],
+          stateType: "completed",
+        }),
+      ];
+
+      (adapter as any).fetchIssues = mock(async () => mockIssues);
+
+      const stats = await adapter.getStats();
+
+      expect(stats.epics.total).toBe(5);
+      expect(stats.epics.pending).toBe(2); // backlog + unstarted
+      expect(stats.epics.inProgress).toBe(2); // started
+      expect(stats.epics.completed).toBe(1); // completed
+    });
+
+    test("returns zero counts when no epics exist", async () => {
+      const mockIssues = [
+        createMockIssue({
+          id: "issue_1",
+          identifier: "ENG-1",
+          labels: ["prd"],
+          stateType: "started",
+        }),
+        createMockIssue({
+          id: "issue_2",
+          identifier: "ENG-2",
+          labels: ["task"],
+          stateType: "started",
+        }),
+      ];
+
+      (adapter as any).fetchIssues = mock(async () => mockIssues);
+
+      const stats = await adapter.getStats();
+
+      expect(stats.epics.total).toBe(0);
+      expect(stats.epics.pending).toBe(0);
+      expect(stats.epics.inProgress).toBe(0);
+      expect(stats.epics.completed).toBe(0);
+    });
+  });
+
+  describe("Task stats (label-based)", () => {
+    test("aggregates task counts by workflow state type", async () => {
+      const mockIssues = [
+        createMockIssue({
+          id: "issue_1",
+          identifier: "ENG-1",
+          labels: ["task"],
+          stateType: "backlog",
+        }),
+        createMockIssue({
+          id: "issue_2",
+          identifier: "ENG-2",
+          labels: ["task"],
+          stateType: "unstarted",
+        }),
+        createMockIssue({
+          id: "issue_3",
+          identifier: "ENG-3",
+          labels: ["task"],
+          stateType: "started",
+        }),
+        createMockIssue({
+          id: "issue_4",
+          identifier: "ENG-4",
+          labels: ["task"],
+          stateType: "started",
+        }),
+        createMockIssue({
+          id: "issue_5",
+          identifier: "ENG-5",
+          labels: ["task"],
+          stateType: "started",
+        }),
+        createMockIssue({
+          id: "issue_6",
+          identifier: "ENG-6",
+          labels: ["task"],
+          stateType: "completed",
+        }),
+      ];
+
+      (adapter as any).fetchIssues = mock(async () => mockIssues);
+
+      const stats = await adapter.getStats();
+
+      expect(stats.tasks.total).toBe(6);
+      expect(stats.tasks.pending).toBe(2); // backlog + unstarted
+      expect(stats.tasks.inProgress).toBe(3); // started
+      expect(stats.tasks.completed).toBe(1); // completed
+    });
+
+    test("returns zero counts when no tasks exist", async () => {
+      const mockIssues = [
+        createMockIssue({
+          id: "issue_1",
+          identifier: "ENG-1",
+          labels: ["prd"],
+          stateType: "started",
+        }),
+        createMockIssue({
+          id: "issue_2",
+          identifier: "ENG-2",
+          labels: ["epic"],
+          stateType: "started",
+        }),
+      ];
+
+      (adapter as any).fetchIssues = mock(async () => mockIssues);
+
+      const stats = await adapter.getStats();
+
+      expect(stats.tasks.total).toBe(0);
+      expect(stats.tasks.pending).toBe(0);
+      expect(stats.tasks.inProgress).toBe(0);
+      expect(stats.tasks.completed).toBe(0);
+    });
+  });
+
+  describe("Combined stats", () => {
+    test("aggregates all entity types correctly", async () => {
+      const mockIssues = [
+        // PRDs
+        createMockIssue({
+          id: "prd_1",
+          identifier: "ENG-1",
+          labels: ["prd"],
+          stateName: "Backlog",
+          stateType: "backlog",
+        }),
+        createMockIssue({
+          id: "prd_2",
+          identifier: "ENG-2",
+          labels: ["prd"],
+          stateName: "In Progress",
+          stateType: "started",
+        }),
+        createMockIssue({
+          id: "prd_3",
+          identifier: "ENG-3",
+          labels: ["prd"],
+          stateName: "Done",
+          stateType: "completed",
+        }),
+        // Epics
+        createMockIssue({
+          id: "epic_1",
+          identifier: "ENG-4",
+          labels: ["epic"],
+          stateType: "backlog",
+        }),
+        createMockIssue({
+          id: "epic_2",
+          identifier: "ENG-5",
+          labels: ["epic"],
+          stateType: "started",
+        }),
+        // Tasks
+        createMockIssue({
+          id: "task_1",
+          identifier: "ENG-6",
+          labels: ["task"],
+          stateType: "backlog",
+        }),
+        createMockIssue({
+          id: "task_2",
+          identifier: "ENG-7",
+          labels: ["task"],
+          stateType: "started",
+        }),
+        createMockIssue({
+          id: "task_3",
+          identifier: "ENG-8",
+          labels: ["task"],
+          stateType: "completed",
+        }),
+      ];
+
+      (adapter as any).fetchIssues = mock(async () => mockIssues);
+
+      const stats = await adapter.getStats();
+
+      // PRDs
+      expect(stats.prds.total).toBe(3);
+      expect(stats.prds.draft).toBe(1);
+      expect(stats.prds.approved).toBe(1);
+      expect(stats.prds.completed).toBe(1);
+
+      // Epics
+      expect(stats.epics.total).toBe(2);
+      expect(stats.epics.pending).toBe(1);
+      expect(stats.epics.inProgress).toBe(1);
+
+      // Tasks
+      expect(stats.tasks.total).toBe(3);
+      expect(stats.tasks.pending).toBe(1);
+      expect(stats.tasks.inProgress).toBe(1);
+      expect(stats.tasks.completed).toBe(1);
+    });
+  });
+
+  describe("Edge cases", () => {
+    test("handles issues without state gracefully", async () => {
+      const mockIssues = [
+        createMockIssue({
+          id: "issue_1",
+          identifier: "ENG-1",
+          labels: ["epic"],
+          stateName: "Backlog", // Default fallback
+          stateType: undefined as any,
+        }),
+      ];
+
+      (adapter as any).fetchIssues = mock(async () => mockIssues);
+
+      const stats = await adapter.getStats();
+
+      // Issue without stateType should still be counted
+      expect(stats.epics.total).toBe(1);
+    });
+
+    test("handles unknown workflow states", async () => {
+      const mockIssues = [
+        createMockIssue({
+          id: "issue_1",
+          identifier: "ENG-1",
+          labels: ["prd"],
+          stateName: "Unknown State",
+          stateType: "custom" as any,
+        }),
+        createMockIssue({
+          id: "issue_2",
+          identifier: "ENG-2",
+          labels: ["prd"],
+          stateName: "Triage",
+          stateType: "triage" as any,
+        }),
+      ];
+
+      (adapter as any).fetchIssues = mock(async () => mockIssues);
+
+      const stats = await adapter.getStats();
+
+      // Unknown states should still count towards total but go to draft
+      expect(stats.prds.total).toBe(2);
+      expect(stats.prds.draft).toBe(2);
+    });
+
+    test("uses custom label names from config", async () => {
+      const customConfig: LinearConfig = {
+        apiKey: "lin_api_test123",
+        teamId: "team_123",
+        projectId: "proj_container",
+        defaultLabels: {
+          prd: "product-requirement",
+          epic: "feature",
+          task: "story",
+        },
+      };
+
+      const { LinearAdapter: LA } = await import("../linear/adapter.js");
+      const customAdapter = new LA(customConfig);
+
+      const mockIssues = [
+        createMockIssue({
+          id: "issue_1",
+          identifier: "ENG-1",
+          labels: ["product-requirement"],
+          stateName: "Backlog",
+          stateType: "backlog",
+        }),
+        createMockIssue({
+          id: "issue_2",
+          identifier: "ENG-2",
+          labels: ["feature"],
+          stateType: "started",
+        }),
+        createMockIssue({
+          id: "issue_3",
+          identifier: "ENG-3",
+          labels: ["story"],
+          stateType: "completed",
+        }),
+        // Standard labels should not match
+        createMockIssue({
+          id: "issue_4",
+          identifier: "ENG-4",
+          labels: ["prd"],
+          stateType: "started",
+        }),
+      ];
+
+      (customAdapter as any).fetchIssues = mock(async () => mockIssues);
+
+      const stats = await customAdapter.getStats();
+
+      expect(stats.prds.total).toBe(1);
+      expect(stats.epics.total).toBe(1);
+      expect(stats.tasks.total).toBe(1);
+    });
+  });
+});