@cliangdev/flux-plugin 0.0.0-dev.cbdf207 → 0.0.0-dev.df3e9bb

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");
+    });
+  });
+});

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

@@ -0,0 +1,425 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+
+describe("Linear Config", () => {
+  const originalEnv = process.env.FLUX_PROJECT_ROOT;
+  const TEST_DIR = `${realpathSync(tmpdir())}/flux-linear-config-test-${Date.now()}`;
+  const FLUX_DIR = `${TEST_DIR}/.flux`;
+  const CONFIG_PATH = `${FLUX_DIR}/linear-config.json`;
+
+  beforeEach(async () => {
+    // Clean up any previous test directory
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true });
+    }
+
+    // Create test directory structure
+    mkdirSync(FLUX_DIR, { recursive: true });
+
+    // Set project root to test directory
+    process.env.FLUX_PROJECT_ROOT = TEST_DIR;
+
+    // Clear the config cache
+    const { config } = await import("../../config.js");
+    config.clearCache();
+  });
+
+  afterEach(async () => {
+    // Restore original env
+    if (originalEnv !== undefined) {
+      process.env.FLUX_PROJECT_ROOT = originalEnv;
+    } else {
+      delete process.env.FLUX_PROJECT_ROOT;
+    }
+
+    // Clear the config cache
+    const { config } = await import("../../config.js");
+    config.clearCache();
+
+    // Clean up test directory
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true });
+    }
+  });
+
+  describe("linearConfigExists", () => {
+    test("returns true when config file exists", async () => {
+      writeFileSync(
+        CONFIG_PATH,
+        JSON.stringify({
+          apiKey: "lin_api_test",
+          teamId: "TEAM-123",
+          projectId: "proj_123",
+        }),
+      );
+
+      const { linearConfigExists } = await import("../linear/config.js");
+      expect(linearConfigExists()).toBe(true);
+    });
+
+    test("returns false when config file does not exist", async () => {
+      const { linearConfigExists } = await import("../linear/config.js");
+      expect(linearConfigExists()).toBe(false);
+    });
+  });
+
+  describe("validateLinearConfig", () => {
+    test("validates valid config with all fields", async () => {
+      const validConfig = {
+        apiKey: "lin_api_test123",
+        teamId: "TEAM-123",
+        projectId: "proj_abc123",
+        defaultLabels: {
+          prd: "prd",
+          epic: "epic",
+          task: "task",
+        },
+      };
+
+      const { validateLinearConfig } = await import("../linear/config.js");
+      const result = validateLinearConfig(validConfig);
+
+      expect(result.apiKey).toBe("lin_api_test123");
+      expect(result.teamId).toBe("TEAM-123");
+      expect(result.projectId).toBe("proj_abc123");
+      expect(result.defaultLabels.prd).toBe("prd");
+      expect(result.defaultLabels.epic).toBe("epic");
+      expect(result.defaultLabels.task).toBe("task");
+    });
+
+    test("validates valid config with optional defaultLabels omitted", async () => {
+      const validConfig = {
+        apiKey: "lin_api_test123",
+        teamId: "TEAM-123",
+        projectId: "proj_abc123",
+      };
+
+      const { validateLinearConfig } = await import("../linear/config.js");
+      const result = validateLinearConfig(validConfig);
+
+      expect(result.apiKey).toBe("lin_api_test123");
+      expect(result.teamId).toBe("TEAM-123");
+      expect(result.projectId).toBe("proj_abc123");
+      expect(result.defaultLabels.prd).toBe("prd");
+      expect(result.defaultLabels.epic).toBe("epic");
+      expect(result.defaultLabels.task).toBe("task");
+    });
+
+    test("throws error when apiKey is missing", async () => {
+      const invalidConfig = {
+        teamId: "TEAM-123",
+        projectId: "proj_abc123",
+      };
+
+      const { validateLinearConfig } = await import("../linear/config.js");
+
+      expect(() => validateLinearConfig(invalidConfig)).toThrow(
+        "Invalid Linear config: apiKey is required",
+      );
+    });
+
+    test("throws error when teamId is missing", async () => {
+      const invalidConfig = {
+        apiKey: "lin_api_test123",
+        projectId: "proj_abc123",
+      };
+
+      const { validateLinearConfig } = await import("../linear/config.js");
+
+      expect(() => validateLinearConfig(invalidConfig)).toThrow(
+        "Invalid Linear config: teamId is required",
+      );
+    });
+
+    test("throws error when projectId is missing", async () => {
+      const invalidConfig = {
+        apiKey: "lin_api_test123",
+        teamId: "TEAM-123",
+      };
+
+      const { validateLinearConfig } = await import("../linear/config.js");
+
+      expect(() => validateLinearConfig(invalidConfig)).toThrow(
+        "Invalid Linear config: projectId is required",
+      );
+    });
+
+    test("throws error when config is not an object", async () => {
+      const { validateLinearConfig } = await import("../linear/config.js");
+
+      expect(() => validateLinearConfig(null)).toThrow(
+        "Invalid Linear config: must be an object",
+      );
+      expect(() => validateLinearConfig("string")).toThrow(
+        "Invalid Linear config: must be an object",
+      );
+      expect(() => validateLinearConfig(123)).toThrow(
+        "Invalid Linear config: must be an object",
+      );
+    });
+
+    test("throws error when apiKey is not a string", async () => {
+      const invalidConfig = {
+        apiKey: 123,
+        teamId: "TEAM-123",
+        projectId: "proj_abc123",
+      };
+
+      const { validateLinearConfig } = await import("../linear/config.js");
+
+      expect(() => validateLinearConfig(invalidConfig)).toThrow(
+        "Invalid Linear config: apiKey must be a string",
+      );
+    });
+
+    test("throws error when teamId is not a string", async () => {
+      const invalidConfig = {
+        apiKey: "lin_api_test",
+        teamId: 123,
+        projectId: "proj_abc123",
+      };
+
+      const { validateLinearConfig } = await import("../linear/config.js");
+
+      expect(() => validateLinearConfig(invalidConfig)).toThrow(
+        "Invalid Linear config: teamId must be a string",
+      );
+    });
+
+    test("throws error when projectId is not a string", async () => {
+      const invalidConfig = {
+        apiKey: "lin_api_test",
+        teamId: "TEAM-123",
+        projectId: 123,
+      };
+
+      const { validateLinearConfig } = await import("../linear/config.js");
+
+      expect(() => validateLinearConfig(invalidConfig)).toThrow(
+        "Invalid Linear config: projectId must be a string",
+      );
+    });
+
+    test("uses default labels when defaultLabels is partially provided", async () => {
+      const configWithPartialLabels = {
+        apiKey: "lin_api_test",
+        teamId: "TEAM-123",
+        projectId: "proj_abc123",
+        defaultLabels: {
+          epic: "custom-epic",
+        },
+      };
+
+      const { validateLinearConfig } = await import("../linear/config.js");
+      const result = validateLinearConfig(configWithPartialLabels);
+
+      expect(result.defaultLabels.prd).toBe("prd");
+      expect(result.defaultLabels.epic).toBe("custom-epic");
+      expect(result.defaultLabels.task).toBe("task");
+    });
+
+    test("allows custom prd label", async () => {
+      const configWithCustomPrdLabel = {
+        apiKey: "lin_api_test",
+        teamId: "TEAM-123",
+        projectId: "proj_abc123",
+        defaultLabels: {
+          prd: "custom-prd",
+        },
+      };
+
+      const { validateLinearConfig } = await import("../linear/config.js");
+      const result = validateLinearConfig(configWithCustomPrdLabel);
+
+      expect(result.defaultLabels.prd).toBe("custom-prd");
+      expect(result.defaultLabels.epic).toBe("epic");
+      expect(result.defaultLabels.task).toBe("task");
+    });
+  });
+
+  describe("loadLinearConfig", () => {
+    test("loads valid config from file", async () => {
+      writeFileSync(
+        CONFIG_PATH,
+        JSON.stringify({
+          apiKey: "lin_api_test123",
+          teamId: "TEAM-123",
+          projectId: "proj_abc123",
+          defaultLabels: {
+            prd: "prd",
+            epic: "epic",
+            task: "task",
+          },
+        }),
+      );
+
+      const { loadLinearConfig } = await import("../linear/config.js");
+      const config = loadLinearConfig();
+
+      expect(config.apiKey).toBe("lin_api_test123");
+      expect(config.teamId).toBe("TEAM-123");
+      expect(config.projectId).toBe("proj_abc123");
+      expect(config.defaultLabels.prd).toBe("prd");
+      expect(config.defaultLabels.epic).toBe("epic");
+      expect(config.defaultLabels.task).toBe("task");
+    });
+
+    test("loads config with default labels when not provided", async () => {
+      writeFileSync(
+        CONFIG_PATH,
+        JSON.stringify({
+          apiKey: "lin_api_test123",
+          teamId: "TEAM-123",
+          projectId: "proj_abc123",
+        }),
+      );
+
+      const { loadLinearConfig } = await import("../linear/config.js");
+      const config = loadLinearConfig();
+
+      expect(config.apiKey).toBe("lin_api_test123");
+      expect(config.teamId).toBe("TEAM-123");
+      expect(config.projectId).toBe("proj_abc123");
+      expect(config.defaultLabels.prd).toBe("prd");
+      expect(config.defaultLabels.epic).toBe("epic");
+      expect(config.defaultLabels.task).toBe("task");
+    });
+
+    test("throws error when config file does not exist", async () => {
+      const { loadLinearConfig } = await import("../linear/config.js");
+
+      expect(() => loadLinearConfig()).toThrow(
+        "Linear config not found. Run configure_linear first.",
+      );
+    });
+
+    test("throws error when config file contains invalid JSON", async () => {
+      writeFileSync(CONFIG_PATH, "invalid json {");
+
+      const { loadLinearConfig } = await import("../linear/config.js");
+
+      expect(() => loadLinearConfig()).toThrow();
+    });
+
+    test("throws error when config is missing required fields", async () => {
+      writeFileSync(
+        CONFIG_PATH,
+        JSON.stringify({
+          apiKey: "lin_api_test123",
+          // missing teamId and projectId
+        }),
+      );
+
+      const { loadLinearConfig } = await import("../linear/config.js");
+
+      expect(() => loadLinearConfig()).toThrow(
+        "Invalid Linear config: teamId is required",
+      );
+    });
+  });
+
+  describe("saveLinearConfig", () => {
+    test("saves valid config to file", async () => {
+      const config = {
+        apiKey: "lin_api_test123",
+        teamId: "TEAM-123",
+        projectId: "proj_abc123",
+        defaultLabels: {
+          prd: "prd",
+          epic: "epic",
+          task: "task",
+        },
+      };
+
+      const { saveLinearConfig } = await import("../linear/config.js");
+      saveLinearConfig(config);
+
+      expect(existsSync(CONFIG_PATH)).toBe(true);
+
+      const saved = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+      expect(saved.apiKey).toBe("lin_api_test123");
+      expect(saved.teamId).toBe("TEAM-123");
+      expect(saved.projectId).toBe("proj_abc123");
+      expect(saved.defaultLabels.prd).toBe("prd");
+      expect(saved.defaultLabels.epic).toBe("epic");
+    });
+
+    test("creates .flux directory if it does not exist", async () => {
+      // Remove .flux directory
+      rmSync(FLUX_DIR, { recursive: true });
+
+      const config = {
+        apiKey: "lin_api_test123",
+        teamId: "TEAM-123",
+        projectId: "proj_abc123",
+        defaultLabels: {
+          prd: "prd",
+          epic: "epic",
+          task: "task",
+        },
+      };
+
+      const { saveLinearConfig } = await import("../linear/config.js");
+      saveLinearConfig(config);
+
+      expect(existsSync(FLUX_DIR)).toBe(true);
+      expect(existsSync(CONFIG_PATH)).toBe(true);
+    });
+
+    test("overwrites existing config file", async () => {
+      writeFileSync(
+        CONFIG_PATH,
+        JSON.stringify({
+          apiKey: "old_api_key",
+          teamId: "OLD-TEAM",
+          projectId: "old_proj",
+        }),
+      );
+
+      const newConfig = {
+        apiKey: "new_api_key",
+        teamId: "NEW-TEAM",
+        projectId: "new_proj",
+        defaultLabels: {
+          prd: "custom-prd",
+          epic: "custom-epic",
+          task: "custom-task",
+        },
+      };
+
+      const { saveLinearConfig } = await import("../linear/config.js");
+      saveLinearConfig(newConfig);
+
+      const saved = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+      expect(saved.apiKey).toBe("new_api_key");
+      expect(saved.teamId).toBe("NEW-TEAM");
+      expect(saved.projectId).toBe("new_proj");
+      expect(saved.defaultLabels.prd).toBe("custom-prd");
+      expect(saved.defaultLabels.epic).toBe("custom-epic");
+    });
+
+    test("validates config before saving", async () => {
+      const invalidConfig = {
+        apiKey: "lin_api_test",
+        // missing teamId and projectId
+      } as any;
+
+      const { saveLinearConfig } = await import("../linear/config.js");
+
+      expect(() => saveLinearConfig(invalidConfig)).toThrow(
+        "Invalid Linear config: teamId is required",
+      );
+
+      // Ensure file was not created
+      expect(existsSync(CONFIG_PATH)).toBe(false);
+    });
+  });
+});