@cliangdev/flux-plugin 0.2.0 → 0.3.0

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

@@ -0,0 +1,306 @@
+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 { Document } 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: ["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 - Document 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 () => {
+    const { LinearAdapter: LA } = await import("../linear/adapter.js");
+    adapter = new LA(mockConfig);
+  });
+
+  describe("saveDocument", () => {
+    test("creates attachment for PRD and returns document with URL", async () => {
+      const mockPrdIssue = createMockIssue({
+        id: "issue_prd_123",
+        identifier: "ENG-1",
+        title: "Test PRD",
+        labels: ["prd"],
+        _raw: {
+          attachments: mock(async () => ({
+            nodes: [],
+          })),
+        },
+      });
+
+      const mockAttachment = {
+        id: "att_123",
+        title: "prd.md",
+        url:
+          "data:text/markdown;base64," +
+          Buffer.from(
+            "# Product Requirements Document\n\nContent here...",
+          ).toString("base64"),
+        createdAt: "2024-01-01T00:00:00Z",
+      };
+
+      (adapter as any).fetchIssue = mock(async () => mockPrdIssue);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+        client: {
+          attachmentCreate: mock(async () => ({
+            attachment: mockAttachment,
+            success: true,
+          })),
+        },
+      };
+
+      const doc: Document = {
+        prdRef: "ENG-1",
+        filename: "prd.md",
+        content: "# Product Requirements Document\n\nContent here...",
+      };
+
+      const savedDoc = await adapter.saveDocument(doc);
+
+      expect(savedDoc.prdRef).toBe("ENG-1");
+      expect(savedDoc.filename).toBe("prd.md");
+      expect(savedDoc.content).toBe(doc.content);
+      expect(savedDoc.url).toContain("data:text/markdown;base64,");
+    });
+
+    test("updates existing document if filename already exists", async () => {
+      const mockArchive = mock(async () => ({ success: true }));
+      const existingAttachment = {
+        id: "att_existing",
+        title: "prd.md",
+        url: "data:text/markdown;base64,b2xkIGNvbnRlbnQ=",
+        archive: mockArchive,
+      };
+
+      const mockPrdIssue = createMockIssue({
+        id: "issue_prd_123",
+        identifier: "ENG-1",
+        title: "Test PRD",
+        labels: ["prd"],
+        _raw: {
+          attachments: mock(async () => ({
+            nodes: [existingAttachment],
+          })),
+        },
+      });
+
+      const newAttachment = {
+        id: "att_new",
+        title: "prd.md",
+        url:
+          "data:text/markdown;base64," +
+          Buffer.from("# Updated Content").toString("base64"),
+        createdAt: "2024-01-02T00:00:00Z",
+      };
+
+      (adapter as any).fetchIssue = mock(async () => mockPrdIssue);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+        client: {
+          attachmentCreate: mock(async () => ({
+            attachment: newAttachment,
+            success: true,
+          })),
+        },
+      };
+
+      const doc: Document = {
+        prdRef: "ENG-1",
+        filename: "prd.md",
+        content: "# Updated Content",
+      };
+
+      const savedDoc = await adapter.saveDocument(doc);
+
+      expect(savedDoc.url).toContain("data:text/markdown;base64,");
+      expect(mockArchive).toHaveBeenCalled();
+    });
+
+    test("throws error when PRD does not exist", async () => {
+      (adapter as any).fetchIssue = mock(async () => null);
+
+      const doc: Document = {
+        prdRef: "ENG-999",
+        filename: "prd.md",
+        content: "Content",
+      };
+
+      await expect(adapter.saveDocument(doc)).rejects.toThrow(
+        "PRD ENG-999 not found",
+      );
+    });
+  });
+
+  describe("getDocuments", () => {
+    test("returns all documents for a PRD", async () => {
+      const mockPrdIssue = createMockIssue({
+        id: "issue_prd_123",
+        identifier: "ENG-1",
+        title: "Test PRD",
+        labels: ["prd"],
+        _raw: {
+          attachments: mock(async () => ({
+            nodes: [
+              {
+                id: "att_1",
+                title: "prd.md",
+                url:
+                  "data:text/markdown;base64," +
+                  Buffer.from("# PRD Content").toString("base64"),
+              },
+              {
+                id: "att_2",
+                title: "design.md",
+                url:
+                  "data:text/markdown;base64," +
+                  Buffer.from("# Design Doc").toString("base64"),
+              },
+            ],
+          })),
+        },
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockPrdIssue);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const documents = await adapter.getDocuments("ENG-1");
+
+      expect(documents.length).toBe(2);
+      expect(documents[0].prdRef).toBe("ENG-1");
+      expect(documents[0].filename).toBe("prd.md");
+      expect(documents[0].content).toBe("# PRD Content");
+      expect(documents[0].url).toContain("data:text/markdown;base64,");
+      expect(documents[1].filename).toBe("design.md");
+      expect(documents[1].content).toBe("# Design Doc");
+    });
+
+    test("returns empty array when PRD has no documents", async () => {
+      const mockPrdIssue = createMockIssue({
+        id: "issue_prd_123",
+        identifier: "ENG-1",
+        title: "Test PRD",
+        labels: ["prd"],
+        _raw: {
+          attachments: mock(async () => ({
+            nodes: [],
+          })),
+        },
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockPrdIssue);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const documents = await adapter.getDocuments("ENG-1");
+
+      expect(documents.length).toBe(0);
+    });
+
+    test("throws error when PRD does not exist", async () => {
+      (adapter as any).fetchIssue = mock(async () => null);
+
+      await expect(adapter.getDocuments("ENG-999")).rejects.toThrow(
+        "PRD ENG-999 not found",
+      );
+    });
+  });
+
+  describe("deleteDocument", () => {
+    test("archives attachment matching filename", async () => {
+      const mockArchive = mock(async () => ({ success: true }));
+      const mockAttachment = {
+        id: "att_123",
+        title: "prd.md",
+        url: "data:text/markdown;base64,Y29udGVudA==",
+        archive: mockArchive,
+      };
+
+      const mockPrdIssue = createMockIssue({
+        id: "issue_prd_123",
+        identifier: "ENG-1",
+        title: "Test PRD",
+        labels: ["prd"],
+        _raw: {
+          attachments: mock(async () => ({
+            nodes: [mockAttachment],
+          })),
+        },
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockPrdIssue);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      await adapter.deleteDocument("ENG-1", "prd.md");
+
+      expect(mockArchive).toHaveBeenCalled();
+    });
+
+    test("throws error when document not found", async () => {
+      const mockPrdIssue = createMockIssue({
+        id: "issue_prd_123",
+        identifier: "ENG-1",
+        title: "Test PRD",
+        labels: ["prd"],
+        _raw: {
+          attachments: mock(async () => ({
+            nodes: [],
+          })),
+        },
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockPrdIssue);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      await expect(
+        adapter.deleteDocument("ENG-1", "nonexistent.md"),
+      ).rejects.toThrow("Document nonexistent.md not found");
+    });
+
+    test("throws error when PRD does not exist", async () => {
+      (adapter as any).fetchIssue = mock(async () => null);
+
+      await expect(adapter.deleteDocument("ENG-999", "prd.md")).rejects.toThrow(
+        "PRD ENG-999 not found",
+      );
+    });
+  });
+});

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

@@ -0,0 +1,91 @@
+import { describe, expect, mock, test } from "bun:test";
+import type { HydratedIssue } from "../linear/adapter.js";
+import type { LinearConfig } from "../linear/index.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", () => {
+  const mockConfig: LinearConfig = {
+    apiKey: "lin_api_test123",
+    teamId: "TEAM-123",
+    projectId: "proj_container",
+    defaultLabels: {
+      prd: "prd",
+      epic: "epic",
+      task: "task",
+    },
+  };
+
+  describe("Instantiation", () => {
+    test("can be instantiated with valid config", async () => {
+      const { LinearAdapter: LA } = await import("../linear/adapter.js");
+      const adapter = new LA(mockConfig);
+      expect(adapter).toBeInstanceOf(LA);
+    });
+  });
+
+  describe("addCriterion", () => {
+    test("adds criterion to epic description", async () => {
+      const { LinearAdapter: LA } = await import("../linear/adapter.js");
+      const adapter = new LA(mockConfig);
+
+      const mockEpic = createMockIssue({
+        id: "issue_epic_123",
+        identifier: "ENG-42",
+        title: "Test Epic",
+        description: "Epic description",
+        labels: ["epic"],
+        parentIdentifier: "ENG-1",
+        _raw: {
+          update: mock(async () => ({})),
+        },
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockEpic);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const criterion = await adapter.addCriterion({
+        parentRef: "ENG-42",
+        criteria: "User can login",
+      });
+
+      expect(criterion.parentId).toBe("ENG-42");
+      expect(criterion.criteria).toBe("User can login");
+      expect(criterion.isMet).toBe(false);
+    });
+
+    test("throws error if parent not found", async () => {
+      const { LinearAdapter: LA } = await import("../linear/adapter.js");
+      const adapter = new LA(mockConfig);
+
+      (adapter as any).fetchIssue = mock(async () => null);
+
+      await expect(
+        adapter.addCriterion({ parentRef: "ENG-999", criteria: "test" }),
+      ).rejects.toThrow("Entity not found: ENG-999");
+    });
+  });
+});