@stackmemoryai/stackmemory 0.2.4 → 0.2.7

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

@@ -0,0 +1,700 @@
+/**
+ * Tests for LinearSyncService - Bidirectional sync with Linear
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { LinearSyncService } from '../sync-service.js';
+import { LinearClient } from '../client.js';
+import { ContextService } from '../../../services/context-service.js';
+import { ConfigService } from '../../../services/config-service.js';
+// Mock dependencies
+vi.mock('../client.js', () => ({
+    LinearClient: vi.fn()
+}));
+vi.mock('../../../services/context-service.js', () => ({
+    ContextService: vi.fn()
+}));
+vi.mock('../../../services/config-service.js', () => ({
+    ConfigService: vi.fn()
+}));
+vi.mock('../../../utils/logger.js', () => ({
+    Logger: vi.fn().mockImplementation(() => ({
+        info: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+        warn: vi.fn()
+    }))
+}));
+describe('LinearSyncService', () => {
+    let syncService;
+    let mockLinearClient;
+    let mockContextService;
+    let mockConfigService;
+    let originalEnv;
+    beforeEach(() => {
+        // Store original environment
+        originalEnv = process.env;
+        // Set required environment variable
+        process.env.LINEAR_API_KEY = 'test-api-key';
+        // Setup mocks
+        mockLinearClient = {
+            getIssues: vi.fn(),
+            updateIssue: vi.fn(),
+            createIssue: vi.fn()
+        };
+        mockContextService = {
+            getTaskByExternalId: vi.fn(),
+            updateTask: vi.fn(),
+            createTask: vi.fn(),
+            getTask: vi.fn(),
+            deleteTask: vi.fn(),
+            getAllTasks: vi.fn()
+        };
+        mockConfigService = {
+            getConfig: vi.fn()
+        };
+        // Configure mock constructors
+        LinearClient.mockImplementation(() => mockLinearClient);
+        ContextService.mockImplementation(() => mockContextService);
+        ConfigService.mockImplementation(() => mockConfigService);
+        // Create sync service instance
+        syncService = new LinearSyncService();
+    });
+    afterEach(() => {
+        // Restore environment
+        process.env = originalEnv;
+        vi.clearAllMocks();
+    });
+    describe('Initialization', () => {
+        it('should initialize with Linear API key from environment', () => {
+            expect(LinearClient).toHaveBeenCalledWith({ apiKey: 'test-api-key' });
+        });
+        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(ContextService).toHaveBeenCalled();
+            expect(ConfigService).toHaveBeenCalled();
+        });
+    });
+    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: 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: new Date().toISOString()
+                }
+            ];
+            mockLinearClient.getIssues.mockResolvedValue(mockIssues);
+            mockContextService.getTaskByExternalId.mockResolvedValue(null); // No existing tasks
+            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: 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: 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: 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: new Date().toISOString()
+            };
+            mockContextService.getTaskByExternalId.mockResolvedValue(null);
+            const result = await syncService.syncIssueToLocal(mockIssue);
+            expect(result).toBe('created');
+            expect(mockContextService.createTask).toHaveBeenCalledWith({
+                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: {
+                        teamId: 'team-1',
+                        teamKey: 'STA',
+                        stateId: 'state-1',
+                        stateName: 'Todo',
+                        projectId: 'proj-1',
+                        projectName: 'Main Project',
+                        assigneeId: 'user-1',
+                        assigneeName: 'John Doe'
+                    }
+                },
+                updatedAt: expect.any(Date)
+            });
+        });
+        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: 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: new Date(),
+                updatedAt: new Date()
+            };
+            mockContextService.getTaskByExternalId.mockResolvedValue(existingTask);
+            const result = await syncService.syncIssueToLocal(mockIssue);
+            expect(result).toBe('updated');
+            expect(mockContextService.updateTask).toHaveBeenCalledWith('local-1', {
+                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: {
+                        teamId: 'team-1',
+                        teamKey: 'STA',
+                        stateId: 'state-2',
+                        stateName: 'In Progress',
+                        projectId: undefined,
+                        projectName: undefined,
+                        assigneeId: undefined,
+                        assigneeName: undefined
+                    }
+                },
+                updatedAt: expect.any(Date)
+            });
+        });
+        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: new Date().toISOString()
+            };
+            mockContextService.getTaskByExternalId.mockRejectedValue(new Error('Database error'));
+            await expect(syncService.syncIssueToLocal(mockIssue)).rejects.toThrow('Database error');
+        });
+    });
+    describe('syncLocalToLinear', () => {
+        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: new Date(),
+                updatedAt: 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',
+                priority: 3, // high -> 3
+                stateId: undefined,
+                projectId: undefined,
+                assigneeId: undefined
+            });
+            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: new Date(),
+                updatedAt: 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: 2, // medium -> 2
+                stateId: 'state-1',
+                projectId: 'proj-1',
+                assigneeId: 'user-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: new Date(),
+                updatedAt: 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: new Date(),
+                    updatedAt: new Date()
+                },
+                {
+                    id: 'local-2',
+                    title: 'Task 2',
+                    description: 'Task 2 description',
+                    status: 'todo',
+                    priority: 'medium',
+                    tags: [],
+                    externalIdentifier: 'STA-2',
+                    createdAt: new Date(),
+                    updatedAt: 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: new Date(),
+                    updatedAt: 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', () => {
+        it('should map Linear states to task statuses correctly', () => {
+            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' }
+            ];
+            testCases.forEach(({ linearState, expectedStatus }) => {
+                const mockIssue = {
+                    id: 'test-issue',
+                    identifier: 'TEST-1',
+                    title: 'Test',
+                    state: { type: linearState },
+                    team: { id: 'team-1', key: 'TEST' },
+                    updatedAt: new Date().toISOString()
+                };
+                mockContextService.getTaskByExternalId.mockResolvedValue(null);
+                syncService.syncIssueToLocal(mockIssue);
+                expect(mockContextService.createTask).toHaveBeenCalledWith(expect.objectContaining({ status: expectedStatus }));
+                vi.clearAllMocks();
+            });
+        });
+        it('should map Linear priorities to task priorities correctly', () => {
+            const testCases = [
+                { linearPriority: 1, expectedPriority: 'urgent' },
+                { linearPriority: 2, expectedPriority: 'high' },
+                { linearPriority: 3, expectedPriority: 'medium' },
+                { linearPriority: 4, expectedPriority: 'low' },
+                { linearPriority: undefined, expectedPriority: undefined }
+            ];
+            testCases.forEach(({ linearPriority, expectedPriority }) => {
+                const mockIssue = {
+                    id: 'test-issue',
+                    identifier: 'TEST-1',
+                    title: 'Test',
+                    state: { type: 'unstarted' },
+                    priority: linearPriority,
+                    team: { id: 'team-1', key: 'TEST' },
+                    updatedAt: new Date().toISOString()
+                };
+                mockContextService.getTaskByExternalId.mockResolvedValue(null);
+                syncService.syncIssueToLocal(mockIssue);
+                expect(mockContextService.createTask).toHaveBeenCalledWith(expect.objectContaining({ priority: expectedPriority }));
+                vi.clearAllMocks();
+            });
+        });
+        it('should map task priorities to Linear priorities correctly', () => {
+            const testCases = [
+                { taskPriority: 'urgent', expectedLinearPriority: 4 },
+                { taskPriority: 'high', expectedLinearPriority: 3 },
+                { taskPriority: 'medium', expectedLinearPriority: 2 },
+                { taskPriority: 'low', expectedLinearPriority: 1 },
+                { taskPriority: undefined, expectedLinearPriority: 0 }
+            ];
+            testCases.forEach(({ taskPriority, expectedLinearPriority }) => {
+                const mockTask = {
+                    id: 'local-1',
+                    title: 'Test Task',
+                    description: 'Test description',
+                    status: 'todo',
+                    priority: taskPriority,
+                    tags: [],
+                    createdAt: new Date(),
+                    updatedAt: new Date()
+                };
+                mockContextService.getTask.mockResolvedValue(mockTask);
+                mockLinearClient.createIssue.mockResolvedValue({ id: 'created', identifier: 'TEST-1' });
+                syncService.syncLocalToLinear('local-1');
+                expect(mockLinearClient.createIssue).toHaveBeenCalledWith(expect.objectContaining({ priority: expectedLinearPriority }));
+                vi.clearAllMocks();
+            });
+        });
+    });
+    describe('Change Detection', () => {
+        it('should detect changes in title', () => {
+            const existing = {
+                id: '1',
+                title: 'Old Title',
+                description: 'Same',
+                status: 'todo',
+                priority: 'medium',
+                tags: [],
+                createdAt: new Date(),
+                updatedAt: new Date()
+            };
+            const updated = {
+                title: 'New Title',
+                description: 'Same',
+                status: 'todo',
+                priority: 'medium',
+                tags: []
+            };
+            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: new Date().toISOString()
+            };
+            syncService.syncIssueToLocal(mockIssue);
+            expect(mockContextService.updateTask).toHaveBeenCalled();
+        });
+        it('should detect changes in tags', () => {
+            const existing = {
+                id: '1',
+                title: 'Same',
+                description: 'Same',
+                status: 'todo',
+                priority: 'medium',
+                tags: ['old-tag'],
+                createdAt: new Date(),
+                updatedAt: 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: new Date().toISOString()
+            };
+            syncService.syncIssueToLocal(mockIssue);
+            expect(mockContextService.updateTask).toHaveBeenCalled();
+        });
+        it('should not update when no changes detected', () => {
+            const existing = {
+                id: '1',
+                title: 'Same Title',
+                description: 'Same Description',
+                status: 'todo',
+                priority: 'medium',
+                tags: ['tag1'],
+                createdAt: new Date(),
+                updatedAt: 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,
+                team: { id: 'team-1', key: 'STA' },
+                labels: [{ name: 'tag1' }],
+                updatedAt: new Date().toISOString()
+            };
+            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: new Date().toISOString() },
+                { id: 'issue-2', identifier: 'STA-2', title: 'Bad Issue', state: { type: 'unstarted' }, team: { id: 'team-1', key: 'STA' }, updatedAt: new Date().toISOString() }
+            ];
+            mockConfigService.getConfig.mockResolvedValue({
+                integrations: { linear: { teamId: 'test-team-id' } }
+            });
+            mockLinearClient.getIssues.mockResolvedValue(mockIssues);
+            mockContextService.getTaskByExternalId.mockResolvedValue(null);
+            // First issue succeeds, second fails
+            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