@vibescope/mcp-server 0.0.1

package/src/handlers/cost.test.ts

@@ -0,0 +1,436 @@
+/**
+ * Cost Handlers Unit Tests
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+	getCostSummary,
+	getCostAlerts,
+	addCostAlert,
+	updateCostAlert,
+	deleteCostAlert,
+	getTaskCosts,
+} from './cost.js';
+import { createMockSupabase, createMockContext, testUUID } from './__test-utils__.js';
+
+describe('Cost Handlers', () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	// ============================================================================
+	// getCostSummary
+	// ============================================================================
+
+	describe('getCostSummary', () => {
+		it('should return error when project_id is missing', async () => {
+			const supabase = createMockSupabase();
+			const ctx = createMockContext(supabase);
+
+			const result = await getCostSummary({}, ctx);
+
+			expect(result.isError).toBe(true);
+			expect(result.result).toEqual({ error: 'project_id is required' });
+		});
+
+		it('should return daily cost summary with totals', async () => {
+			const mockData = [
+				{
+					date: '2025-01-14',
+					session_count: 5,
+					total_tokens: 10000,
+					total_calls: 50,
+					estimated_cost_usd: '0.50',
+				},
+				{
+					date: '2025-01-13',
+					session_count: 3,
+					total_tokens: 6000,
+					total_calls: 30,
+					estimated_cost_usd: '0.30',
+				},
+			];
+
+			const supabase = createMockSupabase({
+				selectResult: { data: mockData, error: null },
+			});
+			const ctx = createMockContext(supabase);
+
+			const result = await getCostSummary({ project_id: testUUID() }, ctx);
+
+			expect(result.isError).toBeUndefined();
+			expect(result.result.period).toBe('daily');
+			expect(result.result.summary).toEqual(mockData);
+			expect(result.result.totals).toEqual({
+				sessions: 8,
+				tokens: 16000,
+				calls: 80,
+				cost: 0.8,
+			});
+		});
+
+		it('should handle weekly period', async () => {
+			const supabase = createMockSupabase({
+				selectResult: { data: [], error: null },
+			});
+			const ctx = createMockContext(supabase);
+
+			const result = await getCostSummary(
+				{ project_id: testUUID(), period: 'weekly' },
+				ctx
+			);
+
+			expect(result.result.period).toBe('weekly');
+			expect(supabase.from).toHaveBeenCalledWith('weekly_cost_summary');
+		});
+
+		it('should handle monthly period', async () => {
+			const supabase = createMockSupabase({
+				selectResult: { data: [], error: null },
+			});
+			const ctx = createMockContext(supabase);
+
+			const result = await getCostSummary(
+				{ project_id: testUUID(), period: 'monthly' },
+				ctx
+			);
+
+			expect(result.result.period).toBe('monthly');
+			expect(supabase.from).toHaveBeenCalledWith('monthly_cost_summary');
+		});
+
+		it('should return error on database failure', async () => {
+			const supabase = createMockSupabase({
+				selectResult: { data: null, error: { message: 'Database error' } },
+			});
+			const ctx = createMockContext(supabase);
+
+			const result = await getCostSummary({ project_id: testUUID() }, ctx);
+
+			expect(result.isError).toBe(true);
+			expect(result.result.error).toContain('Failed to get cost summary');
+		});
+	});
+
+	// ============================================================================
+	// getCostAlerts
+	// ============================================================================
+
+	describe('getCostAlerts', () => {
+		it('should return all alerts for user', async () => {
+			const mockAlerts = [
+				{ 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 },
+			});
+			const ctx = createMockContext(supabase);
+
+			const result = await getCostAlerts({}, ctx);
+
+			expect(result.result.alerts).toEqual(mockAlerts);
+			expect(result.result.count).toBe(2);
+		});
+
+		it('should filter by project_id when provided', async () => {
+			const supabase = createMockSupabase({
+				selectResult: { data: [], error: null },
+			});
+			const ctx = createMockContext(supabase);
+
+			await getCostAlerts({ project_id: testUUID() }, ctx);
+
+			expect(supabase.eq).toHaveBeenCalledWith('project_id', testUUID());
+		});
+
+		it('should return error on database failure', async () => {
+			const supabase = createMockSupabase({
+				selectResult: { data: null, error: { message: 'Query failed' } },
+			});
+			const ctx = createMockContext(supabase);
+
+			const result = await getCostAlerts({}, ctx);
+
+			expect(result.isError).toBe(true);
+			expect(result.result.error).toContain('Failed to get cost alerts');
+		});
+	});
+
+	// ============================================================================
+	// addCostAlert
+	// ============================================================================
+
+	describe('addCostAlert', () => {
+		it('should return error when threshold_amount is missing', async () => {
+			const supabase = createMockSupabase();
+			const ctx = createMockContext(supabase);
+
+			const result = await addCostAlert(
+				{ threshold_period: 'daily' },
+				ctx
+			);
+
+			expect(result.isError).toBe(true);
+			expect(result.result.error).toContain('threshold_amount must be a positive number');
+		});
+
+		it('should return error when threshold_amount is not positive', async () => {
+			const supabase = createMockSupabase();
+			const ctx = createMockContext(supabase);
+
+			const result = await addCostAlert(
+				{ threshold_amount: -5, threshold_period: 'daily' },
+				ctx
+			);
+
+			expect(result.isError).toBe(true);
+			expect(result.result.error).toContain('threshold_amount must be a positive number');
+		});
+
+		it('should return error when threshold_period is invalid', async () => {
+			const supabase = createMockSupabase();
+			const ctx = createMockContext(supabase);
+
+			const result = await addCostAlert(
+				{ threshold_amount: 10, threshold_period: 'yearly' },
+				ctx
+			);
+
+			expect(result.isError).toBe(true);
+			expect(result.result.error).toContain('threshold_period must be');
+		});
+
+		it('should create alert successfully', async () => {
+			const mockAlert = {
+				id: 'new-alert',
+				threshold_amount: 10,
+				threshold_period: 'daily',
+				alert_type: 'warning',
+			};
+
+			const supabase = createMockSupabase({
+				insertResult: { data: mockAlert, error: null },
+			});
+			const ctx = createMockContext(supabase);
+
+			const result = await addCostAlert(
+				{ threshold_amount: 10, threshold_period: 'daily' },
+				ctx
+			);
+
+			expect(result.result.success).toBe(true);
+			expect(result.result.alert).toEqual(mockAlert);
+			expect(result.result.message).toContain('Alert created');
+		});
+
+		it('should create alert with project_id', async () => {
+			const supabase = createMockSupabase({
+				insertResult: { data: { id: 'new-alert' }, error: null },
+			});
+			const ctx = createMockContext(supabase);
+
+			await addCostAlert(
+				{
+					project_id: testUUID(),
+					threshold_amount: 10,
+					threshold_period: 'daily',
+				},
+				ctx
+			);
+
+			expect(supabase.insert).toHaveBeenCalledWith(
+				expect.objectContaining({
+					project_id: testUUID(),
+				})
+			);
+		});
+
+		it('should return error on database failure', async () => {
+			const supabase = createMockSupabase({
+				insertResult: { data: null, error: { message: 'Insert failed' } },
+			});
+			const ctx = createMockContext(supabase);
+
+			const result = await addCostAlert(
+				{ threshold_amount: 10, threshold_period: 'daily' },
+				ctx
+			);
+
+			expect(result.isError).toBe(true);
+			expect(result.result.error).toContain('Failed to create cost alert');
+		});
+	});
+
+	// ============================================================================
+	// updateCostAlert
+	// ============================================================================
+
+	describe('updateCostAlert', () => {
+		it('should return error when alert_id is missing', async () => {
+			const supabase = createMockSupabase();
+			const ctx = createMockContext(supabase);
+
+			const result = await updateCostAlert({}, ctx);
+
+			expect(result.isError).toBe(true);
+			expect(result.result.error).toBe('alert_id is required');
+		});
+
+		it('should return error when no updates provided', async () => {
+			const supabase = createMockSupabase();
+			const ctx = createMockContext(supabase);
+
+			const result = await updateCostAlert({ alert_id: testUUID() }, ctx);
+
+			expect(result.isError).toBe(true);
+			expect(result.result.error).toBe('No updates provided');
+		});
+
+		it('should update alert successfully', async () => {
+			const mockUpdatedAlert = {
+				id: testUUID(),
+				threshold_amount: 20,
+				threshold_period: 'weekly',
+			};
+
+			const supabase = createMockSupabase({
+				updateResult: { data: mockUpdatedAlert, error: null },
+			});
+			const ctx = createMockContext(supabase);
+
+			const result = await updateCostAlert(
+				{ alert_id: testUUID(), threshold_amount: 20 },
+				ctx
+			);
+
+			expect(result.result.success).toBe(true);
+			expect(result.result.alert).toEqual(mockUpdatedAlert);
+		});
+
+		it('should update enabled status', async () => {
+			const supabase = createMockSupabase({
+				updateResult: { data: { id: testUUID(), enabled: false }, error: null },
+			});
+			const ctx = createMockContext(supabase);
+
+			await updateCostAlert({ alert_id: testUUID(), enabled: false }, ctx);
+
+			expect(supabase.update).toHaveBeenCalledWith({ enabled: false });
+		});
+
+		it('should return error on database failure', async () => {
+			const supabase = createMockSupabase({
+				updateResult: { data: null, error: { message: 'Update failed' } },
+			});
+			const ctx = createMockContext(supabase);
+
+			const result = await updateCostAlert(
+				{ alert_id: testUUID(), threshold_amount: 20 },
+				ctx
+			);
+
+			expect(result.isError).toBe(true);
+			expect(result.result.error).toContain('Failed to update cost alert');
+		});
+	});
+
+	// ============================================================================
+	// deleteCostAlert
+	// ============================================================================
+
+	describe('deleteCostAlert', () => {
+		it('should return error when alert_id is missing', async () => {
+			const supabase = createMockSupabase();
+			const ctx = createMockContext(supabase);
+
+			const result = await deleteCostAlert({}, ctx);
+
+			expect(result.isError).toBe(true);
+			expect(result.result.error).toBe('alert_id is required');
+		});
+
+		it('should delete alert successfully', async () => {
+			const supabase = createMockSupabase({
+				deleteResult: { data: null, error: null },
+			});
+			const ctx = createMockContext(supabase);
+
+			const result = await deleteCostAlert({ alert_id: testUUID() }, ctx);
+
+			expect(result.result.success).toBe(true);
+			expect(result.result.deleted_alert_id).toBe(testUUID());
+		});
+
+		it('should return error on database failure', async () => {
+			const supabase = createMockSupabase({
+				deleteResult: { data: null, error: { message: 'Delete failed' } },
+			});
+			const ctx = createMockContext(supabase);
+
+			const result = await deleteCostAlert({ alert_id: testUUID() }, ctx);
+
+			expect(result.isError).toBe(true);
+			expect(result.result.error).toContain('Failed to delete cost alert');
+		});
+	});
+
+	// ============================================================================
+	// getTaskCosts
+	// ============================================================================
+
+	describe('getTaskCosts', () => {
+		it('should return error when project_id is missing', async () => {
+			const supabase = createMockSupabase();
+			const ctx = createMockContext(supabase);
+
+			const result = await getTaskCosts({}, ctx);
+
+			expect(result.isError).toBe(true);
+			expect(result.result.error).toBe('project_id is required');
+		});
+
+		it('should return task costs with total', async () => {
+			const mockTasks = [
+				{ 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 },
+			});
+			const ctx = createMockContext(supabase);
+
+			const result = await getTaskCosts({ project_id: testUUID() }, ctx);
+
+			expect(result.result.project_id).toBe(testUUID());
+			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 },
+			});
+			const ctx = createMockContext(supabase);
+
+			const result = await getTaskCosts({ project_id: testUUID() }, 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' } },
+			});
+			const ctx = createMockContext(supabase);
+
+			const result = await getTaskCosts({ project_id: testUUID() }, ctx);
+
+			expect(result.isError).toBe(true);
+			expect(result.result.error).toContain('Failed to get task costs');
+		});
+	});
+});