@vibescope/mcp-server 0.0.1 → 0.2.0

package/src/handlers/deployment.test.ts

@@ -1,6 +1,4 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { SupabaseClient } from '@supabase/supabase-js';
-import type { HandlerContext, TokenUsage } from './types.js';
 import {
 	claimDeploymentValidation,
 	reportValidation,
@@ -12,113 +10,14 @@ import {
 	getDeploymentRequirements,
 } from './deployment.js';
 import { ValidationError } from '../validators.js';
+import { createMockContext } from './__test-utils__.js';
+import { mockApiClient } from './__test-setup__.js';
 
 // ============================================================================
 // Test Utilities
 // ============================================================================
 
-function createMockSupabase(overrides: {
-	selectResult?: { data: unknown; error: unknown };
-	insertResult?: { data: unknown; error: unknown };
-	updateResult?: { data: unknown; error: unknown };
-} = {}) {
-	const defaultResult = { data: null, error: null };
-	let currentOperation = 'select';
-	let insertThenSelect = false;
-
-	const mock = {
-		from: vi.fn().mockReturnThis(),
-		select: vi.fn(() => {
-			if (currentOperation === 'insert') {
-				insertThenSelect = true;
-			} else {
-				currentOperation = 'select';
-				insertThenSelect = false;
-			}
-			return mock;
-		}),
-		insert: vi.fn(() => {
-			currentOperation = 'insert';
-			insertThenSelect = false;
-			return mock;
-		}),
-		update: vi.fn(() => {
-			currentOperation = 'update';
-			insertThenSelect = false;
-			return mock;
-		}),
-		delete: vi.fn(() => {
-			currentOperation = 'delete';
-			insertThenSelect = false;
-			return mock;
-		}),
-		eq: vi.fn().mockReturnThis(),
-		neq: vi.fn().mockReturnThis(),
-		in: vi.fn().mockReturnThis(),
-		is: vi.fn().mockReturnThis(),
-		not: vi.fn().mockReturnThis(),
-		or: vi.fn().mockReturnThis(),
-		gte: vi.fn().mockReturnThis(),
-		lte: vi.fn().mockReturnThis(),
-		lt: vi.fn().mockReturnThis(),
-		order: vi.fn().mockReturnThis(),
-		limit: vi.fn().mockReturnThis(),
-		single: vi.fn(() => {
-			if (currentOperation === 'insert' || insertThenSelect) {
-				return Promise.resolve(overrides.insertResult ?? defaultResult);
-			}
-			if (currentOperation === 'select') {
-				return Promise.resolve(overrides.selectResult ?? defaultResult);
-			}
-			if (currentOperation === 'update') {
-				return Promise.resolve(overrides.updateResult ?? defaultResult);
-			}
-			return Promise.resolve(defaultResult);
-		}),
-		maybeSingle: vi.fn(() => {
-			return Promise.resolve(overrides.selectResult ?? defaultResult);
-		}),
-		then: vi.fn((resolve: (value: unknown) => void) => {
-			if (currentOperation === 'insert' || insertThenSelect) {
-				return Promise.resolve(overrides.insertResult ?? defaultResult).then(resolve);
-			}
-			if (currentOperation === 'select') {
-				return Promise.resolve(overrides.selectResult ?? defaultResult).then(resolve);
-			}
-			if (currentOperation === 'update') {
-				return Promise.resolve(overrides.updateResult ?? defaultResult).then(resolve);
-			}
-			return Promise.resolve(defaultResult).then(resolve);
-		}),
-	};
-
-	return mock as unknown as SupabaseClient;
-}
-
-function createMockContext(
-	supabase: SupabaseClient,
-	options: { sessionId?: string | null } = {}
-): HandlerContext {
-	const defaultTokenUsage: TokenUsage = {
-		callCount: 5,
-		totalTokens: 2500,
-		byTool: {},
-	};
-
-	const sessionId = 'sessionId' in options ? options.sessionId : 'session-123';
-
-	return {
-		supabase,
-		auth: { userId: 'user-123', apiKeyId: 'api-key-123' },
-		session: {
-			instanceId: 'instance-abc',
-			currentSessionId: sessionId,
-			currentPersona: 'Wave',
-			tokenUsage: defaultTokenUsage,
-		},
-		updateSession: vi.fn(),
-	};
-}
+const VALID_UUID = '123e4567-e89b-12d3-a456-426614174000';
 
 // ============================================================================
 // claimDeploymentValidation Tests
@@ -128,37 +27,58 @@ describe('claimDeploymentValidation', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(claimDeploymentValidation({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for invalid project_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
 			claimDeploymentValidation({ project_id: 'invalid' }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should return error when no pending deployment', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: { message: 'Not found' } },
+		mockApiClient.claimDeploymentValidation.mockResolvedValue({
+			ok: true,
+			data: { success: false, error: 'No pending deployment found' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
-		const result = await claimDeploymentValidation(
-			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
-			ctx
-		);
+		const result = await claimDeploymentValidation({ project_id: VALID_UUID }, ctx);
 
 		expect(result.result).toMatchObject({
 			success: false,
 			error: 'No pending deployment found',
 		});
 	});
+
+	it('should claim deployment successfully', async () => {
+		mockApiClient.claimDeploymentValidation.mockResolvedValue({
+			ok: true,
+			data: { success: true, deployment_id: 'deploy-1' },
+		});
+		const ctx = createMockContext();
+
+		const result = await claimDeploymentValidation({ project_id: VALID_UUID }, ctx);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			deployment_id: 'deploy-1',
+		});
+	});
+
+	it('should pass session_id to API client', async () => {
+		mockApiClient.claimDeploymentValidation.mockResolvedValue({
+			ok: true,
+			data: { success: true },
+		});
+		const ctx = createMockContext({ sessionId: 'my-session' });
+
+		await claimDeploymentValidation({ project_id: VALID_UUID }, ctx);
+
+		expect(mockApiClient.claimDeploymentValidation).toHaveBeenCalledWith(VALID_UUID, 'my-session');
+	});
 });
 
 // ============================================================================
@@ -169,31 +89,28 @@ describe('reportValidation', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
 			reportValidation({ build_passed: true }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for missing build_passed', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
-			reportValidation({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+			reportValidation({ project_id: VALID_UUID }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should return error when no deployment being validated', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: { message: 'Not found' } },
+		mockApiClient.reportValidation.mockResolvedValue({
+			ok: true,
+			data: { success: false, error: 'No deployment being validated. Use claim_deployment_validation first.' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await reportValidation(
-			{ project_id: '123e4567-e89b-12d3-a456-426614174000', build_passed: true },
+			{ project_id: VALID_UUID, build_passed: true },
 			ctx
 		);
 
@@ -202,6 +119,24 @@ describe('reportValidation', () => {
 			error: 'No deployment being validated. Use claim_deployment_validation first.',
 		});
 	});
+
+	it('should report validation successfully', async () => {
+		mockApiClient.reportValidation.mockResolvedValue({
+			ok: true,
+			data: { success: true, status: 'ready' },
+		});
+		const ctx = createMockContext();
+
+		const result = await reportValidation(
+			{ project_id: VALID_UUID, build_passed: true, tests_passed: true },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			status: 'ready',
+		});
+	});
 });
 
 // ============================================================================
@@ -212,22 +147,18 @@ describe('checkDeploymentStatus', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(checkDeploymentStatus({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should return no deployment when none found', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: { message: 'Not found' } },
+		mockApiClient.checkDeploymentStatus.mockResolvedValue({
+			ok: true,
+			data: { has_deployment: false, message: 'No deployments found for this project' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
-		const result = await checkDeploymentStatus(
-			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
-			ctx
-		);
+		const result = await checkDeploymentStatus({ project_id: VALID_UUID }, ctx);
 
 		expect(result.result).toMatchObject({
 			has_deployment: false,
@@ -240,21 +171,14 @@ describe('checkDeploymentStatus', () => {
 			id: 'deploy-1',
 			status: 'deployed',
 			environment: 'production',
-			requested_by: 'agent',
-			build_passed: true,
-			tests_passed: true,
-			created_at: '2025-01-14T10:00:00Z',
 		};
-
-		const supabase = createMockSupabase({
-			selectResult: { data: mockDeployment, error: null },
+		mockApiClient.checkDeploymentStatus.mockResolvedValue({
+			ok: true,
+			data: { has_deployment: true, deployment: mockDeployment },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
-		const result = await checkDeploymentStatus(
-			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
-			ctx
-		);
+		const result = await checkDeploymentStatus({ project_id: VALID_UUID }, ctx);
 
 		expect(result.result).toMatchObject({
 			has_deployment: true,
@@ -271,28 +195,39 @@ describe('startDeployment', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(startDeployment({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should return error when no deployment ready', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: { message: 'Not found' } },
+		mockApiClient.startDeployment.mockResolvedValue({
+			ok: true,
+			data: { success: false, error: 'No deployment ready. Must pass validation first.' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
-		const result = await startDeployment(
-			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
-			ctx
-		);
+		const result = await startDeployment({ project_id: VALID_UUID }, ctx);
 
 		expect(result.result).toMatchObject({
 			success: false,
 			error: 'No deployment ready. Must pass validation first.',
 		});
 	});
+
+	it('should start deployment successfully', async () => {
+		mockApiClient.startDeployment.mockResolvedValue({
+			ok: true,
+			data: { success: true, status: 'deploying' },
+		});
+		const ctx = createMockContext();
+
+		const result = await startDeployment({ project_id: VALID_UUID }, ctx);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			status: 'deploying',
+		});
+	});
 });
 
 // ============================================================================
@@ -303,31 +238,28 @@ describe('completeDeployment', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
 			completeDeployment({ success: true }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for missing success', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
-			completeDeployment({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+			completeDeployment({ project_id: VALID_UUID }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should return error when no deployment in progress', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: { message: 'Not found' } },
+		mockApiClient.completeDeployment.mockResolvedValue({
+			ok: true,
+			data: { success: false, error: 'No deployment in progress. Use start_deployment first.' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await completeDeployment(
-			{ project_id: '123e4567-e89b-12d3-a456-426614174000', success: true },
+			{ project_id: VALID_UUID, success: true },
 			ctx
 		);
 
@@ -336,6 +268,24 @@ describe('completeDeployment', () => {
 			error: 'No deployment in progress. Use start_deployment first.',
 		});
 	});
+
+	it('should complete deployment successfully', async () => {
+		mockApiClient.completeDeployment.mockResolvedValue({
+			ok: true,
+			data: { success: true, status: 'deployed' },
+		});
+		const ctx = createMockContext();
+
+		const result = await completeDeployment(
+			{ project_id: VALID_UUID, success: true, summary: 'Deployed v1.2.0' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			status: 'deployed',
+		});
+	});
 });
 
 // ============================================================================
@@ -346,26 +296,40 @@ describe('cancelDeployment', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(cancelDeployment({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should return error when no active deployment', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: { message: 'Not found' } },
+		mockApiClient.cancelDeployment.mockResolvedValue({
+			ok: true,
+			data: { success: false, error: 'No active deployment' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
+
+		const result = await cancelDeployment({ project_id: VALID_UUID }, ctx);
+
+		expect(result.result).toMatchObject({
+			success: false,
+			error: 'No active deployment',
+		});
+	});
+
+	it('should cancel deployment successfully', async () => {
+		mockApiClient.cancelDeployment.mockResolvedValue({
+			ok: true,
+			data: { success: true, status: 'failed' },
+		});
+		const ctx = createMockContext();
 
 		const result = await cancelDeployment(
-			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			{ project_id: VALID_UUID, reason: 'Found critical bug' },
 			ctx
 		);
 
 		expect(result.result).toMatchObject({
-			success: false,
-			error: 'No active deployment',
+			success: true,
+			status: 'failed',
 		});
 	});
 });
@@ -378,45 +342,31 @@ describe('addDeploymentRequirement', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
 			addDeploymentRequirement({ type: 'migration', title: 'Test' }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for missing type', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
-			addDeploymentRequirement({
-				project_id: '123e4567-e89b-12d3-a456-426614174000',
-				title: 'Test',
-			}, ctx)
+			addDeploymentRequirement({ project_id: VALID_UUID, title: 'Test' }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for missing title', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
-			addDeploymentRequirement({
-				project_id: '123e4567-e89b-12d3-a456-426614174000',
-				type: 'migration',
-			}, ctx)
+			addDeploymentRequirement({ project_id: VALID_UUID, type: 'migration' }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for invalid type', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
 			addDeploymentRequirement({
-				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				project_id: VALID_UUID,
 				type: 'invalid_type',
 				title: 'Test',
 			}, ctx)
@@ -424,12 +374,10 @@ describe('addDeploymentRequirement', () => {
 	});
 
 	it('should throw error for invalid stage', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
 			addDeploymentRequirement({
-				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				project_id: VALID_UUID,
 				type: 'migration',
 				title: 'Test',
 				stage: 'invalid_stage',
@@ -438,17 +386,15 @@ describe('addDeploymentRequirement', () => {
 	});
 
 	it('should add requirement successfully', async () => {
-		const supabase = createMockSupabase({
-			insertResult: {
-				data: { id: 'req-1', type: 'migration', title: 'Test Migration', stage: 'preparation', blocking: false },
-				error: null,
-			},
+		mockApiClient.addDeploymentRequirement.mockResolvedValue({
+			ok: true,
+			data: { success: true, requirement_id: 'req-1', stage: 'preparation' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await addDeploymentRequirement(
 			{
-				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				project_id: VALID_UUID,
 				type: 'migration',
 				title: 'Test Migration',
 			},
@@ -471,46 +417,54 @@ describe('getDeploymentRequirements', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(getDeploymentRequirements({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should return empty list when no requirements', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+		mockApiClient.getDeploymentRequirements.mockResolvedValue({
+			ok: true,
+			data: { requirements: [], deployment_blocked: false },
 		});
-		const ctx = createMockContext(supabase);
-
-		// Need to mock the .then() to return the array result
-		vi.mocked(supabase.from('').select).mockReturnValue({
-			...supabase,
-			then: (resolve: (val: unknown) => void) =>
-				Promise.resolve({ data: [], error: null }).then(resolve),
-		} as unknown as ReturnType<SupabaseClient['from']>);
+		const ctx = createMockContext();
 
-		const result = await getDeploymentRequirements(
-			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
-			ctx
-		);
+		const result = await getDeploymentRequirements({ project_id: VALID_UUID }, ctx);
 
-		expect(result.result).toHaveProperty('requirements');
-		expect(result.result).toHaveProperty('deployment_blocked');
+		expect(result.result).toMatchObject({
+			requirements: [],
+			deployment_blocked: false,
+		});
 	});
 
 	it('should query with correct project_id', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+		mockApiClient.getDeploymentRequirements.mockResolvedValue({
+			ok: true,
+			data: { requirements: [], deployment_blocked: false },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
-		await getDeploymentRequirements(
-			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
-			ctx
+		await getDeploymentRequirements({ project_id: VALID_UUID }, ctx);
+
+		expect(mockApiClient.getDeploymentRequirements).toHaveBeenCalledWith(
+			VALID_UUID,
+			expect.any(Object)
 		);
+	});
+
+	it('should return requirements list', async () => {
+		const mockReqs = [
+			{ id: 'req-1', type: 'migration', title: 'Run migrations' },
+			{ id: 'req-2', type: 'env_var', title: 'Set API_KEY' },
+		];
+		mockApiClient.getDeploymentRequirements.mockResolvedValue({
+			ok: true,
+			data: { requirements: mockReqs, deployment_blocked: true },
+		});
+		const ctx = createMockContext();
+
+		const result = await getDeploymentRequirements({ project_id: VALID_UUID }, ctx);
 
-		expect(supabase.from).toHaveBeenCalledWith('deployment_requirements');
-		expect(supabase.eq).toHaveBeenCalled();
+		expect((result.result as { requirements: unknown[] }).requirements).toHaveLength(2);
+		expect(result.result).toHaveProperty('deployment_blocked', true);
 	});
 });