@vibescope/mcp-server 0.0.1 → 0.2.0

package/src/handlers/__test-utils__.ts

@@ -2,141 +2,12 @@
  * Shared Test Utilities
  *
  * Common mock factories and test helpers used across handler tests.
- * This eliminates ~85 lines of duplicate code per test file.
+ * Handlers now use API client instead of direct Supabase access.
  */
 
 import { vi } from 'vitest';
-import type { SupabaseClient } from '@supabase/supabase-js';
 import type { HandlerContext, TokenUsage } from './types.js';
 
-// ============================================================================
-// Mock Supabase Factory
-// ============================================================================
-
-export interface MockSupabaseOverrides {
-	selectResult?: { data: unknown; error: unknown };
-	insertResult?: { data: unknown; error: unknown };
-	updateResult?: { data: unknown; error: unknown };
-	deleteResult?: { data: unknown; error: unknown };
-	sessionsResult?: { data: unknown; error: unknown };
-}
-
-/**
- * Create a mock Supabase client for testing.
- *
- * The mock tracks which operation is being performed and returns
- * the appropriate result from overrides.
- *
- * @example
- * ```ts
- * const supabase = createMockSupabase({
- *   insertResult: { data: { id: 'new-id' }, error: null }
- * });
- * ```
- */
-export function createMockSupabase(overrides: MockSupabaseOverrides = {}) {
-	const defaultResult = { data: null, error: null };
-
-	// Use an object to track state so it persists across all mock function calls
-	const state = {
-		currentOperation: 'select' as string,
-		currentTable: '' as string,
-		insertThenSelect: false,
-		updateCalled: false,
-	};
-
-	const mock = {
-		from: vi.fn((table: string) => {
-			state.currentTable = table;
-			// Reset state for new query chain
-			state.currentOperation = 'select';
-			state.insertThenSelect = false;
-			state.updateCalled = false;
-			return mock;
-		}),
-		select: vi.fn(() => {
-			if (state.currentOperation === 'insert') {
-				state.insertThenSelect = true;
-			} else if (!state.updateCalled) {
-				state.currentOperation = 'select';
-				state.insertThenSelect = false;
-			}
-			return mock;
-		}),
-		insert: vi.fn(() => {
-			state.currentOperation = 'insert';
-			state.insertThenSelect = false;
-			return mock;
-		}),
-		update: vi.fn(() => {
-			state.currentOperation = 'update';
-			state.updateCalled = true;
-			state.insertThenSelect = false;
-			return mock;
-		}),
-		delete: vi.fn(() => {
-			state.currentOperation = 'delete';
-			state.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(),
-		gt: 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 (state.currentOperation === 'insert' || state.insertThenSelect) {
-				return Promise.resolve(overrides.insertResult ?? defaultResult);
-			}
-			if (state.updateCalled) {
-				return Promise.resolve(overrides.updateResult ?? defaultResult);
-			}
-			if (state.currentOperation === 'select') {
-				return Promise.resolve(overrides.selectResult ?? defaultResult);
-			}
-			if (state.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) => {
-			// Handle special table cases
-			if (state.currentTable === 'agent_sessions' && overrides.sessionsResult) {
-				return Promise.resolve(overrides.sessionsResult).then(resolve);
-			}
-
-			if (state.currentOperation === 'insert' || state.insertThenSelect) {
-				return Promise.resolve(overrides.insertResult ?? defaultResult).then(resolve);
-			}
-			if (state.updateCalled) {
-				return Promise.resolve(overrides.updateResult ?? defaultResult).then(resolve);
-			}
-			if (state.currentOperation === 'select') {
-				return Promise.resolve(overrides.selectResult ?? defaultResult).then(resolve);
-			}
-			if (state.currentOperation === 'update') {
-				return Promise.resolve(overrides.updateResult ?? defaultResult).then(resolve);
-			}
-			if (state.currentOperation === 'delete') {
-				return Promise.resolve(overrides.deleteResult ?? defaultResult).then(resolve);
-			}
-			return Promise.resolve(defaultResult).then(resolve);
-		}),
-	};
-
-	return mock as unknown as SupabaseClient;
-}
-
 // ============================================================================
 // Mock Handler Context Factory
 // ============================================================================
@@ -147,6 +18,7 @@ export interface MockContextOptions {
 	apiKeyId?: string;
 	instanceId?: string;
 	persona?: string;
+	tokenUsage?: TokenUsage;
 }
 
 /**
@@ -154,11 +26,10 @@ export interface MockContextOptions {
  *
  * @example
  * ```ts
- * const ctx = createMockContext(supabase, { sessionId: 'test-session' });
+ * const ctx = createMockContext({ sessionId: 'test-session' });
  * ```
  */
 export function createMockContext(
-	supabase: SupabaseClient,
 	options: MockContextOptions = {}
 ): HandlerContext {
 	const defaultTokenUsage: TokenUsage = {
@@ -172,7 +43,6 @@ export function createMockContext(
 	const sessionId = 'sessionId' in options ? (options.sessionId ?? null) : 'session-123';
 
 	return {
-		supabase,
 		auth: {
 			userId: options.userId ?? 'user-123',
 			apiKeyId: options.apiKeyId ?? 'api-key-123',
@@ -182,7 +52,7 @@ export function createMockContext(
 			instanceId: options.instanceId ?? 'instance-abc',
 			currentSessionId: sessionId,
 			currentPersona: options.persona ?? 'Wave',
-			tokenUsage: defaultTokenUsage,
+			tokenUsage: options.tokenUsage ?? defaultTokenUsage,
 		},
 		updateSession: vi.fn(),
 	};

package/src/handlers/blockers.test.ts

@@ -6,7 +6,8 @@ import {
 	deleteBlocker,
 } from './blockers.js';
 import { ValidationError } from '../validators.js';
-import { createMockSupabase, createMockContext } from './__test-utils__.js';
+import { createMockContext } from './__test-utils__.js';
+import { mockApiClient } from './__test-setup__.js';
 
 // ============================================================================
 // addBlocker Tests
@@ -16,8 +17,7 @@ describe('addBlocker', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			addBlocker({ description: 'Some blocker' }, ctx)
@@ -25,8 +25,7 @@ describe('addBlocker', () => {
 	});
 
 	it('should throw error for invalid project_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			addBlocker({ project_id: 'invalid', description: 'Some blocker' }, ctx)
@@ -34,8 +33,7 @@ describe('addBlocker', () => {
 	});
 
 	it('should throw error for missing description', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			addBlocker({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
@@ -43,10 +41,11 @@ describe('addBlocker', () => {
 	});
 
 	it('should add blocker successfully', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: { id: 'blocker-1' }, error: null },
+		mockApiClient.addBlocker.mockResolvedValue({
+			ok: true,
+			data: { success: true, blocker_id: 'blocker-1' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await addBlocker(
 			{
@@ -62,11 +61,12 @@ describe('addBlocker', () => {
 		});
 	});
 
-	it('should include session_id in insert', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: { id: 'blocker-1' }, error: null },
+	it('should include session_id in API call', async () => {
+		mockApiClient.addBlocker.mockResolvedValue({
+			ok: true,
+			data: { success: true, blocker_id: 'blocker-1' },
 		});
-		const ctx = createMockContext(supabase, { sessionId: 'my-session' });
+		const ctx = createMockContext({ sessionId: 'my-session' });
 
 		await addBlocker(
 			{
@@ -76,26 +76,26 @@ describe('addBlocker', () => {
 			ctx
 		);
 
-		expect(supabase.insert).toHaveBeenCalledWith(
-			expect.objectContaining({
-				created_by: 'agent',
-				created_by_session_id: 'my-session',
-			})
+		expect(mockApiClient.addBlocker).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			'Blocked by dependency',
+			'my-session'
 		);
 	});
 
-	it('should throw error when insert fails', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: null, error: { message: 'Insert failed' } },
+	it('should throw error when API call fails', async () => {
+		mockApiClient.addBlocker.mockResolvedValue({
+			ok: false,
+			error: 'Insert failed',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			addBlocker({
 				project_id: '123e4567-e89b-12d3-a456-426614174000',
 				description: 'Test blocker',
 			}, ctx)
-		).rejects.toThrow('Failed to add blocker: Insert failed');
+		).rejects.toThrow('Insert failed');
 	});
 });
 
@@ -107,15 +107,13 @@ describe('resolveBlocker', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing blocker_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(resolveBlocker({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for invalid blocker_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			resolveBlocker({ blocker_id: 'invalid' }, ctx)
@@ -123,10 +121,11 @@ describe('resolveBlocker', () => {
 	});
 
 	it('should resolve blocker successfully', async () => {
-		const supabase = createMockSupabase({
-			updateResult: { data: null, error: null },
+		mockApiClient.resolveBlocker.mockResolvedValue({
+			ok: true,
+			data: { success: true, blocker_id: '123e4567-e89b-12d3-a456-426614174000' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await resolveBlocker(
 			{ blocker_id: '123e4567-e89b-12d3-a456-426614174000' },
@@ -140,10 +139,11 @@ describe('resolveBlocker', () => {
 	});
 
 	it('should resolve blocker with resolution note', async () => {
-		const supabase = createMockSupabase({
-			updateResult: { data: null, error: null },
+		mockApiClient.resolveBlocker.mockResolvedValue({
+			ok: true,
+			data: { success: true, blocker_id: '123e4567-e89b-12d3-a456-426614174000' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await resolveBlocker(
 			{
@@ -153,48 +153,40 @@ describe('resolveBlocker', () => {
 			ctx
 		);
 
-		expect(supabase.update).toHaveBeenCalledWith(
-			expect.objectContaining({
-				status: 'resolved',
-				resolution_note: 'Fixed by upgrading dependency',
-			})
+		expect(mockApiClient.resolveBlocker).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			'Fixed by upgrading dependency'
 		);
 	});
 
-	it('should set resolved_at timestamp', async () => {
-		const supabase = createMockSupabase({
-			updateResult: { data: null, error: null },
+	it('should call API client resolveBlocker', async () => {
+		mockApiClient.resolveBlocker.mockResolvedValue({
+			ok: true,
+			data: { success: true, blocker_id: '123e4567-e89b-12d3-a456-426614174000' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await resolveBlocker(
 			{ blocker_id: '123e4567-e89b-12d3-a456-426614174000' },
 			ctx
 		);
 
-		expect(supabase.update).toHaveBeenCalledWith(
-			expect.objectContaining({
-				resolved_at: expect.any(String),
-			})
+		expect(mockApiClient.resolveBlocker).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			undefined
 		);
 	});
 
-	it('should throw error when update fails', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
-		// Override update to return error
-		vi.mocked(supabase.from('').update).mockReturnValue({
-			...supabase,
-			eq: vi.fn().mockReturnValue({
-				then: (resolve: (val: unknown) => void) =>
-					Promise.resolve({ data: null, error: { message: 'Update failed' } }).then(resolve),
-			}),
-		} as unknown as ReturnType<SupabaseClient['from']>);
+	it('should throw error when API call fails', async () => {
+		mockApiClient.resolveBlocker.mockResolvedValue({
+			ok: false,
+			error: 'Update failed',
+		});
+		const ctx = createMockContext();
 
 		await expect(
 			resolveBlocker({ blocker_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
-		).rejects.toThrow('Failed to resolve blocker');
+		).rejects.toThrow('Update failed');
 	});
 });
 
@@ -206,15 +198,13 @@ describe('getBlockers', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(getBlockers({}, 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(
 			getBlockers({ project_id: 'invalid' }, ctx)
@@ -222,10 +212,11 @@ describe('getBlockers', () => {
 	});
 
 	it('should return empty list when no blockers', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+		mockApiClient.getBlockers.mockResolvedValue({
+			ok: true,
+			data: { blockers: [] },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await getBlockers(
 			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
@@ -242,11 +233,11 @@ describe('getBlockers', () => {
 			{ id: 'b1', description: 'Blocker 1', status: 'open', created_at: '2025-01-14T10:00:00Z' },
 			{ id: 'b2', description: 'Blocker 2', status: 'open', created_at: '2025-01-14T11:00:00Z' },
 		];
-
-		const supabase = createMockSupabase({
-			selectResult: { data: mockBlockers, error: null },
+		mockApiClient.getBlockers.mockResolvedValue({
+			ok: true,
+			data: { blockers: mockBlockers },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await getBlockers(
 			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
@@ -256,62 +247,67 @@ describe('getBlockers', () => {
 		expect((result.result as { blockers: unknown[] }).blockers).toHaveLength(2);
 	});
 
-	it('should filter by status (default: open)', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+	it('should pass status parameter to API (default: open)', async () => {
+		mockApiClient.getBlockers.mockResolvedValue({
+			ok: true,
+			data: { blockers: [] },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await getBlockers(
 			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
 			ctx
 		);
 
-		expect(supabase.eq).toHaveBeenCalledWith('status', 'open');
+		expect(mockApiClient.getBlockers).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			expect.objectContaining({ status: 'open' })
+		);
 	});
 
-	it('should filter by custom status', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+	it('should pass custom status to API', async () => {
+		mockApiClient.getBlockers.mockResolvedValue({
+			ok: true,
+			data: { blockers: [] },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await getBlockers(
 			{ project_id: '123e4567-e89b-12d3-a456-426614174000', status: 'resolved' },
 			ctx
 		);
 
-		expect(supabase.eq).toHaveBeenCalledWith('status', 'resolved');
+		expect(mockApiClient.getBlockers).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			expect.objectContaining({ status: 'resolved' })
+		);
 	});
 
-	it('should query blockers table', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+	it('should call API client getBlockers', async () => {
+		mockApiClient.getBlockers.mockResolvedValue({
+			ok: true,
+			data: { blockers: [] },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await getBlockers(
 			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
 			ctx
 		);
 
-		expect(supabase.from).toHaveBeenCalledWith('blockers');
+		expect(mockApiClient.getBlockers).toHaveBeenCalled();
 	});
 
-	it('should throw error when query fails', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
-		// Override to return error
-		vi.mocked(supabase.from('').select).mockReturnValue({
-			...supabase,
-			then: (resolve: (val: unknown) => void) =>
-				Promise.resolve({ data: null, error: { message: 'Query failed' } }).then(resolve),
-		} as unknown as ReturnType<SupabaseClient['from']>);
+	it('should throw error when API call fails', async () => {
+		mockApiClient.getBlockers.mockResolvedValue({
+			ok: false,
+			error: 'Query failed',
+		});
+		const ctx = createMockContext();
 
 		await expect(
 			getBlockers({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
-		).rejects.toThrow('Failed to fetch blockers');
+		).rejects.toThrow('Query failed');
 	});
 });
 
@@ -323,15 +319,13 @@ describe('deleteBlocker', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing blocker_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(deleteBlocker({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for invalid blocker_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			deleteBlocker({ blocker_id: 'invalid' }, ctx)
@@ -339,10 +333,11 @@ describe('deleteBlocker', () => {
 	});
 
 	it('should delete blocker successfully', async () => {
-		const supabase = createMockSupabase({
-			deleteResult: { data: null, error: null },
+		mockApiClient.deleteBlocker.mockResolvedValue({
+			ok: true,
+			data: { success: true },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await deleteBlocker(
 			{ blocker_id: '123e4567-e89b-12d3-a456-426614174000' },
@@ -354,37 +349,32 @@ describe('deleteBlocker', () => {
 		});
 	});
 
-	it('should call delete on blockers table', async () => {
-		const supabase = createMockSupabase({
-			deleteResult: { data: null, error: null },
+	it('should call API client deleteBlocker', async () => {
+		mockApiClient.deleteBlocker.mockResolvedValue({
+			ok: true,
+			data: { success: true },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await deleteBlocker(
 			{ blocker_id: '123e4567-e89b-12d3-a456-426614174000' },
 			ctx
 		);
 
-		expect(supabase.from).toHaveBeenCalledWith('blockers');
-		expect(supabase.delete).toHaveBeenCalled();
-		expect(supabase.eq).toHaveBeenCalledWith('id', '123e4567-e89b-12d3-a456-426614174000');
+		expect(mockApiClient.deleteBlocker).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000'
+		);
 	});
 
-	it('should throw error when delete fails', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
-		// Override delete to return error
-		vi.mocked(supabase.from('').delete).mockReturnValue({
-			...supabase,
-			eq: vi.fn().mockReturnValue({
-				then: (resolve: (val: unknown) => void) =>
-					Promise.resolve({ data: null, error: { message: 'Delete failed' } }).then(resolve),
-			}),
-		} as unknown as ReturnType<SupabaseClient['from']>);
+	it('should throw error when API call fails', async () => {
+		mockApiClient.deleteBlocker.mockResolvedValue({
+			ok: false,
+			error: 'Delete failed',
+		});
+		const ctx = createMockContext();
 
 		await expect(
 			deleteBlocker({ blocker_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
-		).rejects.toThrow('Failed to delete blocker');
+		).rejects.toThrow('Delete failed');
 	});
 });