@vibescope/mcp-server 0.0.1 → 0.2.0

package/src/handlers/findings.test.ts

@@ -1,116 +1,14 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { SupabaseClient } from '@supabase/supabase-js';
-import type { HandlerContext, TokenUsage } from './types.js';
 import {
 	addFinding,
 	getFindings,
+	getFindingsStats,
 	updateFinding,
 	deleteFinding,
 } from './findings.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(),
-		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);
-		}),
-		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(),
-	};
-}
+import { createMockContext } from './__test-utils__.js';
+import { mockApiClient } from './__test-setup__.js';
 
 const VALID_UUID = '123e4567-e89b-12d3-a456-426614174000';
 const VALID_UUID_2 = '223e4567-e89b-12d3-a456-426614174001';
@@ -123,15 +21,13 @@ describe('addFinding', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(addFinding({ title: 'Test Finding' }, 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(
 			addFinding({ project_id: 'invalid', title: 'Test' }, ctx)
@@ -139,8 +35,7 @@ describe('addFinding', () => {
 	});
 
 	it('should throw error for missing title', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			addFinding({ project_id: VALID_UUID }, ctx)
@@ -148,19 +43,19 @@ describe('addFinding', () => {
 	});
 
 	it('should throw error for invalid related_task_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			addFinding({ project_id: VALID_UUID, title: 'Test', related_task_id: 'invalid' }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
-	it('should create finding with required fields and defaults', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: { id: 'finding-1' }, error: null },
+	it('should create finding with required fields', async () => {
+		mockApiClient.addFinding.mockResolvedValue({
+			ok: true,
+			data: { success: true, finding_id: 'finding-1', title: 'Performance issue' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await addFinding(
 			{ project_id: VALID_UUID, title: 'Performance issue' },
@@ -172,27 +67,14 @@ describe('addFinding', () => {
 			finding_id: 'finding-1',
 			title: 'Performance issue',
 		});
-		expect(supabase.from).toHaveBeenCalledWith('findings');
-		expect(supabase.insert).toHaveBeenCalledWith(
-			expect.objectContaining({
-				project_id: VALID_UUID,
-				title: 'Performance issue',
-				category: 'other',
-				severity: 'info',
-				description: null,
-				file_path: null,
-				line_number: null,
-				related_task_id: null,
-				created_by: 'agent',
-			})
-		);
 	});
 
-	it('should create finding with all optional fields', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: { id: 'finding-2' }, error: null },
+	it('should call API client with all parameters', async () => {
+		mockApiClient.addFinding.mockResolvedValue({
+			ok: true,
+			data: { success: true, finding_id: 'finding-2' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext({ sessionId: 'my-session' });
 
 		await addFinding(
 			{
@@ -208,8 +90,9 @@ describe('addFinding', () => {
 			ctx
 		);
 
-		expect(supabase.insert).toHaveBeenCalledWith(
-			expect.objectContaining({
+		expect(mockApiClient.addFinding).toHaveBeenCalledWith(
+			VALID_UUID,
+			{
 				title: 'SQL Injection vulnerability',
 				description: 'User input not sanitized',
 				category: 'security',
@@ -217,19 +100,21 @@ describe('addFinding', () => {
 				file_path: 'src/api/users.ts',
 				line_number: 42,
 				related_task_id: VALID_UUID_2,
-			})
+			},
+			'my-session'
 		);
 	});
 
-	it('should throw error when database insert fails', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: null, error: { message: 'Insert failed' } },
+	it('should throw error when API call fails', async () => {
+		mockApiClient.addFinding.mockResolvedValue({
+			ok: false,
+			error: 'Insert failed',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			addFinding({ project_id: VALID_UUID, title: 'Test' }, ctx)
-		).rejects.toThrow('Failed to add finding');
+		).rejects.toThrow('Insert failed');
 	});
 });
 
@@ -241,15 +126,13 @@ describe('getFindings', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(getFindings({}, 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(
 			getFindings({ project_id: 'invalid' }, ctx)
@@ -261,83 +144,130 @@ describe('getFindings', () => {
 			{ id: 'f1', title: 'Finding 1', category: 'security', severity: 'high', status: 'open', file_path: null, created_at: '2026-01-14' },
 			{ id: 'f2', title: 'Finding 2', category: 'performance', severity: 'medium', status: 'addressed', file_path: 'src/app.ts', created_at: '2026-01-13' },
 		];
-
-		const supabase = createMockSupabase({
-			selectResult: { data: mockFindings, error: null },
+		mockApiClient.getFindings.mockResolvedValue({
+			ok: true,
+			data: { findings: mockFindings },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await getFindings({ project_id: VALID_UUID }, ctx);
 
 		expect(result.result).toMatchObject({ findings: mockFindings });
-		expect(supabase.from).toHaveBeenCalledWith('findings');
-		expect(supabase.eq).toHaveBeenCalledWith('project_id', VALID_UUID);
 	});
 
-	it('should filter by category when provided', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+	it('should pass filters to API client', async () => {
+		mockApiClient.getFindings.mockResolvedValue({
+			ok: true,
+			data: { findings: [] },
 		});
-		const ctx = createMockContext(supabase);
-
-		await getFindings({ project_id: VALID_UUID, category: 'security' }, ctx);
-
-		expect(supabase.eq).toHaveBeenCalledWith('category', 'security');
+		const ctx = createMockContext();
+
+		await getFindings({
+			project_id: VALID_UUID,
+			category: 'security',
+			severity: 'critical',
+			status: 'open',
+			limit: 10
+		}, ctx);
+
+		expect(mockApiClient.getFindings).toHaveBeenCalledWith(
+			VALID_UUID,
+			expect.objectContaining({
+				category: 'security',
+				severity: 'critical',
+				status: 'open',
+				limit: 10,
+			})
+		);
 	});
 
-	it('should filter by severity when provided', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+	it('should pass summary_only parameter to API client', async () => {
+		mockApiClient.getFindings.mockResolvedValue({
+			ok: true,
+			data: { findings: [], total_count: 0, has_more: false },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
-		await getFindings({ project_id: VALID_UUID, severity: 'critical' }, ctx);
+		await getFindings({
+			project_id: VALID_UUID,
+			summary_only: true
+		}, ctx);
 
-		expect(supabase.eq).toHaveBeenCalledWith('severity', 'critical');
+		expect(mockApiClient.getFindings).toHaveBeenCalledWith(
+			VALID_UUID,
+			expect.objectContaining({
+				summary_only: true,
+			})
+		);
 	});
 
-	it('should filter by status when provided', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+	it('should pass search_query parameter to API client', async () => {
+		mockApiClient.getFindings.mockResolvedValue({
+			ok: true,
+			data: { findings: [], total_count: 0, has_more: false },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
-		await getFindings({ project_id: VALID_UUID, status: 'open' }, ctx);
+		await getFindings({
+			project_id: VALID_UUID,
+			search_query: 'security'
+		}, ctx);
 
-		expect(supabase.eq).toHaveBeenCalledWith('status', 'open');
+		expect(mockApiClient.getFindings).toHaveBeenCalledWith(
+			VALID_UUID,
+			expect.objectContaining({
+				search_query: 'security',
+			})
+		);
 	});
 
-	it('should use custom limit when provided', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+	it('should pass offset parameter to API client', async () => {
+		mockApiClient.getFindings.mockResolvedValue({
+			ok: true,
+			data: { findings: [], total_count: 100, has_more: true },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
-		await getFindings({ project_id: VALID_UUID, limit: 10 }, ctx);
+		await getFindings({
+			project_id: VALID_UUID,
+			offset: 50,
+			limit: 25
+		}, ctx);
 
-		expect(supabase.limit).toHaveBeenCalledWith(10);
+		expect(mockApiClient.getFindings).toHaveBeenCalledWith(
+			VALID_UUID,
+			expect.objectContaining({
+				offset: 50,
+				limit: 25,
+			})
+		);
 	});
 
 	it('should use default limit of 50', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+		mockApiClient.getFindings.mockResolvedValue({
+			ok: true,
+			data: { findings: [] },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await getFindings({ project_id: VALID_UUID }, ctx);
 
-		expect(supabase.limit).toHaveBeenCalledWith(50);
+		expect(mockApiClient.getFindings).toHaveBeenCalledWith(
+			VALID_UUID,
+			expect.objectContaining({ limit: 50 })
+		);
 	});
 
-	it('should throw error when database query fails', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: { message: 'Query failed' } },
+	it('should throw error when API call fails', async () => {
+		mockApiClient.getFindings.mockResolvedValue({
+			ok: false,
+			error: 'Query failed',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			getFindings({ project_id: VALID_UUID }, ctx)
-		).rejects.toThrow('Failed to get findings');
+		).rejects.toThrow('Query failed');
 	});
 });
 
@@ -349,15 +279,13 @@ describe('updateFinding', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing finding_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(updateFinding({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for invalid finding_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			updateFinding({ finding_id: 'invalid' }, ctx)
@@ -365,10 +293,11 @@ describe('updateFinding', () => {
 	});
 
 	it('should update title', async () => {
-		const supabase = createMockSupabase({
-			updateResult: { data: null, error: null },
+		mockApiClient.updateFinding.mockResolvedValue({
+			ok: true,
+			data: { success: true, finding_id: VALID_UUID },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await updateFinding(
 			{ finding_id: VALID_UUID, title: 'Updated Title' },
@@ -376,190 +305,170 @@ describe('updateFinding', () => {
 		);
 
 		expect(result.result).toMatchObject({ success: true, finding_id: VALID_UUID });
-		expect(supabase.update).toHaveBeenCalledWith(
-			expect.objectContaining({ title: 'Updated Title' })
-		);
-	});
-
-	it('should update severity', async () => {
-		const supabase = createMockSupabase({
-			updateResult: { data: null, error: null },
-		});
-		const ctx = createMockContext(supabase);
-
-		await updateFinding(
-			{ finding_id: VALID_UUID, severity: 'high' },
-			ctx
-		);
-
-		expect(supabase.update).toHaveBeenCalledWith(
-			expect.objectContaining({ severity: 'high' })
-		);
 	});
 
-	it('should set addressed_at when status changed to addressed', async () => {
-		const supabase = createMockSupabase({
-			updateResult: { data: null, error: null },
+	it('should call API client with all update fields', async () => {
+		mockApiClient.updateFinding.mockResolvedValue({
+			ok: true,
+			data: { success: true },
 		});
-		const ctx = createMockContext(supabase, { sessionId: 'resolver-session' });
+		const ctx = createMockContext();
 
 		await updateFinding(
-			{ finding_id: VALID_UUID, status: 'addressed' },
+			{
+				finding_id: VALID_UUID,
+				title: 'New Title',
+				description: 'New description',
+				severity: 'high',
+				status: 'addressed',
+				resolution_note: 'Fixed by sanitizing input'
+			},
 			ctx
 		);
 
-		expect(supabase.update).toHaveBeenCalledWith(
-			expect.objectContaining({
+		expect(mockApiClient.updateFinding).toHaveBeenCalledWith(
+			VALID_UUID,
+			{
+				title: 'New Title',
+				description: 'New description',
+				severity: 'high',
 				status: 'addressed',
-				addressed_at: expect.any(String),
-				addressed_by_session_id: 'resolver-session',
-			})
+				resolution_note: 'Fixed by sanitizing input',
+			}
 		);
 	});
 
-	it('should set addressed_at when status changed to dismissed', async () => {
-		const supabase = createMockSupabase({
-			updateResult: { data: null, error: null },
+	it('should throw error when API call fails', async () => {
+		mockApiClient.updateFinding.mockResolvedValue({
+			ok: false,
+			error: 'Update failed',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
-		await updateFinding(
-			{ finding_id: VALID_UUID, status: 'dismissed' },
-			ctx
-		);
-
-		expect(supabase.update).toHaveBeenCalledWith(
-			expect.objectContaining({
-				status: 'dismissed',
-				addressed_at: expect.any(String),
-			})
-		);
+		await expect(
+			updateFinding({ finding_id: VALID_UUID, title: 'Test' }, ctx)
+		).rejects.toThrow('Update failed');
 	});
+});
 
-	it('should set addressed_at when status changed to wontfix', async () => {
-		const supabase = createMockSupabase({
-			updateResult: { data: null, error: null },
-		});
-		const ctx = createMockContext(supabase);
+// ============================================================================
+// deleteFinding Tests
+// ============================================================================
 
-		await updateFinding(
-			{ finding_id: VALID_UUID, status: 'wontfix' },
-			ctx
-		);
+describe('deleteFinding', () => {
+	beforeEach(() => vi.clearAllMocks());
 
-		expect(supabase.update).toHaveBeenCalledWith(
-			expect.objectContaining({
-				status: 'wontfix',
-				addressed_at: expect.any(String),
-			})
-		);
-	});
+	it('should throw error for missing finding_id', async () => {
+		const ctx = createMockContext();
 
-	it('should not set addressed_at when status changed to open', async () => {
-		const supabase = createMockSupabase({
-			updateResult: { data: null, error: null },
-		});
-		const ctx = createMockContext(supabase);
+		await expect(deleteFinding({}, ctx)).rejects.toThrow(ValidationError);
+	});
 
-		await updateFinding(
-			{ finding_id: VALID_UUID, status: 'open' },
-			ctx
-		);
+	it('should throw error for invalid finding_id UUID', async () => {
+		const ctx = createMockContext();
 
-		const updateCall = vi.mocked(supabase.update).mock.calls[0][0] as Record<string, unknown>;
-		expect(updateCall.status).toBe('open');
-		expect(updateCall.addressed_at).toBeUndefined();
+		await expect(
+			deleteFinding({ finding_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
 	});
 
-	it('should update resolution_note', async () => {
-		const supabase = createMockSupabase({
-			updateResult: { data: null, error: null },
+	it('should delete finding successfully', async () => {
+		mockApiClient.deleteFinding.mockResolvedValue({
+			ok: true,
+			data: { success: true },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
-		await updateFinding(
-			{ finding_id: VALID_UUID, resolution_note: 'Fixed by sanitizing input' },
-			ctx
-		);
+		const result = await deleteFinding({ finding_id: VALID_UUID }, ctx);
 
-		expect(supabase.update).toHaveBeenCalledWith(
-			expect.objectContaining({ resolution_note: 'Fixed by sanitizing input' })
-		);
+		expect(result.result).toMatchObject({ success: true });
 	});
 
-	it('should always update updated_at timestamp', async () => {
-		const supabase = createMockSupabase({
-			updateResult: { data: null, error: null },
+	it('should call API client deleteFinding', async () => {
+		mockApiClient.deleteFinding.mockResolvedValue({
+			ok: true,
+			data: { success: true },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
-		await updateFinding(
-			{ finding_id: VALID_UUID, title: 'Test' },
-			ctx
-		);
+		await deleteFinding({ finding_id: VALID_UUID }, ctx);
 
-		expect(supabase.update).toHaveBeenCalledWith(
-			expect.objectContaining({ updated_at: expect.any(String) })
-		);
+		expect(mockApiClient.deleteFinding).toHaveBeenCalledWith(VALID_UUID);
 	});
 
-	it('should throw error when database update fails', async () => {
-		const supabase = createMockSupabase({
-			updateResult: { data: null, error: { message: 'Update failed' } },
+	it('should throw error when API call fails', async () => {
+		mockApiClient.deleteFinding.mockResolvedValue({
+			ok: false,
+			error: 'Delete failed',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
-			updateFinding({ finding_id: VALID_UUID, title: 'Test' }, ctx)
-		).rejects.toThrow('Failed to update finding');
+			deleteFinding({ finding_id: VALID_UUID }, ctx)
+		).rejects.toThrow('Delete failed');
 	});
 });
 
 // ============================================================================
-// deleteFinding Tests
+// getFindingsStats Tests
 // ============================================================================
 
-describe('deleteFinding', () => {
+describe('getFindingsStats', () => {
 	beforeEach(() => vi.clearAllMocks());
 
-	it('should throw error for missing finding_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+	it('should throw error for missing project_id', async () => {
+		const ctx = createMockContext();
 
-		await expect(deleteFinding({}, ctx)).rejects.toThrow(ValidationError);
+		await expect(getFindingsStats({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
-	it('should throw error for invalid finding_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+	it('should throw error for invalid project_id UUID', async () => {
+		const ctx = createMockContext();
 
 		await expect(
-			deleteFinding({ finding_id: 'invalid' }, ctx)
+			getFindingsStats({ project_id: 'invalid' }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
-	it('should delete finding successfully', async () => {
-		const supabase = createMockSupabase({
-			deleteResult: { data: null, error: null },
+	it('should return findings stats for project', async () => {
+		const mockStats = {
+			total: 10,
+			by_status: { open: 5, addressed: 3, dismissed: 2 },
+			by_severity: { critical: 1, high: 3, medium: 4, low: 2 },
+			by_category: { security: 3, performance: 4, code_quality: 3 },
+		};
+		mockApiClient.getFindingsStats.mockResolvedValue({
+			ok: true,
+			data: mockStats,
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
-		const result = await deleteFinding({ finding_id: VALID_UUID }, ctx);
+		const result = await getFindingsStats({ project_id: VALID_UUID }, ctx);
 
-		expect(result.result).toMatchObject({ success: true });
-		expect(supabase.from).toHaveBeenCalledWith('findings');
-		expect(supabase.delete).toHaveBeenCalled();
-		expect(supabase.eq).toHaveBeenCalledWith('id', VALID_UUID);
+		expect(result.result).toMatchObject(mockStats);
 	});
 
-	it('should throw error when database delete fails', async () => {
-		const supabase = createMockSupabase({
-			deleteResult: { data: null, error: { message: 'Delete failed' } },
+	it('should call API client getFindingsStats with project_id', async () => {
+		mockApiClient.getFindingsStats.mockResolvedValue({
+			ok: true,
+			data: { total: 0, by_status: {}, by_severity: {}, by_category: {} },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
+
+		await getFindingsStats({ project_id: VALID_UUID }, ctx);
+
+		expect(mockApiClient.getFindingsStats).toHaveBeenCalledWith(VALID_UUID);
+	});
+
+	it('should throw error when API call fails', async () => {
+		mockApiClient.getFindingsStats.mockResolvedValue({
+			ok: false,
+			error: 'Query failed',
+		});
+		const ctx = createMockContext();
 
 		await expect(
-			deleteFinding({ finding_id: VALID_UUID }, ctx)
-		).rejects.toThrow('Failed to delete finding');
+			getFindingsStats({ project_id: VALID_UUID }, ctx)
+		).rejects.toThrow('Query failed');
 	});
 });