@vibescope/mcp-server 0.0.1 → 0.1.0

package/src/handlers/cost.test.ts

@@ -11,7 +11,10 @@ import {
 	deleteCostAlert,
 	getTaskCosts,
 } from './cost.js';
-import { createMockSupabase, createMockContext, testUUID } from './__test-utils__.js';
+import { createMockContext } from './__test-utils__.js';
+import { mockApiClient } from './__test-setup__.js';
+
+const VALID_UUID = '123e4567-e89b-12d3-a456-426614174000';
 
 describe('Cost Handlers', () => {
 	beforeEach(() => {
@@ -24,8 +27,7 @@ describe('Cost Handlers', () => {
 
 	describe('getCostSummary', () => {
 		it('should return error when project_id is missing', async () => {
-			const supabase = createMockSupabase();
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
 			const result = await getCostSummary({}, ctx);
 
@@ -50,13 +52,22 @@ describe('Cost Handlers', () => {
 					estimated_cost_usd: '0.30',
 				},
 			];
-
-			const supabase = createMockSupabase({
-				selectResult: { data: mockData, error: null },
+			mockApiClient.getCostSummary.mockResolvedValue({
+				ok: true,
+				data: {
+					period: 'daily',
+					summary: mockData,
+					totals: {
+						sessions: 8,
+						tokens: 16000,
+						calls: 80,
+						cost: 0.8,
+					},
+				},
 			});
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
-			const result = await getCostSummary({ project_id: testUUID() }, ctx);
+			const result = await getCostSummary({ project_id: VALID_UUID }, ctx);
 
 			expect(result.isError).toBeUndefined();
 			expect(result.result.period).toBe('daily');
@@ -70,45 +81,54 @@ describe('Cost Handlers', () => {
 		});
 
 		it('should handle weekly period', async () => {
-			const supabase = createMockSupabase({
-				selectResult: { data: [], error: null },
+			mockApiClient.getCostSummary.mockResolvedValue({
+				ok: true,
+				data: { period: 'weekly', summary: [], totals: { sessions: 0, tokens: 0, calls: 0, cost: 0 } },
 			});
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
 			const result = await getCostSummary(
-				{ project_id: testUUID(), period: 'weekly' },
+				{ project_id: VALID_UUID, period: 'weekly' },
 				ctx
 			);
 
 			expect(result.result.period).toBe('weekly');
-			expect(supabase.from).toHaveBeenCalledWith('weekly_cost_summary');
+			expect(mockApiClient.getCostSummary).toHaveBeenCalledWith(
+				VALID_UUID,
+				expect.objectContaining({ period: 'weekly' })
+			);
 		});
 
 		it('should handle monthly period', async () => {
-			const supabase = createMockSupabase({
-				selectResult: { data: [], error: null },
+			mockApiClient.getCostSummary.mockResolvedValue({
+				ok: true,
+				data: { period: 'monthly', summary: [], totals: { sessions: 0, tokens: 0, calls: 0, cost: 0 } },
 			});
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
 			const result = await getCostSummary(
-				{ project_id: testUUID(), period: 'monthly' },
+				{ project_id: VALID_UUID, period: 'monthly' },
 				ctx
 			);
 
 			expect(result.result.period).toBe('monthly');
-			expect(supabase.from).toHaveBeenCalledWith('monthly_cost_summary');
+			expect(mockApiClient.getCostSummary).toHaveBeenCalledWith(
+				VALID_UUID,
+				expect.objectContaining({ period: 'monthly' })
+			);
 		});
 
-		it('should return error on database failure', async () => {
-			const supabase = createMockSupabase({
-				selectResult: { data: null, error: { message: 'Database error' } },
+		it('should return error on API failure', async () => {
+			mockApiClient.getCostSummary.mockResolvedValue({
+				ok: false,
+				error: 'Database error',
 			});
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
-			const result = await getCostSummary({ project_id: testUUID() }, ctx);
+			const result = await getCostSummary({ project_id: VALID_UUID }, ctx);
 
 			expect(result.isError).toBe(true);
-			expect(result.result.error).toContain('Failed to get cost summary');
+			expect(result.result.error).toBe('Database error');
 		});
 	});
 
@@ -122,11 +142,11 @@ describe('Cost Handlers', () => {
 				{ id: 'alert-1', threshold_amount: 10, threshold_period: 'daily' },
 				{ id: 'alert-2', threshold_amount: 50, threshold_period: 'weekly' },
 			];
-
-			const supabase = createMockSupabase({
-				selectResult: { data: mockAlerts, error: null },
+			mockApiClient.getCostAlerts.mockResolvedValue({
+				ok: true,
+				data: { alerts: mockAlerts, count: 2 },
 			});
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
 			const result = await getCostAlerts({}, ctx);
 
@@ -134,27 +154,29 @@ describe('Cost Handlers', () => {
 			expect(result.result.count).toBe(2);
 		});
 
-		it('should filter by project_id when provided', async () => {
-			const supabase = createMockSupabase({
-				selectResult: { data: [], error: null },
+		it('should call getCostAlerts with no args (project filtering done server-side)', async () => {
+			mockApiClient.getCostAlerts.mockResolvedValue({
+				ok: true,
+				data: { alerts: [], count: 0 },
 			});
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
-			await getCostAlerts({ project_id: testUUID() }, ctx);
+			await getCostAlerts({ project_id: VALID_UUID }, ctx);
 
-			expect(supabase.eq).toHaveBeenCalledWith('project_id', testUUID());
+			expect(mockApiClient.getCostAlerts).toHaveBeenCalledWith();
 		});
 
-		it('should return error on database failure', async () => {
-			const supabase = createMockSupabase({
-				selectResult: { data: null, error: { message: 'Query failed' } },
+		it('should return error on API failure', async () => {
+			mockApiClient.getCostAlerts.mockResolvedValue({
+				ok: false,
+				error: 'Query failed',
 			});
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
 			const result = await getCostAlerts({}, ctx);
 
 			expect(result.isError).toBe(true);
-			expect(result.result.error).toContain('Failed to get cost alerts');
+			expect(result.result.error).toBe('Query failed');
 		});
 	});
 
@@ -164,8 +186,7 @@ describe('Cost Handlers', () => {
 
 	describe('addCostAlert', () => {
 		it('should return error when threshold_amount is missing', async () => {
-			const supabase = createMockSupabase();
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
 			const result = await addCostAlert(
 				{ threshold_period: 'daily' },
@@ -177,8 +198,7 @@ describe('Cost Handlers', () => {
 		});
 
 		it('should return error when threshold_amount is not positive', async () => {
-			const supabase = createMockSupabase();
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
 			const result = await addCostAlert(
 				{ threshold_amount: -5, threshold_period: 'daily' },
@@ -190,8 +210,7 @@ describe('Cost Handlers', () => {
 		});
 
 		it('should return error when threshold_period is invalid', async () => {
-			const supabase = createMockSupabase();
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
 			const result = await addCostAlert(
 				{ threshold_amount: 10, threshold_period: 'yearly' },
@@ -209,11 +228,11 @@ describe('Cost Handlers', () => {
 				threshold_period: 'daily',
 				alert_type: 'warning',
 			};
-
-			const supabase = createMockSupabase({
-				insertResult: { data: mockAlert, error: null },
+			mockApiClient.addCostAlert.mockResolvedValue({
+				ok: true,
+				data: { success: true, alert: mockAlert, message: 'Alert created' },
 			});
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
 			const result = await addCostAlert(
 				{ threshold_amount: 10, threshold_period: 'daily' },
@@ -226,32 +245,36 @@ describe('Cost Handlers', () => {
 		});
 
 		it('should create alert with project_id', async () => {
-			const supabase = createMockSupabase({
-				insertResult: { data: { id: 'new-alert' }, error: null },
+			mockApiClient.addCostAlert.mockResolvedValue({
+				ok: true,
+				data: { success: true, alert: { id: 'new-alert' } },
 			});
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
 			await addCostAlert(
 				{
-					project_id: testUUID(),
+					project_id: VALID_UUID,
 					threshold_amount: 10,
 					threshold_period: 'daily',
 				},
 				ctx
 			);
 
-			expect(supabase.insert).toHaveBeenCalledWith(
+			expect(mockApiClient.addCostAlert).toHaveBeenCalledWith(
 				expect.objectContaining({
-					project_id: testUUID(),
+					project_id: VALID_UUID,
+					threshold_amount: 10,
+					threshold_period: 'daily',
 				})
 			);
 		});
 
-		it('should return error on database failure', async () => {
-			const supabase = createMockSupabase({
-				insertResult: { data: null, error: { message: 'Insert failed' } },
+		it('should return error on API failure', async () => {
+			mockApiClient.addCostAlert.mockResolvedValue({
+				ok: false,
+				error: 'Insert failed',
 			});
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
 			const result = await addCostAlert(
 				{ threshold_amount: 10, threshold_period: 'daily' },
@@ -259,7 +282,7 @@ describe('Cost Handlers', () => {
 			);
 
 			expect(result.isError).toBe(true);
-			expect(result.result.error).toContain('Failed to create cost alert');
+			expect(result.result.error).toBe('Insert failed');
 		});
 	});
 
@@ -269,8 +292,7 @@ describe('Cost Handlers', () => {
 
 	describe('updateCostAlert', () => {
 		it('should return error when alert_id is missing', async () => {
-			const supabase = createMockSupabase();
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
 			const result = await updateCostAlert({}, ctx);
 
@@ -279,10 +301,9 @@ describe('Cost Handlers', () => {
 		});
 
 		it('should return error when no updates provided', async () => {
-			const supabase = createMockSupabase();
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
-			const result = await updateCostAlert({ alert_id: testUUID() }, ctx);
+			const result = await updateCostAlert({ alert_id: VALID_UUID }, ctx);
 
 			expect(result.isError).toBe(true);
 			expect(result.result.error).toBe('No updates provided');
@@ -290,18 +311,18 @@ describe('Cost Handlers', () => {
 
 		it('should update alert successfully', async () => {
 			const mockUpdatedAlert = {
-				id: testUUID(),
+				id: VALID_UUID,
 				threshold_amount: 20,
 				threshold_period: 'weekly',
 			};
-
-			const supabase = createMockSupabase({
-				updateResult: { data: mockUpdatedAlert, error: null },
+			mockApiClient.updateCostAlert.mockResolvedValue({
+				ok: true,
+				data: { success: true, alert: mockUpdatedAlert },
 			});
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
 			const result = await updateCostAlert(
-				{ alert_id: testUUID(), threshold_amount: 20 },
+				{ alert_id: VALID_UUID, threshold_amount: 20 },
 				ctx
 			);
 
@@ -310,29 +331,34 @@ describe('Cost Handlers', () => {
 		});
 
 		it('should update enabled status', async () => {
-			const supabase = createMockSupabase({
-				updateResult: { data: { id: testUUID(), enabled: false }, error: null },
+			mockApiClient.updateCostAlert.mockResolvedValue({
+				ok: true,
+				data: { success: true, alert: { id: VALID_UUID, enabled: false } },
 			});
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
-			await updateCostAlert({ alert_id: testUUID(), enabled: false }, ctx);
+			await updateCostAlert({ alert_id: VALID_UUID, enabled: false }, ctx);
 
-			expect(supabase.update).toHaveBeenCalledWith({ enabled: false });
+			expect(mockApiClient.updateCostAlert).toHaveBeenCalledWith(
+				VALID_UUID,
+				expect.objectContaining({ enabled: false })
+			);
 		});
 
-		it('should return error on database failure', async () => {
-			const supabase = createMockSupabase({
-				updateResult: { data: null, error: { message: 'Update failed' } },
+		it('should return error on API failure', async () => {
+			mockApiClient.updateCostAlert.mockResolvedValue({
+				ok: false,
+				error: 'Update failed',
 			});
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
 			const result = await updateCostAlert(
-				{ alert_id: testUUID(), threshold_amount: 20 },
+				{ alert_id: VALID_UUID, threshold_amount: 20 },
 				ctx
 			);
 
 			expect(result.isError).toBe(true);
-			expect(result.result.error).toContain('Failed to update cost alert');
+			expect(result.result.error).toBe('Update failed');
 		});
 	});
 
@@ -342,8 +368,7 @@ describe('Cost Handlers', () => {
 
 	describe('deleteCostAlert', () => {
 		it('should return error when alert_id is missing', async () => {
-			const supabase = createMockSupabase();
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
 			const result = await deleteCostAlert({}, ctx);
 
@@ -352,27 +377,29 @@ describe('Cost Handlers', () => {
 		});
 
 		it('should delete alert successfully', async () => {
-			const supabase = createMockSupabase({
-				deleteResult: { data: null, error: null },
+			mockApiClient.deleteCostAlert.mockResolvedValue({
+				ok: true,
+				data: { success: true, deleted_alert_id: VALID_UUID },
 			});
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
-			const result = await deleteCostAlert({ alert_id: testUUID() }, ctx);
+			const result = await deleteCostAlert({ alert_id: VALID_UUID }, ctx);
 
 			expect(result.result.success).toBe(true);
-			expect(result.result.deleted_alert_id).toBe(testUUID());
+			expect(result.result.deleted_alert_id).toBe(VALID_UUID);
 		});
 
-		it('should return error on database failure', async () => {
-			const supabase = createMockSupabase({
-				deleteResult: { data: null, error: { message: 'Delete failed' } },
+		it('should return error on API failure', async () => {
+			mockApiClient.deleteCostAlert.mockResolvedValue({
+				ok: false,
+				error: 'Delete failed',
 			});
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
-			const result = await deleteCostAlert({ alert_id: testUUID() }, ctx);
+			const result = await deleteCostAlert({ alert_id: VALID_UUID }, ctx);
 
 			expect(result.isError).toBe(true);
-			expect(result.result.error).toContain('Failed to delete cost alert');
+			expect(result.result.error).toBe('Delete failed');
 		});
 	});
 
@@ -382,8 +409,7 @@ describe('Cost Handlers', () => {
 
 	describe('getTaskCosts', () => {
 		it('should return error when project_id is missing', async () => {
-			const supabase = createMockSupabase();
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
 			const result = await getTaskCosts({}, ctx);
 
@@ -396,41 +422,51 @@ describe('Cost Handlers', () => {
 				{ id: 'task-1', title: 'Task 1', estimated_cost_usd: '0.50' },
 				{ id: 'task-2', title: 'Task 2', estimated_cost_usd: '0.30' },
 			];
-
-			const supabase = createMockSupabase({
-				selectResult: { data: mockTasks, error: null },
+			mockApiClient.getTaskCosts.mockResolvedValue({
+				ok: true,
+				data: {
+					project_id: VALID_UUID,
+					tasks: mockTasks,
+					total_cost_usd: 0.8,
+				},
 			});
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
-			const result = await getTaskCosts({ project_id: testUUID() }, ctx);
+			const result = await getTaskCosts({ project_id: VALID_UUID }, ctx);
 
-			expect(result.result.project_id).toBe(testUUID());
+			expect(result.result.project_id).toBe(VALID_UUID);
 			expect(result.result.tasks).toEqual(mockTasks);
 			expect(result.result.total_cost_usd).toBe(0.8);
 		});
 
 		it('should handle empty task list', async () => {
-			const supabase = createMockSupabase({
-				selectResult: { data: [], error: null },
+			mockApiClient.getTaskCosts.mockResolvedValue({
+				ok: true,
+				data: {
+					project_id: VALID_UUID,
+					tasks: [],
+					total_cost_usd: 0,
+				},
 			});
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
-			const result = await getTaskCosts({ project_id: testUUID() }, ctx);
+			const result = await getTaskCosts({ project_id: VALID_UUID }, ctx);
 
 			expect(result.result.tasks).toEqual([]);
 			expect(result.result.total_cost_usd).toBe(0);
 		});
 
-		it('should return error on database failure', async () => {
-			const supabase = createMockSupabase({
-				selectResult: { data: null, error: { message: 'Query failed' } },
+		it('should return error on API failure', async () => {
+			mockApiClient.getTaskCosts.mockResolvedValue({
+				ok: false,
+				error: 'Query failed',
 			});
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
-			const result = await getTaskCosts({ project_id: testUUID() }, ctx);
+			const result = await getTaskCosts({ project_id: VALID_UUID }, ctx);
 
 			expect(result.isError).toBe(true);
-			expect(result.result.error).toContain('Failed to get task costs');
+			expect(result.result.error).toBe('Query failed');
 		});
 	});
 });