@vibescope/mcp-server 0.0.1

package/src/handlers/fallback.test.ts

@@ -0,0 +1,687 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { SupabaseClient } from '@supabase/supabase-js';
+import type { HandlerContext, TokenUsage } from './types.js';
+import {
+	startFallbackActivity,
+	stopFallbackActivity,
+	getActivityHistory,
+	getActivitySchedules,
+} from './fallback.js';
+import { ValidationError } from '../validators.js';
+
+// ============================================================================
+// Test Utilities
+// ============================================================================
+
+function createMockSupabase(overrides: {
+	selectResult?: { data: unknown; error: unknown };
+	insertResult?: { data: unknown; error: unknown };
+	updateResult?: { data: unknown; error: unknown };
+	deleteResult?: { 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(),
+		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 (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);
+			}
+			if (currentOperation === 'delete') {
+				return Promise.resolve(overrides.deleteResult ?? 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(),
+	};
+}
+
+// ============================================================================
+// startFallbackActivity Tests
+// ============================================================================
+
+describe('startFallbackActivity', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			startFallbackActivity({ activity: 'code_review' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			startFallbackActivity({ project_id: 'invalid', activity: 'code_review' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for missing activity', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			startFallbackActivity({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid activity type', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			startFallbackActivity({
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				activity: 'invalid_activity',
+			}, ctx)
+		).rejects.toThrow('Invalid activity');
+	});
+
+	it('should start fallback activity successfully', async () => {
+		const supabase = createMockSupabase({
+			updateResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await startFallbackActivity(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				activity: 'code_review',
+			},
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			activity: 'code_review',
+		});
+		expect((result.result as { title: string }).title).toBeDefined();
+	});
+
+	it('should update agent_sessions with fallback activity', async () => {
+		const supabase = createMockSupabase({
+			updateResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase, { sessionId: 'my-session' });
+
+		await startFallbackActivity(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				activity: 'security_review',
+			},
+			ctx
+		);
+
+		expect(supabase.from).toHaveBeenCalledWith('agent_sessions');
+		expect(supabase.update).toHaveBeenCalledWith(
+			expect.objectContaining({
+				current_fallback_activity: 'security_review',
+				current_task_id: null,
+				status: 'active',
+			})
+		);
+		expect(supabase.eq).toHaveBeenCalledWith('id', 'my-session');
+	});
+
+	it('should accept all valid activity types', async () => {
+		const validActivities = [
+			'feature_ideation',
+			'code_review',
+			'performance_audit',
+			'ux_review',
+			'cost_analysis',
+			'security_review',
+			'test_coverage',
+			'documentation_review',
+			'dependency_audit',
+			'validate_completed_tasks',
+		];
+
+		for (const activity of validActivities) {
+			const supabase = createMockSupabase({
+				updateResult: { data: null, error: null },
+			});
+			const ctx = createMockContext(supabase);
+
+			const result = await startFallbackActivity(
+				{
+					project_id: '123e4567-e89b-12d3-a456-426614174000',
+					activity,
+				},
+				ctx
+			);
+
+			expect(result.result).toMatchObject({
+				success: true,
+				activity,
+			});
+		}
+	});
+
+	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']>);
+
+		await expect(
+			startFallbackActivity({
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				activity: 'code_review',
+			}, ctx)
+		).rejects.toThrow();
+	});
+});
+
+// ============================================================================
+// stopFallbackActivity Tests
+// ============================================================================
+
+describe('stopFallbackActivity', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(stopFallbackActivity({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			stopFallbackActivity({ project_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should stop fallback activity successfully when activity exists', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: { current_fallback_activity: 'code_review' }, error: null },
+			insertResult: { data: null, error: null },
+			updateResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await stopFallbackActivity(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+		});
+		expect((result.result as { message: string }).message).toContain('code_review');
+	});
+
+	it('should stop fallback activity when no activity was active', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: { current_fallback_activity: null }, error: null },
+			updateResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await stopFallbackActivity(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			message: 'Fallback activity stopped',
+		});
+	});
+
+	it('should include summary in history when provided', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: { current_fallback_activity: 'code_review' }, error: null },
+			insertResult: { data: null, error: null },
+			updateResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await stopFallbackActivity(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				summary: 'Reviewed 5 files, found 3 issues',
+			},
+			ctx
+		);
+
+		expect(supabase.from).toHaveBeenCalledWith('background_activity_history');
+		expect(supabase.insert).toHaveBeenCalledWith(
+			expect.objectContaining({
+				summary: 'Reviewed 5 files, found 3 issues',
+			})
+		);
+	});
+
+	it('should clear session fallback activity', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: { current_fallback_activity: null }, error: null },
+			updateResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase, { sessionId: 'my-session' });
+
+		await stopFallbackActivity(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(supabase.update).toHaveBeenCalledWith(
+			expect.objectContaining({
+				current_fallback_activity: null,
+				status: 'idle',
+			})
+		);
+	});
+});
+
+// ============================================================================
+// getActivityHistory Tests
+// ============================================================================
+
+describe('getActivityHistory', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(getActivityHistory({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			getActivityHistory({ project_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should return empty history when no activities', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: [], error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await getActivityHistory(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			history: [],
+			count: 0,
+		});
+	});
+
+	it('should return activity history', async () => {
+		const mockHistory = [
+			{
+				id: 'h1',
+				activity_type: 'code_review',
+				completed_at: '2025-01-14T10:00:00Z',
+				summary: 'Reviewed auth module',
+				agent_sessions: { agent_name: 'Wave' },
+			},
+			{
+				id: 'h2',
+				activity_type: 'security_review',
+				completed_at: '2025-01-14T09:00:00Z',
+				summary: null,
+				agent_sessions: { agent_name: 'Glitch' },
+			},
+		];
+
+		const supabase = createMockSupabase({
+			selectResult: { data: mockHistory, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await getActivityHistory(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect((result.result as { history: unknown[] }).history).toHaveLength(2);
+		expect((result.result as { count: number }).count).toBe(2);
+	});
+
+	it('should include latest_by_type in response', async () => {
+		const mockHistory = [
+			{
+				id: 'h1',
+				activity_type: 'code_review',
+				completed_at: '2025-01-14T10:00:00Z',
+				agent_sessions: null,
+			},
+			{
+				id: 'h2',
+				activity_type: 'code_review',
+				completed_at: '2025-01-14T09:00:00Z',
+				agent_sessions: null,
+			},
+		];
+
+		const supabase = createMockSupabase({
+			selectResult: { data: mockHistory, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await getActivityHistory(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		const latestByType = (result.result as { latest_by_type: Record<string, unknown> }).latest_by_type;
+		expect(latestByType['code_review']).toBeDefined();
+		expect((latestByType['code_review'] as { id: string }).id).toBe('h1');
+	});
+
+	it('should filter by activity_type when provided', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: [], error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await getActivityHistory(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				activity_type: 'security_review',
+			},
+			ctx
+		);
+
+		expect(supabase.eq).toHaveBeenCalledWith('activity_type', 'security_review');
+	});
+
+	it('should respect limit parameter', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: [], error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await getActivityHistory(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				limit: 10,
+			},
+			ctx
+		);
+
+		expect(supabase.limit).toHaveBeenCalledWith(10);
+	});
+
+	it('should query background_activity_history table', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: [], error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await getActivityHistory(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(supabase.from).toHaveBeenCalledWith('background_activity_history');
+	});
+});
+
+// ============================================================================
+// getActivitySchedules Tests
+// ============================================================================
+
+describe('getActivitySchedules', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(getActivitySchedules({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			getActivitySchedules({ project_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should return empty schedules when none exist', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: [], error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await getActivitySchedules(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			schedules: [],
+			due_activities: [],
+			count: 0,
+		});
+	});
+
+	it('should return activity schedules', async () => {
+		const mockSchedules = [
+			{
+				id: 's1',
+				activity_type: 'code_review',
+				schedule_type: 'weekly',
+				enabled: true,
+				next_run_at: '2025-01-20T10:00:00Z',
+			},
+			{
+				id: 's2',
+				activity_type: 'security_review',
+				schedule_type: 'monthly',
+				enabled: true,
+				next_run_at: '2025-02-14T10:00:00Z',
+			},
+		];
+
+		const supabase = createMockSupabase({
+			selectResult: { data: mockSchedules, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await getActivitySchedules(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect((result.result as { schedules: unknown[] }).schedules).toHaveLength(2);
+		expect((result.result as { count: number }).count).toBe(2);
+	});
+
+	it('should identify due activities', async () => {
+		const pastDate = new Date(Date.now() - 3600000).toISOString(); // 1 hour ago
+		const futureDate = new Date(Date.now() + 3600000).toISOString(); // 1 hour from now
+
+		const mockSchedules = [
+			{
+				id: 's1',
+				activity_type: 'code_review',
+				enabled: true,
+				next_run_at: pastDate, // Due
+			},
+			{
+				id: 's2',
+				activity_type: 'security_review',
+				enabled: true,
+				next_run_at: futureDate, // Not due
+			},
+			{
+				id: 's3',
+				activity_type: 'test_coverage',
+				enabled: false, // Disabled
+				next_run_at: pastDate,
+			},
+		];
+
+		const supabase = createMockSupabase({
+			selectResult: { data: mockSchedules, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await getActivitySchedules(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		const dueActivities = (result.result as { due_activities: string[] }).due_activities;
+		expect(dueActivities).toContain('code_review');
+		expect(dueActivities).not.toContain('security_review');
+		expect(dueActivities).not.toContain('test_coverage');
+	});
+
+	it('should query background_activity_schedules table', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: [], error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await getActivitySchedules(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(supabase.from).toHaveBeenCalledWith('background_activity_schedules');
+	});
+
+	it('should order schedules by activity_type', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: [], error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await getActivitySchedules(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(supabase.order).toHaveBeenCalledWith('activity_type');
+	});
+
+	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']>);
+
+		await expect(
+			getActivitySchedules({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+		).rejects.toThrow();
+	});
+});