@vibescope/mcp-server 0.0.1 → 0.1.0

package/src/handlers/git-issues.test.ts

@@ -0,0 +1,623 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+	addGitIssue,
+	resolveGitIssue,
+	getGitIssues,
+	deleteGitIssue,
+} from './git-issues.js';
+import { ValidationError } from '../validators.js';
+import { createMockContext } from './__test-utils__.js';
+import { mockApiClient } from './__test-setup__.js';
+
+const VALID_PROJECT_ID = '123e4567-e89b-12d3-a456-426614174000';
+const VALID_GIT_ISSUE_ID = '987e6543-e21b-12d3-a456-426614174000';
+
+// ============================================================================
+// addGitIssue Tests
+// ============================================================================
+
+describe('addGitIssue', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			addGitIssue({ issue_type: 'merge_conflict', branch: 'feature/test' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			addGitIssue({ project_id: 'invalid', issue_type: 'merge_conflict', branch: 'feature/test' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for missing issue_type', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			addGitIssue({ project_id: VALID_PROJECT_ID, branch: 'feature/test' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for missing branch', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			addGitIssue({ project_id: VALID_PROJECT_ID, issue_type: 'merge_conflict' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid issue_type', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			addGitIssue({
+				project_id: VALID_PROJECT_ID,
+				issue_type: 'invalid_type',
+				branch: 'feature/test',
+			}, ctx)
+		).rejects.toThrow('Invalid issue_type');
+	});
+
+	it('should throw error for invalid task_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			addGitIssue({
+				project_id: VALID_PROJECT_ID,
+				issue_type: 'merge_conflict',
+				branch: 'feature/test',
+				task_id: 'invalid-uuid',
+			}, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should add git issue successfully', async () => {
+		mockApiClient.addGitIssue.mockResolvedValue({
+			ok: true,
+			data: { success: true, git_issue_id: VALID_GIT_ISSUE_ID },
+		});
+		const ctx = createMockContext();
+
+		const result = await addGitIssue(
+			{
+				project_id: VALID_PROJECT_ID,
+				issue_type: 'merge_conflict',
+				branch: 'feature/test',
+			},
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			git_issue_id: VALID_GIT_ISSUE_ID,
+		});
+	});
+
+	it('should add git issue with all optional fields', async () => {
+		mockApiClient.addGitIssue.mockResolvedValue({
+			ok: true,
+			data: { success: true, git_issue_id: VALID_GIT_ISSUE_ID },
+		});
+		const ctx = createMockContext({ sessionId: 'test-session' });
+
+		await addGitIssue(
+			{
+				project_id: VALID_PROJECT_ID,
+				issue_type: 'pr_not_mergeable',
+				branch: 'feature/test',
+				target_branch: 'main',
+				pr_url: 'https://github.com/org/repo/pull/123',
+				conflicting_files: ['src/file1.ts', 'src/file2.ts'],
+				error_message: 'Merge conflict in file1.ts',
+				task_id: VALID_GIT_ISSUE_ID,
+			},
+			ctx
+		);
+
+		expect(mockApiClient.addGitIssue).toHaveBeenCalledWith(
+			VALID_PROJECT_ID,
+			{
+				issue_type: 'pr_not_mergeable',
+				branch: 'feature/test',
+				target_branch: 'main',
+				pr_url: 'https://github.com/org/repo/pull/123',
+				conflicting_files: ['src/file1.ts', 'src/file2.ts'],
+				error_message: 'Merge conflict in file1.ts',
+				task_id: VALID_GIT_ISSUE_ID,
+			},
+			'test-session'
+		);
+	});
+
+	it('should include session_id in API call', async () => {
+		mockApiClient.addGitIssue.mockResolvedValue({
+			ok: true,
+			data: { success: true, git_issue_id: VALID_GIT_ISSUE_ID },
+		});
+		const ctx = createMockContext({ sessionId: 'my-session' });
+
+		await addGitIssue(
+			{
+				project_id: VALID_PROJECT_ID,
+				issue_type: 'push_failed',
+				branch: 'feature/test',
+			},
+			ctx
+		);
+
+		expect(mockApiClient.addGitIssue).toHaveBeenCalledWith(
+			VALID_PROJECT_ID,
+			expect.objectContaining({
+				issue_type: 'push_failed',
+				branch: 'feature/test',
+			}),
+			'my-session'
+		);
+	});
+
+	it('should accept all valid issue types', async () => {
+		const validTypes = ['merge_conflict', 'push_failed', 'rebase_needed', 'branch_diverged', 'pr_not_mergeable'];
+		const ctx = createMockContext();
+
+		for (const issueType of validTypes) {
+			mockApiClient.addGitIssue.mockResolvedValue({
+				ok: true,
+				data: { success: true, git_issue_id: VALID_GIT_ISSUE_ID },
+			});
+
+			await expect(
+				addGitIssue({
+					project_id: VALID_PROJECT_ID,
+					issue_type: issueType,
+					branch: 'feature/test',
+				}, ctx)
+			).resolves.not.toThrow();
+		}
+	});
+
+	it('should throw error when API call fails', async () => {
+		mockApiClient.addGitIssue.mockResolvedValue({
+			ok: false,
+			error: 'Insert failed',
+		});
+		const ctx = createMockContext();
+
+		await expect(
+			addGitIssue({
+				project_id: VALID_PROJECT_ID,
+				issue_type: 'merge_conflict',
+				branch: 'feature/test',
+			}, ctx)
+		).rejects.toThrow('Insert failed');
+	});
+
+	it('should throw default error message when API fails without error', async () => {
+		mockApiClient.addGitIssue.mockResolvedValue({
+			ok: false,
+		});
+		const ctx = createMockContext();
+
+		await expect(
+			addGitIssue({
+				project_id: VALID_PROJECT_ID,
+				issue_type: 'merge_conflict',
+				branch: 'feature/test',
+			}, ctx)
+		).rejects.toThrow('Failed to add git issue');
+	});
+});
+
+// ============================================================================
+// resolveGitIssue Tests
+// ============================================================================
+
+describe('resolveGitIssue', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing git_issue_id', async () => {
+		const ctx = createMockContext();
+
+		await expect(resolveGitIssue({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid git_issue_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			resolveGitIssue({ git_issue_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should resolve git issue successfully', async () => {
+		mockApiClient.resolveGitIssue.mockResolvedValue({
+			ok: true,
+			data: { success: true, git_issue_id: VALID_GIT_ISSUE_ID },
+		});
+		const ctx = createMockContext();
+
+		const result = await resolveGitIssue(
+			{ git_issue_id: VALID_GIT_ISSUE_ID },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			git_issue_id: VALID_GIT_ISSUE_ID,
+		});
+	});
+
+	it('should resolve git issue with resolution_note', async () => {
+		mockApiClient.resolveGitIssue.mockResolvedValue({
+			ok: true,
+			data: { success: true, git_issue_id: VALID_GIT_ISSUE_ID },
+		});
+		const ctx = createMockContext({ sessionId: 'test-session' });
+
+		await resolveGitIssue(
+			{
+				git_issue_id: VALID_GIT_ISSUE_ID,
+				resolution_note: 'Resolved by rebasing',
+			},
+			ctx
+		);
+
+		expect(mockApiClient.resolveGitIssue).toHaveBeenCalledWith(
+			VALID_GIT_ISSUE_ID,
+			{ resolution_note: 'Resolved by rebasing', auto_resolved: undefined },
+			'test-session'
+		);
+	});
+
+	it('should resolve git issue with auto_resolved flag', async () => {
+		mockApiClient.resolveGitIssue.mockResolvedValue({
+			ok: true,
+			data: { success: true, git_issue_id: VALID_GIT_ISSUE_ID },
+		});
+		const ctx = createMockContext({ sessionId: 'test-session' });
+
+		await resolveGitIssue(
+			{
+				git_issue_id: VALID_GIT_ISSUE_ID,
+				auto_resolved: true,
+			},
+			ctx
+		);
+
+		expect(mockApiClient.resolveGitIssue).toHaveBeenCalledWith(
+			VALID_GIT_ISSUE_ID,
+			{ resolution_note: undefined, auto_resolved: true },
+			'test-session'
+		);
+	});
+
+	it('should include session_id in API call', async () => {
+		mockApiClient.resolveGitIssue.mockResolvedValue({
+			ok: true,
+			data: { success: true, git_issue_id: VALID_GIT_ISSUE_ID },
+		});
+		const ctx = createMockContext({ sessionId: 'my-session' });
+
+		await resolveGitIssue(
+			{ git_issue_id: VALID_GIT_ISSUE_ID },
+			ctx
+		);
+
+		expect(mockApiClient.resolveGitIssue).toHaveBeenCalledWith(
+			VALID_GIT_ISSUE_ID,
+			expect.any(Object),
+			'my-session'
+		);
+	});
+
+	it('should throw error when API call fails', async () => {
+		mockApiClient.resolveGitIssue.mockResolvedValue({
+			ok: false,
+			error: 'Update failed',
+		});
+		const ctx = createMockContext();
+
+		await expect(
+			resolveGitIssue({ git_issue_id: VALID_GIT_ISSUE_ID }, ctx)
+		).rejects.toThrow('Update failed');
+	});
+
+	it('should throw default error message when API fails without error', async () => {
+		mockApiClient.resolveGitIssue.mockResolvedValue({
+			ok: false,
+		});
+		const ctx = createMockContext();
+
+		await expect(
+			resolveGitIssue({ git_issue_id: VALID_GIT_ISSUE_ID }, ctx)
+		).rejects.toThrow('Failed to resolve git issue');
+	});
+});
+
+// ============================================================================
+// getGitIssues Tests
+// ============================================================================
+
+describe('getGitIssues', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const ctx = createMockContext();
+
+		await expect(getGitIssues({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			getGitIssues({ project_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid status', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			getGitIssues({ project_id: VALID_PROJECT_ID, status: 'invalid_status' }, ctx)
+		).rejects.toThrow('Invalid status');
+	});
+
+	it('should throw error for invalid issue_type filter', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			getGitIssues({ project_id: VALID_PROJECT_ID, issue_type: 'invalid_type' }, ctx)
+		).rejects.toThrow('Invalid issue_type');
+	});
+
+	it('should return empty list when no git issues', async () => {
+		mockApiClient.getGitIssues.mockResolvedValue({
+			ok: true,
+			data: { git_issues: [] },
+		});
+		const ctx = createMockContext();
+
+		const result = await getGitIssues(
+			{ project_id: VALID_PROJECT_ID },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			git_issues: [],
+		});
+	});
+
+	it('should return git issues list', async () => {
+		const mockGitIssues = [
+			{ id: 'gi1', issue_type: 'merge_conflict', branch: 'feature/a', status: 'open', created_at: '2025-01-14T10:00:00Z' },
+			{ id: 'gi2', issue_type: 'push_failed', branch: 'feature/b', status: 'open', created_at: '2025-01-14T11:00:00Z' },
+		];
+		mockApiClient.getGitIssues.mockResolvedValue({
+			ok: true,
+			data: { git_issues: mockGitIssues },
+		});
+		const ctx = createMockContext();
+
+		const result = await getGitIssues(
+			{ project_id: VALID_PROJECT_ID },
+			ctx
+		);
+
+		expect((result.result as { git_issues: unknown[] }).git_issues).toHaveLength(2);
+	});
+
+	it('should pass status parameter to API (default: open)', async () => {
+		mockApiClient.getGitIssues.mockResolvedValue({
+			ok: true,
+			data: { git_issues: [] },
+		});
+		const ctx = createMockContext();
+
+		await getGitIssues(
+			{ project_id: VALID_PROJECT_ID },
+			ctx
+		);
+
+		expect(mockApiClient.getGitIssues).toHaveBeenCalledWith(
+			VALID_PROJECT_ID,
+			expect.objectContaining({ status: 'open' })
+		);
+	});
+
+	it('should pass custom status to API', async () => {
+		mockApiClient.getGitIssues.mockResolvedValue({
+			ok: true,
+			data: { git_issues: [] },
+		});
+		const ctx = createMockContext();
+
+		await getGitIssues(
+			{ project_id: VALID_PROJECT_ID, status: 'resolved' },
+			ctx
+		);
+
+		expect(mockApiClient.getGitIssues).toHaveBeenCalledWith(
+			VALID_PROJECT_ID,
+			expect.objectContaining({ status: 'resolved' })
+		);
+	});
+
+	it('should pass issue_type filter to API', async () => {
+		mockApiClient.getGitIssues.mockResolvedValue({
+			ok: true,
+			data: { git_issues: [] },
+		});
+		const ctx = createMockContext();
+
+		await getGitIssues(
+			{ project_id: VALID_PROJECT_ID, issue_type: 'merge_conflict' },
+			ctx
+		);
+
+		expect(mockApiClient.getGitIssues).toHaveBeenCalledWith(
+			VALID_PROJECT_ID,
+			expect.objectContaining({ issue_type: 'merge_conflict' })
+		);
+	});
+
+	it('should pass branch filter to API', async () => {
+		mockApiClient.getGitIssues.mockResolvedValue({
+			ok: true,
+			data: { git_issues: [] },
+		});
+		const ctx = createMockContext();
+
+		await getGitIssues(
+			{ project_id: VALID_PROJECT_ID, branch: 'feature/test' },
+			ctx
+		);
+
+		expect(mockApiClient.getGitIssues).toHaveBeenCalledWith(
+			VALID_PROJECT_ID,
+			expect.objectContaining({ branch: 'feature/test' })
+		);
+	});
+
+	it('should pass limit parameter to API (default: 50)', async () => {
+		mockApiClient.getGitIssues.mockResolvedValue({
+			ok: true,
+			data: { git_issues: [] },
+		});
+		const ctx = createMockContext();
+
+		await getGitIssues(
+			{ project_id: VALID_PROJECT_ID },
+			ctx
+		);
+
+		expect(mockApiClient.getGitIssues).toHaveBeenCalledWith(
+			VALID_PROJECT_ID,
+			expect.objectContaining({ limit: 50 })
+		);
+	});
+
+	it('should pass custom limit to API', async () => {
+		mockApiClient.getGitIssues.mockResolvedValue({
+			ok: true,
+			data: { git_issues: [] },
+		});
+		const ctx = createMockContext();
+
+		await getGitIssues(
+			{ project_id: VALID_PROJECT_ID, limit: 10 },
+			ctx
+		);
+
+		expect(mockApiClient.getGitIssues).toHaveBeenCalledWith(
+			VALID_PROJECT_ID,
+			expect.objectContaining({ limit: 10 })
+		);
+	});
+
+	it('should throw error when API call fails', async () => {
+		mockApiClient.getGitIssues.mockResolvedValue({
+			ok: false,
+			error: 'Query failed',
+		});
+		const ctx = createMockContext();
+
+		await expect(
+			getGitIssues({ project_id: VALID_PROJECT_ID }, ctx)
+		).rejects.toThrow('Query failed');
+	});
+
+	it('should throw default error message when API fails without error', async () => {
+		mockApiClient.getGitIssues.mockResolvedValue({
+			ok: false,
+		});
+		const ctx = createMockContext();
+
+		await expect(
+			getGitIssues({ project_id: VALID_PROJECT_ID }, ctx)
+		).rejects.toThrow('Failed to fetch git issues');
+	});
+});
+
+// ============================================================================
+// deleteGitIssue Tests
+// ============================================================================
+
+describe('deleteGitIssue', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing git_issue_id', async () => {
+		const ctx = createMockContext();
+
+		await expect(deleteGitIssue({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid git_issue_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			deleteGitIssue({ git_issue_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should delete git issue successfully', async () => {
+		mockApiClient.deleteGitIssue.mockResolvedValue({
+			ok: true,
+			data: { success: true },
+		});
+		const ctx = createMockContext();
+
+		const result = await deleteGitIssue(
+			{ git_issue_id: VALID_GIT_ISSUE_ID },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+		});
+	});
+
+	it('should call API client deleteGitIssue', async () => {
+		mockApiClient.deleteGitIssue.mockResolvedValue({
+			ok: true,
+			data: { success: true },
+		});
+		const ctx = createMockContext();
+
+		await deleteGitIssue(
+			{ git_issue_id: VALID_GIT_ISSUE_ID },
+			ctx
+		);
+
+		expect(mockApiClient.deleteGitIssue).toHaveBeenCalledWith(
+			VALID_GIT_ISSUE_ID
+		);
+	});
+
+	it('should throw error when API call fails', async () => {
+		mockApiClient.deleteGitIssue.mockResolvedValue({
+			ok: false,
+			error: 'Delete failed',
+		});
+		const ctx = createMockContext();
+
+		await expect(
+			deleteGitIssue({ git_issue_id: VALID_GIT_ISSUE_ID }, ctx)
+		).rejects.toThrow('Delete failed');
+	});
+
+	it('should throw default error message when API fails without error', async () => {
+		mockApiClient.deleteGitIssue.mockResolvedValue({
+			ok: false,
+		});
+		const ctx = createMockContext();
+
+		await expect(
+			deleteGitIssue({ git_issue_id: VALID_GIT_ISSUE_ID }, ctx)
+		).rejects.toThrow('Failed to delete git issue');
+	});
+});