@vibescope/mcp-server 0.2.1 → 0.2.3

package/src/handlers/connectors.test.ts

@@ -0,0 +1,834 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import {
+	getConnectors,
+	getConnector,
+	addConnector,
+	updateConnector,
+	deleteConnector,
+	testConnector,
+	getConnectorEvents,
+} from './connectors.js';
+import { ValidationError } from '../validators.js';
+import { createMockContext } from './__test-utils__.js';
+import { mockApiClient } from './__test-setup__.js';
+
+// ============================================================================
+// getConnectors Tests
+// ============================================================================
+
+describe('getConnectors', () => {
+	beforeEach(() => {});
+
+	it('should throw error for missing project_id', async () => {
+		const ctx = createMockContext();
+
+		await expect(getConnectors({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			getConnectors({ project_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should return connectors successfully', async () => {
+		const mockConnectors = [
+			{ id: 'conn-1', name: 'Slack Notifications', type: 'slack' },
+			{ id: 'conn-2', name: 'Webhook', type: 'webhook' },
+		];
+		mockApiClient.getConnectors.mockResolvedValue({
+			ok: true,
+			data: { connectors: mockConnectors, total: 2 },
+		});
+		const ctx = createMockContext();
+
+		const result = await getConnectors(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			connectors: mockConnectors,
+			total: 2,
+		});
+	});
+
+	it('should filter by type', async () => {
+		mockApiClient.getConnectors.mockResolvedValue({
+			ok: true,
+			data: { connectors: [], total: 0 },
+		});
+		const ctx = createMockContext();
+
+		await getConnectors(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				type: 'slack',
+			},
+			ctx
+		);
+
+		expect(mockApiClient.getConnectors).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			expect.objectContaining({ type: 'slack' })
+		);
+	});
+
+	it('should filter by status', async () => {
+		mockApiClient.getConnectors.mockResolvedValue({
+			ok: true,
+			data: { connectors: [], total: 0 },
+		});
+		const ctx = createMockContext();
+
+		await getConnectors(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				status: 'active',
+			},
+			ctx
+		);
+
+		expect(mockApiClient.getConnectors).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			expect.objectContaining({ status: 'active' })
+		);
+	});
+
+	it('should throw error for invalid type', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			getConnectors(
+				{
+					project_id: '123e4567-e89b-12d3-a456-426614174000',
+					type: 'invalid_type',
+				},
+				ctx
+			)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid status', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			getConnectors(
+				{
+					project_id: '123e4567-e89b-12d3-a456-426614174000',
+					status: 'invalid_status',
+				},
+				ctx
+			)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should handle pagination with limit and offset', async () => {
+		mockApiClient.getConnectors.mockResolvedValue({
+			ok: true,
+			data: { connectors: [], total: 100 },
+		});
+		const ctx = createMockContext();
+
+		await getConnectors(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				limit: 10,
+				offset: 20,
+			},
+			ctx
+		);
+
+		expect(mockApiClient.getConnectors).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			expect.objectContaining({ limit: 10, offset: 20 })
+		);
+	});
+
+	it('should handle API error', async () => {
+		mockApiClient.getConnectors.mockResolvedValue({
+			ok: false,
+			error: 'Database error',
+		});
+		const ctx = createMockContext();
+
+		const result = await getConnectors(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result.error).toBe('Database error');
+	});
+});
+
+// ============================================================================
+// getConnector Tests
+// ============================================================================
+
+describe('getConnector', () => {
+	beforeEach(() => {});
+
+	it('should throw error for missing connector_id', async () => {
+		const ctx = createMockContext();
+
+		await expect(getConnector({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid connector_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			getConnector({ connector_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should return connector details', async () => {
+		const mockConnector = {
+			id: 'conn-1',
+			name: 'Slack Bot',
+			type: 'slack',
+			config: { webhook_url: 'https://hooks.slack.com/...' },
+			events: { task_completed: true, blocker_added: true },
+		};
+		mockApiClient.getConnector.mockResolvedValue({
+			ok: true,
+			data: mockConnector,
+		});
+		const ctx = createMockContext();
+
+		const result = await getConnector(
+			{ connector_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject(mockConnector);
+	});
+
+	it('should handle API error', async () => {
+		mockApiClient.getConnector.mockResolvedValue({
+			ok: false,
+			error: 'Connector not found',
+		});
+		const ctx = createMockContext();
+
+		const result = await getConnector(
+			{ connector_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result.error).toBe('Connector not found');
+	});
+});
+
+// ============================================================================
+// addConnector Tests
+// ============================================================================
+
+describe('addConnector', () => {
+	beforeEach(() => {});
+
+	it('should throw error for missing project_id', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			addConnector({ name: 'Test', type: 'webhook' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for missing name', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			addConnector(
+				{
+					project_id: '123e4567-e89b-12d3-a456-426614174000',
+					type: 'webhook',
+				},
+				ctx
+			)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for missing type', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			addConnector(
+				{
+					project_id: '123e4567-e89b-12d3-a456-426614174000',
+					name: 'Test',
+				},
+				ctx
+			)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid type', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			addConnector(
+				{
+					project_id: '123e4567-e89b-12d3-a456-426614174000',
+					name: 'Test',
+					type: 'invalid_type',
+				},
+				ctx
+			)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should create connector with minimal params', async () => {
+		mockApiClient.addConnector.mockResolvedValue({
+			ok: true,
+			data: { connector_id: 'conn-new' },
+		});
+		const ctx = createMockContext();
+
+		const result = await addConnector(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				name: 'My Webhook',
+				type: 'webhook',
+			},
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			connector_id: 'conn-new',
+		});
+	});
+
+	it('should create connector with all params', async () => {
+		mockApiClient.addConnector.mockResolvedValue({
+			ok: true,
+			data: { connector_id: 'conn-new' },
+		});
+		const ctx = createMockContext();
+
+		await addConnector(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				name: 'Slack Alerts',
+				type: 'slack',
+				description: 'Send alerts to Slack',
+				config: { webhook_url: 'https://hooks.slack.com/...' },
+				events: { task_completed: true, deployment_success: true },
+			},
+			ctx
+		);
+
+		expect(mockApiClient.addConnector).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			expect.objectContaining({
+				name: 'Slack Alerts',
+				type: 'slack',
+				description: 'Send alerts to Slack',
+				config: { webhook_url: 'https://hooks.slack.com/...' },
+				events: { task_completed: true, deployment_success: true },
+			})
+		);
+	});
+
+	it('should accept all valid connector types', async () => {
+		const ctx = createMockContext();
+		const validTypes = ['webhook', 'slack', 'discord', 'github', 'custom'];
+
+		for (const type of validTypes) {
+			mockApiClient.addConnector.mockResolvedValue({
+				ok: true,
+				data: { connector_id: `conn-${type}` },
+			});
+
+			const result = await addConnector(
+				{
+					project_id: '123e4567-e89b-12d3-a456-426614174000',
+					name: `Test ${type}`,
+					type,
+				},
+				ctx
+			);
+
+			expect(result.result.connector_id).toBe(`conn-${type}`);
+		}
+	});
+
+	it('should handle API error', async () => {
+		mockApiClient.addConnector.mockResolvedValue({
+			ok: false,
+			error: 'Project not found',
+		});
+		const ctx = createMockContext();
+
+		const result = await addConnector(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				name: 'Test',
+				type: 'webhook',
+			},
+			ctx
+		);
+
+		expect(result.result.error).toBe('Project not found');
+	});
+});
+
+// ============================================================================
+// updateConnector Tests
+// ============================================================================
+
+describe('updateConnector', () => {
+	beforeEach(() => {});
+
+	it('should throw error for missing connector_id', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			updateConnector({ name: 'Updated Name' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid connector_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			updateConnector({ connector_id: 'invalid', name: 'Updated' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should update connector name', async () => {
+		mockApiClient.updateConnector.mockResolvedValue({
+			ok: true,
+			data: { updated: true },
+		});
+		const ctx = createMockContext();
+
+		const result = await updateConnector(
+			{
+				connector_id: '123e4567-e89b-12d3-a456-426614174000',
+				name: 'New Name',
+			},
+			ctx
+		);
+
+		expect(result.result).toMatchObject({ updated: true });
+		expect(mockApiClient.updateConnector).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			expect.objectContaining({ name: 'New Name' })
+		);
+	});
+
+	it('should update connector config', async () => {
+		mockApiClient.updateConnector.mockResolvedValue({
+			ok: true,
+			data: { updated: true },
+		});
+		const ctx = createMockContext();
+
+		await updateConnector(
+			{
+				connector_id: '123e4567-e89b-12d3-a456-426614174000',
+				config: { webhook_url: 'https://new-url.com' },
+			},
+			ctx
+		);
+
+		expect(mockApiClient.updateConnector).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			expect.objectContaining({
+				config: { webhook_url: 'https://new-url.com' },
+			})
+		);
+	});
+
+	it('should update connector events', async () => {
+		mockApiClient.updateConnector.mockResolvedValue({
+			ok: true,
+			data: { updated: true },
+		});
+		const ctx = createMockContext();
+
+		await updateConnector(
+			{
+				connector_id: '123e4567-e89b-12d3-a456-426614174000',
+				events: { task_completed: false, blocker_added: true },
+			},
+			ctx
+		);
+
+		expect(mockApiClient.updateConnector).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			expect.objectContaining({
+				events: { task_completed: false, blocker_added: true },
+			})
+		);
+	});
+
+	it('should update connector status to active', async () => {
+		mockApiClient.updateConnector.mockResolvedValue({
+			ok: true,
+			data: { updated: true },
+		});
+		const ctx = createMockContext();
+
+		await updateConnector(
+			{
+				connector_id: '123e4567-e89b-12d3-a456-426614174000',
+				status: 'active',
+			},
+			ctx
+		);
+
+		expect(mockApiClient.updateConnector).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			expect.objectContaining({ status: 'active' })
+		);
+	});
+
+	it('should update connector status to disabled', async () => {
+		mockApiClient.updateConnector.mockResolvedValue({
+			ok: true,
+			data: { updated: true },
+		});
+		const ctx = createMockContext();
+
+		await updateConnector(
+			{
+				connector_id: '123e4567-e89b-12d3-a456-426614174000',
+				status: 'disabled',
+			},
+			ctx
+		);
+
+		expect(mockApiClient.updateConnector).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			expect.objectContaining({ status: 'disabled' })
+		);
+	});
+
+	it('should throw error for invalid status', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			updateConnector(
+				{
+					connector_id: '123e4567-e89b-12d3-a456-426614174000',
+					status: 'invalid_status',
+				},
+				ctx
+			)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should handle API error', async () => {
+		mockApiClient.updateConnector.mockResolvedValue({
+			ok: false,
+			error: 'Connector not found',
+		});
+		const ctx = createMockContext();
+
+		const result = await updateConnector(
+			{
+				connector_id: '123e4567-e89b-12d3-a456-426614174000',
+				name: 'Updated',
+			},
+			ctx
+		);
+
+		expect(result.result.error).toBe('Connector not found');
+	});
+});
+
+// ============================================================================
+// deleteConnector Tests
+// ============================================================================
+
+describe('deleteConnector', () => {
+	beforeEach(() => {});
+
+	it('should throw error for missing connector_id', async () => {
+		const ctx = createMockContext();
+
+		await expect(deleteConnector({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid connector_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			deleteConnector({ connector_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should delete connector successfully', async () => {
+		mockApiClient.deleteConnector.mockResolvedValue({
+			ok: true,
+			data: { deleted: true },
+		});
+		const ctx = createMockContext();
+
+		const result = await deleteConnector(
+			{ connector_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({ deleted: true });
+	});
+
+	it('should handle API error', async () => {
+		mockApiClient.deleteConnector.mockResolvedValue({
+			ok: false,
+			error: 'Connector not found',
+		});
+		const ctx = createMockContext();
+
+		const result = await deleteConnector(
+			{ connector_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result.error).toBe('Connector not found');
+	});
+});
+
+// ============================================================================
+// testConnector Tests
+// ============================================================================
+
+describe('testConnector', () => {
+	beforeEach(() => {});
+
+	it('should throw error for missing connector_id', async () => {
+		const ctx = createMockContext();
+
+		await expect(testConnector({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid connector_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			testConnector({ connector_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should test connector successfully', async () => {
+		mockApiClient.testConnector.mockResolvedValue({
+			ok: true,
+			data: { success: true, message: 'Test event sent' },
+		});
+		const ctx = createMockContext();
+
+		const result = await testConnector(
+			{ connector_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			message: 'Test event sent',
+		});
+	});
+
+	it('should handle test failure', async () => {
+		mockApiClient.testConnector.mockResolvedValue({
+			ok: true,
+			data: { success: false, error: 'Webhook returned 404' },
+		});
+		const ctx = createMockContext();
+
+		const result = await testConnector(
+			{ connector_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: false,
+			error: 'Webhook returned 404',
+		});
+	});
+
+	it('should handle API error', async () => {
+		mockApiClient.testConnector.mockResolvedValue({
+			ok: false,
+			error: 'Connector not found',
+		});
+		const ctx = createMockContext();
+
+		const result = await testConnector(
+			{ connector_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result.error).toBe('Connector not found');
+	});
+});
+
+// ============================================================================
+// getConnectorEvents Tests
+// ============================================================================
+
+describe('getConnectorEvents', () => {
+	beforeEach(() => {});
+
+	it('should throw error when neither connector_id nor project_id provided', async () => {
+		const ctx = createMockContext();
+
+		const result = await getConnectorEvents({}, ctx);
+
+		expect(result.result.error).toBe(
+			'Either connector_id or project_id is required'
+		);
+	});
+
+	it('should throw error for invalid connector_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			getConnectorEvents({ connector_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			getConnectorEvents({ project_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should get events by connector_id', async () => {
+		const mockEvents = [
+			{ id: 'evt-1', event_type: 'task_completed', status: 'sent' },
+			{ id: 'evt-2', event_type: 'blocker_added', status: 'failed' },
+		];
+		mockApiClient.getConnectorEvents.mockResolvedValue({
+			ok: true,
+			data: { events: mockEvents, total: 2 },
+		});
+		const ctx = createMockContext();
+
+		const result = await getConnectorEvents(
+			{ connector_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			events: mockEvents,
+			total: 2,
+		});
+	});
+
+	it('should get events by project_id', async () => {
+		mockApiClient.getConnectorEvents.mockResolvedValue({
+			ok: true,
+			data: { events: [], total: 0 },
+		});
+		const ctx = createMockContext();
+
+		await getConnectorEvents(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(mockApiClient.getConnectorEvents).toHaveBeenCalledWith(
+			expect.objectContaining({
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+			})
+		);
+	});
+
+	it('should filter by status', async () => {
+		mockApiClient.getConnectorEvents.mockResolvedValue({
+			ok: true,
+			data: { events: [], total: 0 },
+		});
+		const ctx = createMockContext();
+
+		await getConnectorEvents(
+			{
+				connector_id: '123e4567-e89b-12d3-a456-426614174000',
+				status: 'failed',
+			},
+			ctx
+		);
+
+		expect(mockApiClient.getConnectorEvents).toHaveBeenCalledWith(
+			expect.objectContaining({ status: 'failed' })
+		);
+	});
+
+	it('should accept all valid event statuses', async () => {
+		const ctx = createMockContext();
+		const validStatuses = ['pending', 'sent', 'failed', 'retrying'];
+
+		for (const status of validStatuses) {
+			mockApiClient.getConnectorEvents.mockResolvedValue({
+				ok: true,
+				data: { events: [], total: 0 },
+			});
+
+			const result = await getConnectorEvents(
+				{
+					connector_id: '123e4567-e89b-12d3-a456-426614174000',
+					status,
+				},
+				ctx
+			);
+
+			expect(result.result.events).toBeDefined();
+		}
+	});
+
+	it('should throw error for invalid status', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			getConnectorEvents(
+				{
+					connector_id: '123e4567-e89b-12d3-a456-426614174000',
+					status: 'invalid_status',
+				},
+				ctx
+			)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should handle pagination', async () => {
+		mockApiClient.getConnectorEvents.mockResolvedValue({
+			ok: true,
+			data: { events: [], total: 100 },
+		});
+		const ctx = createMockContext();
+
+		await getConnectorEvents(
+			{
+				connector_id: '123e4567-e89b-12d3-a456-426614174000',
+				limit: 25,
+				offset: 50,
+			},
+			ctx
+		);
+
+		expect(mockApiClient.getConnectorEvents).toHaveBeenCalledWith(
+			expect.objectContaining({ limit: 25, offset: 50 })
+		);
+	});
+
+	it('should handle API error', async () => {
+		mockApiClient.getConnectorEvents.mockResolvedValue({
+			ok: false,
+			error: 'Database error',
+		});
+		const ctx = createMockContext();
+
+		const result = await getConnectorEvents(
+			{ connector_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result.error).toBe('Database error');
+	});
+});