@stackmemoryai/stackmemory 0.3.1 → 0.3.3

package/dist/integrations/linear/__tests__/sync-service.test.js

@@ -1,760 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { LinearSyncService } from "../sync-service.js";
-const mockLinearClientInstance = {
-  getIssues: vi.fn(),
-  updateIssue: vi.fn(),
-  createIssue: vi.fn()
-};
-const mockContextServiceInstance = {
-  getTaskByExternalId: vi.fn(),
-  updateTask: vi.fn(),
-  createTask: vi.fn(),
-  getTask: vi.fn(),
-  deleteTask: vi.fn(),
-  getAllTasks: vi.fn()
-};
-const mockConfigServiceInstance = {
-  getConfig: vi.fn()
-};
-vi.mock("../client.js", () => ({
-  LinearClient: class {
-    getIssues = mockLinearClientInstance.getIssues;
-    updateIssue = mockLinearClientInstance.updateIssue;
-    createIssue = mockLinearClientInstance.createIssue;
-  }
-}));
-vi.mock("../../../services/context-service.js", () => ({
-  ContextService: class {
-    getTaskByExternalId = mockContextServiceInstance.getTaskByExternalId;
-    updateTask = mockContextServiceInstance.updateTask;
-    createTask = mockContextServiceInstance.createTask;
-    getTask = mockContextServiceInstance.getTask;
-    deleteTask = mockContextServiceInstance.deleteTask;
-    getAllTasks = mockContextServiceInstance.getAllTasks;
-  }
-}));
-vi.mock("../../../services/config-service.js", () => ({
-  ConfigService: class {
-    getConfig = mockConfigServiceInstance.getConfig;
-  }
-}));
-vi.mock("../../../utils/logger.js", () => ({
-  Logger: class {
-    info = vi.fn();
-    error = vi.fn();
-    debug = vi.fn();
-    warn = vi.fn();
-  }
-}));
-describe("LinearSyncService", () => {
-  let syncService;
-  let originalEnv;
-  beforeEach(() => {
-    originalEnv = process.env;
-    process.env.LINEAR_API_KEY = "test-api-key";
-    mockLinearClientInstance.getIssues.mockReset();
-    mockLinearClientInstance.updateIssue.mockReset();
-    mockLinearClientInstance.createIssue.mockReset();
-    mockContextServiceInstance.getTaskByExternalId.mockReset();
-    mockContextServiceInstance.updateTask.mockReset();
-    mockContextServiceInstance.createTask.mockReset();
-    mockContextServiceInstance.getTask.mockReset();
-    mockContextServiceInstance.deleteTask.mockReset();
-    mockContextServiceInstance.getAllTasks.mockReset();
-    mockConfigServiceInstance.getConfig.mockReset();
-    syncService = new LinearSyncService();
-  });
-  afterEach(() => {
-    process.env = originalEnv;
-  });
-  const mockLinearClient = mockLinearClientInstance;
-  const mockContextService = mockContextServiceInstance;
-  const mockConfigService = mockConfigServiceInstance;
-  describe("Initialization", () => {
-    it("should initialize with Linear API key from environment", () => {
-      expect(syncService).toBeDefined();
-    });
-    it("should throw error when LINEAR_API_KEY is not set", () => {
-      delete process.env.LINEAR_API_KEY;
-      expect(() => {
-        new LinearSyncService();
-      }).toThrow("LINEAR_API_KEY environment variable not set");
-    });
-    it("should initialize services correctly", () => {
-      expect(syncService).toBeDefined();
-    });
-  });
-  describe("syncAllIssues", () => {
-    beforeEach(() => {
-      mockConfigService.getConfig.mockResolvedValue({
-        integrations: {
-          linear: {
-            teamId: "test-team-id"
-          }
-        }
-      });
-    });
-    it("should sync all issues from Linear successfully", async () => {
-      const mockIssues = [
-        {
-          id: "issue-1",
-          identifier: "STA-1",
-          title: "Test Issue 1",
-          description: "Description 1",
-          state: { type: "unstarted" },
-          priority: 2,
-          url: "https://linear.app/issue-1",
-          team: { id: "team-1", key: "STA" },
-          labels: [{ name: "bug" }],
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        },
-        {
-          id: "issue-2",
-          identifier: "STA-2",
-          title: "Test Issue 2",
-          description: "Description 2",
-          state: { type: "completed" },
-          priority: 3,
-          url: "https://linear.app/issue-2",
-          team: { id: "team-1", key: "STA" },
-          labels: [],
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        }
-      ];
-      mockLinearClient.getIssues.mockResolvedValue(mockIssues);
-      mockContextService.getTaskByExternalId.mockResolvedValue(null);
-      const result = await syncService.syncAllIssues();
-      expect(result.created).toBe(2);
-      expect(result.updated).toBe(0);
-      expect(result.errors).toHaveLength(0);
-      expect(mockContextService.createTask).toHaveBeenCalledTimes(2);
-    });
-    it("should update existing tasks when they have changes", async () => {
-      const mockIssue = {
-        id: "issue-1",
-        identifier: "STA-1",
-        title: "Updated Title",
-        description: "Updated Description",
-        state: { type: "completed" },
-        priority: 3,
-        url: "https://linear.app/issue-1",
-        team: { id: "team-1", key: "STA" },
-        labels: [{ name: "feature" }],
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      const existingTask = {
-        id: "local-task-1",
-        title: "Old Title",
-        description: "Old Description",
-        status: "todo",
-        priority: "high",
-        externalId: "issue-1"
-      };
-      mockLinearClient.getIssues.mockResolvedValue([mockIssue]);
-      mockContextService.getTaskByExternalId.mockResolvedValue(existingTask);
-      const result = await syncService.syncAllIssues();
-      expect(result.created).toBe(0);
-      expect(result.updated).toBe(1);
-      expect(mockContextService.updateTask).toHaveBeenCalledWith(
-        "local-task-1",
-        expect.objectContaining({
-          title: "Updated Title",
-          description: "Updated Description",
-          status: "done",
-          priority: "medium"
-        })
-      );
-    });
-    it("should skip tasks without changes", async () => {
-      const mockIssue = {
-        id: "issue-1",
-        identifier: "STA-1",
-        title: "Same Title",
-        description: "Same Description",
-        state: { type: "unstarted" },
-        priority: 2,
-        url: "https://linear.app/issue-1",
-        team: { id: "team-1", key: "STA" },
-        labels: [{ name: "bug" }],
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      const existingTask = {
-        id: "local-task-1",
-        title: "Same Title",
-        description: "Same Description",
-        status: "todo",
-        priority: "high",
-        tags: ["bug"],
-        externalId: "issue-1"
-      };
-      mockLinearClient.getIssues.mockResolvedValue([mockIssue]);
-      mockContextService.getTaskByExternalId.mockResolvedValue(existingTask);
-      const result = await syncService.syncAllIssues();
-      expect(result.created).toBe(0);
-      expect(result.updated).toBe(0);
-      expect(mockContextService.updateTask).not.toHaveBeenCalled();
-    });
-    it("should handle sync errors gracefully", async () => {
-      const mockIssues = [
-        {
-          id: "issue-1",
-          identifier: "STA-1",
-          title: "Test Issue",
-          state: { type: "unstarted" },
-          team: { id: "team-1", key: "STA" },
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        }
-      ];
-      mockLinearClient.getIssues.mockResolvedValue(mockIssues);
-      mockContextService.getTaskByExternalId.mockRejectedValue(
-        new Error("Database error")
-      );
-      const result = await syncService.syncAllIssues();
-      expect(result.errors).toHaveLength(1);
-      expect(result.errors[0]).toContain("Failed to sync STA-1");
-    });
-    it("should throw error when Linear team ID is not configured", async () => {
-      mockConfigService.getConfig.mockResolvedValue({
-        integrations: {}
-      });
-      const result = await syncService.syncAllIssues();
-      expect(result.errors).toContain("Linear team ID not configured");
-    });
-    it("should handle Linear API errors", async () => {
-      mockConfigService.getConfig.mockResolvedValue({
-        integrations: {
-          linear: { teamId: "test-team-id" }
-        }
-      });
-      mockLinearClient.getIssues.mockRejectedValue(
-        new Error("Linear API error")
-      );
-      const result = await syncService.syncAllIssues();
-      expect(result.errors).toContain("Linear API error");
-    });
-  });
-  describe("syncIssueToLocal", () => {
-    it("should create new local task from Linear issue", async () => {
-      const mockIssue = {
-        id: "issue-1",
-        identifier: "STA-1",
-        title: "New Issue",
-        description: "Issue description",
-        state: { type: "unstarted", id: "state-1", name: "Todo" },
-        priority: 1,
-        url: "https://linear.app/issue-1",
-        team: { id: "team-1", key: "STA" },
-        labels: [{ name: "bug" }, { name: "urgent" }],
-        project: { id: "proj-1", name: "Main Project" },
-        assignee: { id: "user-1", name: "John Doe" },
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      mockContextService.getTaskByExternalId.mockResolvedValue(null);
-      const result = await syncService.syncIssueToLocal(mockIssue);
-      expect(result).toBe("created");
-      expect(mockContextService.createTask).toHaveBeenCalledWith(
-        expect.objectContaining({
-          title: "New Issue",
-          description: "Issue description",
-          status: "todo",
-          priority: "urgent",
-          externalId: "issue-1",
-          externalIdentifier: "STA-1",
-          externalUrl: "https://linear.app/issue-1",
-          tags: ["bug", "urgent"],
-          metadata: {
-            linear: {
-              stateId: "state-1",
-              stateName: "Todo",
-              assigneeId: "user-1",
-              assigneeName: "John Doe"
-            }
-          }
-        })
-      );
-    });
-    it("should update existing local task", async () => {
-      const mockIssue = {
-        id: "issue-1",
-        identifier: "STA-1",
-        title: "Updated Issue",
-        description: "Updated description",
-        state: { type: "started", id: "state-2", name: "In Progress" },
-        priority: 2,
-        url: "https://linear.app/issue-1",
-        team: { id: "team-1", key: "STA" },
-        labels: [{ name: "feature" }],
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      const existingTask = {
-        id: "local-1",
-        title: "Old Title",
-        description: "Old description",
-        status: "todo",
-        priority: "low",
-        tags: ["old-tag"],
-        externalId: "issue-1",
-        createdAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date()
-      };
-      mockContextService.getTaskByExternalId.mockResolvedValue(existingTask);
-      const result = await syncService.syncIssueToLocal(mockIssue);
-      expect(result).toBe("updated");
-      expect(mockContextService.updateTask).toHaveBeenCalledWith(
-        "local-1",
-        expect.objectContaining({
-          title: "Updated Issue",
-          description: "Updated description",
-          status: "in_progress",
-          priority: "high",
-          externalId: "issue-1",
-          externalIdentifier: "STA-1",
-          externalUrl: "https://linear.app/issue-1",
-          tags: ["feature"],
-          metadata: {
-            linear: {
-              stateId: "state-2",
-              stateName: "In Progress",
-              assigneeId: void 0,
-              assigneeName: void 0
-            }
-          }
-        })
-      );
-    });
-    it("should handle sync errors and rethrow", async () => {
-      const mockIssue = {
-        id: "issue-1",
-        identifier: "STA-1",
-        title: "Error Issue",
-        state: { type: "unstarted" },
-        team: { id: "team-1", key: "STA" },
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      mockContextService.getTaskByExternalId.mockRejectedValue(
-        new Error("Database error")
-      );
-      await expect(syncService.syncIssueToLocal(mockIssue)).rejects.toThrow(
-        "Database error"
-      );
-    });
-  });
-  describe("syncLocalToLinear", () => {
-    beforeEach(() => {
-      mockConfigService.getConfig.mockResolvedValue({
-        integrations: {
-          linear: {
-            teamId: "test-team-id"
-          }
-        }
-      });
-    });
-    it("should create new Linear issue from local task", async () => {
-      const mockTask = {
-        id: "local-1",
-        title: "Local Task",
-        description: "Local description",
-        status: "todo",
-        priority: "high",
-        tags: [],
-        createdAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date()
-      };
-      const mockCreatedIssue = {
-        id: "issue-1",
-        identifier: "STA-1",
-        title: "Local Task",
-        url: "https://linear.app/issue-1"
-      };
-      mockContextService.getTask.mockResolvedValue(mockTask);
-      mockLinearClient.createIssue.mockResolvedValue(mockCreatedIssue);
-      const result = await syncService.syncLocalToLinear("local-1");
-      expect(result).toEqual(mockCreatedIssue);
-      expect(mockLinearClient.createIssue).toHaveBeenCalledWith({
-        title: "Local Task",
-        description: "Local description",
-        teamId: "test-team-id",
-        priority: 2
-        // high -> 2
-      });
-      expect(mockContextService.updateTask).toHaveBeenCalledWith("local-1", {
-        externalId: "issue-1"
-      });
-    });
-    it("should update existing Linear issue", async () => {
-      const mockTask = {
-        id: "local-1",
-        title: "Updated Local Task",
-        description: "Updated description",
-        status: "in_progress",
-        priority: "medium",
-        tags: [],
-        externalId: "issue-1",
-        metadata: {
-          linear: {
-            stateId: "state-1",
-            projectId: "proj-1",
-            assigneeId: "user-1"
-          }
-        },
-        createdAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date()
-      };
-      const mockUpdatedIssue = {
-        id: "issue-1",
-        identifier: "STA-1",
-        title: "Updated Local Task"
-      };
-      mockContextService.getTask.mockResolvedValue(mockTask);
-      mockLinearClient.updateIssue.mockResolvedValue(mockUpdatedIssue);
-      const result = await syncService.syncLocalToLinear("local-1");
-      expect(result).toEqual(mockUpdatedIssue);
-      expect(mockLinearClient.updateIssue).toHaveBeenCalledWith("issue-1", {
-        title: "Updated Local Task",
-        description: "Updated description",
-        priority: 3,
-        // medium -> 3
-        stateId: "state-1"
-      });
-    });
-    it("should throw error for non-existent task", async () => {
-      mockContextService.getTask.mockResolvedValue(null);
-      await expect(
-        syncService.syncLocalToLinear("non-existent")
-      ).rejects.toThrow("Task non-existent not found");
-    });
-    it("should handle Linear API errors", async () => {
-      const mockTask = {
-        id: "local-1",
-        title: "Task",
-        description: "Test task description",
-        status: "todo",
-        priority: "medium",
-        tags: [],
-        createdAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date()
-      };
-      mockContextService.getTask.mockResolvedValue(mockTask);
-      mockLinearClient.createIssue.mockRejectedValue(
-        new Error("Linear API error")
-      );
-      await expect(syncService.syncLocalToLinear("local-1")).rejects.toThrow(
-        "Linear API error"
-      );
-    });
-  });
-  describe("removeLocalIssue", () => {
-    it("should remove local task by Linear identifier", async () => {
-      const mockTasks = [
-        {
-          id: "local-1",
-          title: "Task 1",
-          description: "Task 1 description",
-          status: "todo",
-          priority: "medium",
-          tags: [],
-          externalIdentifier: "STA-1",
-          createdAt: /* @__PURE__ */ new Date(),
-          updatedAt: /* @__PURE__ */ new Date()
-        },
-        {
-          id: "local-2",
-          title: "Task 2",
-          description: "Task 2 description",
-          status: "todo",
-          priority: "medium",
-          tags: [],
-          externalIdentifier: "STA-2",
-          createdAt: /* @__PURE__ */ new Date(),
-          updatedAt: /* @__PURE__ */ new Date()
-        }
-      ];
-      mockContextService.getAllTasks.mockResolvedValue(mockTasks);
-      await syncService.removeLocalIssue("STA-1");
-      expect(mockContextService.deleteTask).toHaveBeenCalledWith("local-1");
-    });
-    it("should handle non-existent identifier gracefully", async () => {
-      mockContextService.getAllTasks.mockResolvedValue([]);
-      await expect(
-        syncService.removeLocalIssue("NON-EXISTENT")
-      ).resolves.not.toThrow();
-      expect(mockContextService.deleteTask).not.toHaveBeenCalled();
-    });
-    it("should handle deletion errors", async () => {
-      const mockTasks = [
-        {
-          id: "local-1",
-          title: "Task",
-          description: "Task description",
-          status: "todo",
-          priority: "medium",
-          tags: [],
-          externalIdentifier: "STA-1",
-          createdAt: /* @__PURE__ */ new Date(),
-          updatedAt: /* @__PURE__ */ new Date()
-        }
-      ];
-      mockContextService.getAllTasks.mockResolvedValue(mockTasks);
-      mockContextService.deleteTask.mockRejectedValue(
-        new Error("Delete error")
-      );
-      await expect(syncService.removeLocalIssue("STA-1")).rejects.toThrow(
-        "Delete error"
-      );
-    });
-  });
-  describe("Status and Priority Mapping", () => {
-    beforeEach(() => {
-      mockConfigService.getConfig.mockResolvedValue({
-        integrations: {
-          linear: {
-            teamId: "test-team-id"
-          }
-        }
-      });
-    });
-    it("should map Linear states to task statuses correctly", async () => {
-      const testCases = [
-        { linearState: "backlog", expectedStatus: "todo" },
-        { linearState: "triage", expectedStatus: "todo" },
-        { linearState: "unstarted", expectedStatus: "todo" },
-        { linearState: "todo", expectedStatus: "todo" },
-        { linearState: "started", expectedStatus: "in_progress" },
-        { linearState: "in_progress", expectedStatus: "in_progress" },
-        { linearState: "completed", expectedStatus: "done" },
-        { linearState: "done", expectedStatus: "done" },
-        { linearState: "canceled", expectedStatus: "cancelled" },
-        { linearState: "cancelled", expectedStatus: "cancelled" },
-        { linearState: "unknown", expectedStatus: "todo" }
-      ];
-      for (const { linearState, expectedStatus } of testCases) {
-        const mockIssue = {
-          id: "test-issue",
-          identifier: "TEST-1",
-          title: "Test",
-          state: { type: linearState },
-          team: { id: "team-1", key: "TEST" },
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        mockContextService.getTaskByExternalId.mockResolvedValue(null);
-        await syncService.syncIssueToLocal(mockIssue);
-        expect(mockContextService.createTask).toHaveBeenCalledWith(
-          expect.objectContaining({ status: expectedStatus })
-        );
-        mockContextService.createTask.mockClear();
-        mockContextService.getTaskByExternalId.mockClear();
-      }
-    });
-    it("should map Linear priorities to task priorities correctly", async () => {
-      const testCases = [
-        { linearPriority: 1, expectedPriority: "urgent" },
-        { linearPriority: 2, expectedPriority: "high" },
-        { linearPriority: 3, expectedPriority: "medium" },
-        { linearPriority: 4, expectedPriority: "low" },
-        { linearPriority: void 0, expectedPriority: void 0 }
-      ];
-      for (const { linearPriority, expectedPriority } of testCases) {
-        const mockIssue = {
-          id: "test-issue",
-          identifier: "TEST-1",
-          title: "Test",
-          state: { type: "unstarted" },
-          priority: linearPriority,
-          team: { id: "team-1", key: "TEST" },
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        mockContextService.getTaskByExternalId.mockResolvedValue(null);
-        await syncService.syncIssueToLocal(mockIssue);
-        expect(mockContextService.createTask).toHaveBeenCalledWith(
-          expect.objectContaining({ priority: expectedPriority })
-        );
-        mockContextService.createTask.mockClear();
-        mockContextService.getTaskByExternalId.mockClear();
-      }
-    });
-    it("should map task priorities to Linear priorities correctly", async () => {
-      const testCases = [
-        { taskPriority: "urgent", expectedLinearPriority: 1 },
-        { taskPriority: "high", expectedLinearPriority: 2 },
-        { taskPriority: "medium", expectedLinearPriority: 3 },
-        { taskPriority: "low", expectedLinearPriority: 4 },
-        { taskPriority: void 0, expectedLinearPriority: 0 }
-      ];
-      for (const { taskPriority, expectedLinearPriority } of testCases) {
-        const mockTask = {
-          id: "local-1",
-          title: "Test Task",
-          description: "Test description",
-          status: "todo",
-          priority: taskPriority,
-          tags: [],
-          createdAt: /* @__PURE__ */ new Date(),
-          updatedAt: /* @__PURE__ */ new Date()
-        };
-        mockContextService.getTask.mockResolvedValue(mockTask);
-        mockLinearClient.createIssue.mockResolvedValue({
-          id: "created",
-          identifier: "TEST-1"
-        });
-        await syncService.syncLocalToLinear("local-1");
-        expect(mockLinearClient.createIssue).toHaveBeenCalledWith(
-          expect.objectContaining({ priority: expectedLinearPriority })
-        );
-        mockLinearClient.createIssue.mockClear();
-        mockContextService.getTask.mockClear();
-        mockContextService.updateTask.mockClear();
-      }
-    });
-  });
-  describe("Change Detection", () => {
-    it("should detect changes in title", async () => {
-      const existing = {
-        id: "1",
-        title: "Old Title",
-        description: "Same",
-        status: "todo",
-        priority: "medium",
-        tags: [],
-        createdAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date()
-      };
-      mockContextService.getTaskByExternalId.mockResolvedValue(existing);
-      const mockIssue = {
-        id: "issue-1",
-        identifier: "STA-1",
-        title: "New Title",
-        description: "Same",
-        state: { type: "unstarted" },
-        priority: 2,
-        team: { id: "team-1", key: "STA" },
-        labels: [],
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      await syncService.syncIssueToLocal(mockIssue);
-      expect(mockContextService.updateTask).toHaveBeenCalled();
-    });
-    it("should detect changes in tags", async () => {
-      const existing = {
-        id: "1",
-        title: "Same",
-        description: "Same",
-        status: "todo",
-        priority: "medium",
-        tags: ["old-tag"],
-        createdAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date()
-      };
-      mockContextService.getTaskByExternalId.mockResolvedValue(existing);
-      const mockIssue = {
-        id: "issue-1",
-        identifier: "STA-1",
-        title: "Same",
-        description: "Same",
-        state: { type: "unstarted" },
-        priority: 2,
-        team: { id: "team-1", key: "STA" },
-        labels: [{ name: "new-tag" }],
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      await syncService.syncIssueToLocal(mockIssue);
-      expect(mockContextService.updateTask).toHaveBeenCalled();
-    });
-    it("should not update when no changes detected", async () => {
-      const existing = {
-        id: "1",
-        title: "Same Title",
-        description: "Same Description",
-        status: "todo",
-        priority: "high",
-        // Linear priority 2 maps to 'high'
-        tags: ["tag1"],
-        createdAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date()
-      };
-      mockContextService.getTaskByExternalId.mockResolvedValue(existing);
-      const mockIssue = {
-        id: "issue-1",
-        identifier: "STA-1",
-        title: "Same Title",
-        description: "Same Description",
-        state: { type: "unstarted" },
-        priority: 2,
-        // Maps to 'high'
-        team: { id: "team-1", key: "STA" },
-        labels: [{ name: "tag1" }],
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      await syncService.syncIssueToLocal(mockIssue);
-      expect(mockContextService.updateTask).not.toHaveBeenCalled();
-    });
-  });
-  describe("Error Recovery and Edge Cases", () => {
-    it("should handle partial sync failures gracefully", async () => {
-      const mockIssues = [
-        {
-          id: "issue-1",
-          identifier: "STA-1",
-          title: "Good Issue",
-          state: { type: "unstarted" },
-          team: { id: "team-1", key: "STA" },
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        },
-        {
-          id: "issue-2",
-          identifier: "STA-2",
-          title: "Bad Issue",
-          state: { type: "unstarted" },
-          team: { id: "team-1", key: "STA" },
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        }
-      ];
-      mockConfigService.getConfig.mockResolvedValue({
-        integrations: { linear: { teamId: "test-team-id" } }
-      });
-      mockLinearClient.getIssues.mockResolvedValue(mockIssues);
-      mockContextService.getTaskByExternalId.mockResolvedValue(null);
-      mockContextService.createTask.mockResolvedValueOnce("success").mockRejectedValueOnce(new Error("Creation failed"));
-      const result = await syncService.syncAllIssues();
-      expect(result.created).toBe(1);
-      expect(result.errors).toHaveLength(1);
-      expect(result.errors[0]).toContain("Failed to sync STA-2");
-    });
-    it("should handle empty issues list", async () => {
-      mockConfigService.getConfig.mockResolvedValue({
-        integrations: { linear: { teamId: "test-team-id" } }
-      });
-      mockLinearClient.getIssues.mockResolvedValue([]);
-      const result = await syncService.syncAllIssues();
-      expect(result.created).toBe(0);
-      expect(result.updated).toBe(0);
-      expect(result.errors).toHaveLength(0);
-    });
-    it("should handle malformed Linear issues", async () => {
-      const malformedIssue = {
-        // Missing required fields
-        id: "issue-1",
-        title: null,
-        state: null,
-        team: null
-      };
-      mockConfigService.getConfig.mockResolvedValue({
-        integrations: { linear: { teamId: "test-team-id" } }
-      });
-      mockLinearClient.getIssues.mockResolvedValue([malformedIssue]);
-      const result = await syncService.syncAllIssues();
-      expect(result.errors).toHaveLength(1);
-    });
-    it("should handle network timeouts gracefully", async () => {
-      mockConfigService.getConfig.mockResolvedValue({
-        integrations: { linear: { teamId: "test-team-id" } }
-      });
-      const timeoutError = new Error("Request timeout");
-      timeoutError.name = "TimeoutError";
-      mockLinearClient.getIssues.mockRejectedValue(timeoutError);
-      const result = await syncService.syncAllIssues();
-      expect(result.errors).toHaveLength(1);
-      expect(result.errors[0]).toContain("Request timeout");
-    });
-  });
-});
-//# sourceMappingURL=sync-service.test.js.map