@codeguide/core 0.0.28 → 0.0.33

package/__tests__/services/usage/usage-service.test.ts

@@ -6,12 +6,19 @@ import {
   TrackUsageRequest,
   TrackUsageResponse,
   CreditBalanceResponse,
+  CreditBalanceData,
   CreditCheckResponse,
   UsageSummaryResponse,
   AuthorizationResponse,
   CalculateUsageResponse,
   TrackCodespaceUsageResponse,
   CodespaceTaskUsageResponse,
+  DashboardAnalyticsRequest,
+  DashboardAnalyticsResponse,
+  UsageDetailsRequest,
+  UsageDetailsResponse,
+  ServiceBreakdownRequest,
+  ServiceBreakdownResponse,
 } from '../../../services/usage/usage-types'
 
 describe('UsageService', () => {
@@ -20,12 +27,12 @@ describe('UsageService', () => {
   let config: APIServiceConfig
 
   beforeEach(() => {
-    mockAxios = new MockAdapter(axios)
     config = {
       baseUrl: 'https://api.codeguide.app',
       databaseApiKey: 'sk_test123',
     }
     usageService = new UsageService(config)
+    mockAxios = new MockAdapter((usageService as any).client)
   })
 
   afterEach(() => {
@@ -49,7 +56,7 @@ describe('UsageService', () => {
         message: 'Usage tracked successfully',
       }
 
-      mockAxios.onPost('/v1/usage/track', request).reply(200, response)
+      mockAxios.onPost('/usage/track', request).reply(200, response)
 
       const result = await usageService.trackUsage(request)
 
@@ -63,7 +70,7 @@ describe('UsageService', () => {
         output_tokens: 50,
       }
 
-      mockAxios.onPost('/v1/usage/track', request).reply(400, {
+      mockAxios.onPost('/usage/track', request).reply(400, {
         detail: 'Invalid request',
       })
 
@@ -73,7 +80,7 @@ describe('UsageService', () => {
 
   describe('getCreditBalance', () => {
     it('should get credit balance successfully', async () => {
-      const response: CreditBalanceResponse = {
+      const creditBalanceData: CreditBalanceData = {
         user_id: 'user123',
         total_consumed: 10.5,
         total_allotted: 100,
@@ -87,7 +94,11 @@ describe('UsageService', () => {
         },
       }
 
-      mockAxios.onGet('/v1/usage/credit-balance').reply(200, response)
+      const response: CreditBalanceResponse = {
+        data: creditBalanceData,
+      }
+
+      mockAxios.onGet('/usage/credit-balance').reply(200, response)
 
       const result = await usageService.getCreditBalance()
 
@@ -113,7 +124,7 @@ describe('UsageService', () => {
 
       mockAxios
         .onGet(
-          '/v1/usage/credit-check?model_key=gpt-4&input_tokens=100&output_tokens=50&call_seconds=2'
+          '/usage/credit-check?model_key=gpt-4&input_tokens=100&output_tokens=50&call_seconds=2'
         )
         .reply(200, response)
 
@@ -135,9 +146,7 @@ describe('UsageService', () => {
         model_key: 'gpt-4',
       }
 
-      mockAxios
-        .onGet('/v1/usage/credit-check?model_key=gpt-4&input_tokens=100')
-        .reply(200, response)
+      mockAxios.onGet('/usage/credit-check?model_key=gpt-4&input_tokens=100').reply(200, response)
 
       const result = await usageService.checkCredits(params)
 
@@ -145,73 +154,6 @@ describe('UsageService', () => {
     })
   })
 
-  describe('getUsageSummary', () => {
-    it('should get usage summary with date range', async () => {
-      const params = {
-        start_date: '2024-01-01',
-        end_date: '2024-01-31',
-      }
-
-      const response: UsageSummaryResponse = {
-        user_id: 'user123',
-        period: {
-          start_date: '2024-01-01',
-          end_date: '2024-01-31',
-        },
-        usage_summary: {
-          total_credits_used: 15.5,
-          total_calls: 42,
-          model_breakdown: {
-            'gpt-4': { calls: 20, credits: 12.0 },
-            'gpt-3.5': { calls: 22, credits: 3.5 },
-          },
-          daily_usage: [
-            { date: '2024-01-01', credits_used: 1.5, calls: 5 },
-            { date: '2024-01-02', credits_used: 2.0, calls: 8 },
-          ],
-        },
-        subscription: {
-          plan: 'pro',
-          status: 'active',
-        },
-      }
-
-      mockAxios
-        .onGet('/v1/usage/summary?start_date=2024-01-01&end_date=2024-01-31')
-        .reply(200, response)
-
-      const result = await usageService.getUsageSummary(params)
-
-      expect(result).toEqual(response)
-    })
-
-    it('should get usage summary without date range', async () => {
-      const response: UsageSummaryResponse = {
-        user_id: 'user123',
-        period: {
-          start_date: '2024-01-01',
-          end_date: '2024-01-31',
-        },
-        usage_summary: {
-          total_credits_used: 15.5,
-          total_calls: 42,
-          model_breakdown: {},
-          daily_usage: [],
-        },
-        subscription: {
-          plan: 'pro',
-          status: 'active',
-        },
-      }
-
-      mockAxios.onGet('/v1/usage/summary').reply(200, response)
-
-      const result = await usageService.getUsageSummary()
-
-      expect(result).toEqual(response)
-    })
-  })
-
   describe('getAuthorization', () => {
     it('should get authorization info successfully', async () => {
       const response: AuthorizationResponse = {
@@ -291,7 +233,7 @@ describe('UsageService', () => {
         message: 'Authorization status retrieved successfully',
       }
 
-      mockAxios.onGet('/v1/usage/authorization').reply(200, response)
+      mockAxios.onGet('/usage/authorization').reply(200, response)
 
       const result = await usageService.getAuthorization()
 
@@ -375,7 +317,7 @@ describe('UsageService', () => {
         message: 'Authorization status retrieved successfully',
       }
 
-      mockAxios.onGet('/v1/usage/authorization').reply(200, response)
+      mockAxios.onGet('/usage/authorization').reply(200, response)
 
       const result = await usageService.getAuthorization()
 
@@ -397,7 +339,7 @@ describe('UsageService', () => {
         credits_expire_at: '2024-12-31',
       }
 
-      mockAxios.onGet('/v1/usage/free-user-status').reply(200, response)
+      mockAxios.onGet('/usage/free-user-status').reply(200, response)
 
       const result = await usageService.getFreeUserStatus()
 
@@ -428,7 +370,7 @@ describe('UsageService', () => {
 
       mockAxios
         .onGet(
-          '/v1/usage/calculate?model_key=gpt-4&input_tokens=100&output_tokens=50&call_seconds=2&cost_amount=0.05'
+          '/usage/calculate?model_key=gpt-4&input_tokens=100&output_tokens=50&call_seconds=2&cost_amount=0.05'
         )
         .reply(200, response)
 
@@ -461,7 +403,7 @@ describe('UsageService', () => {
         created_at: '2024-01-01T00:00:00Z',
       }
 
-      mockAxios.onPost('/v1/usage/codespace/track', request).reply(200, response)
+      mockAxios.onPost('/usage/codespace/track', request).reply(200, response)
 
       const result = await usageService.trackCodespaceUsage(request)
 
@@ -472,29 +414,15 @@ describe('UsageService', () => {
   describe('getCodespaceTaskUsage', () => {
     it('should get codespace task usage successfully', async () => {
       const response: CodespaceTaskUsageResponse = {
-        codespace_task_id: 'task123',
-        total_usage: {
-          total_input_tokens: 200,
-          total_output_tokens: 100,
-          total_call_seconds: 4,
-          total_cost: 0.1,
+        status: 'success',
+        data: {
+          total_records: 2,
+          total_credits_consumed: 49.428799,
+          latest_usage: '2025-11-24T07:50:58.150274+00:00',
         },
-        usage_records: [
-          {
-            id: 'usage123',
-            codespace_task_id: 'task123',
-            user_id: 'user123',
-            model_key: 'gpt-4',
-            input_tokens: 100,
-            output_tokens: 50,
-            call_seconds: 2,
-            cost_amount: 0.05,
-            created_at: '2024-01-01T00:00:00Z',
-          },
-        ],
       }
 
-      mockAxios.onGet('/v1/usage/codespace/task/task123').reply(200, response)
+      mockAxios.onGet('/usage/codespace/task/task123').reply(200, response)
 
       const result = await usageService.getCodespaceTaskUsage('task123')
 
@@ -504,7 +432,7 @@ describe('UsageService', () => {
 
   describe('healthCheck', () => {
     it('should return true when API is healthy', async () => {
-      mockAxios.onGet('/v1/usage/health').reply(200, {
+      mockAxios.onGet('/usage/health').reply(200, {
         status: 'healthy',
         timestamp: '2024-01-01T00:00:00Z',
         version: '1.0.0',
@@ -516,7 +444,7 @@ describe('UsageService', () => {
     })
 
     it('should return false when API is not healthy', async () => {
-      mockAxios.onGet('/v1/usage/health').reply(200, {
+      mockAxios.onGet('/usage/health').reply(200, {
         status: 'unhealthy',
         timestamp: '2024-01-01T00:00:00Z',
         version: '1.0.0',
@@ -528,11 +456,437 @@ describe('UsageService', () => {
     })
 
     it('should return false when health check fails', async () => {
-      mockAxios.onGet('/v1/usage/health').reply(500)
+      mockAxios.onGet('/usage/health').reply(500)
 
       const result = await usageService.healthCheck()
 
       expect(result).toBe(false)
     })
   })
+
+  // Dashboard Analytics Tests
+  describe('getDashboardAnalytics', () => {
+    it('should get dashboard analytics with period parameter', async () => {
+      const params: DashboardAnalyticsRequest = {
+        period: '7d',
+      }
+
+      const response: DashboardAnalyticsResponse = {
+        status: 'success',
+        data: {
+          period: {
+            start: '2024-01-25',
+            end: '2024-01-31',
+            label: '7d',
+          },
+          daily_usage: [
+            {
+              date: '2024-01-25',
+              credits_consumed: 1250,
+              cost_usd: 3.75,
+              requests_count: 15,
+              average_credits_per_request: 83.33,
+            },
+          ],
+          totals: {
+            credits_consumed: 13870,
+            cost_usd: 41.61,
+            requests_count: 142,
+          },
+          averages: {
+            daily_credits: 1981.43,
+            daily_requests: 20.29,
+          },
+          trends: {
+            credits_consumed: 15.7,
+            requests_count: 8.3,
+          },
+          top_services: [
+            {
+              service_type: 'docs',
+              credits_consumed: 5230,
+              requests_count: 58,
+            },
+          ],
+        },
+      }
+
+      mockAxios.onGet('/usage/dashboard/analytics?period=7d').reply(200, response)
+
+      const result = await usageService.getDashboardAnalytics(params)
+
+      expect(result).toEqual(response)
+    })
+
+    it('should get dashboard analytics with all parameters', async () => {
+      const params: DashboardAnalyticsRequest = {
+        start_date: '2024-01-01',
+        end_date: '2024-01-31',
+        service_type: 'docs',
+      }
+
+      const response: DashboardAnalyticsResponse = {
+        status: 'success',
+        data: {
+          period: {
+            start: '2024-01-01',
+            end: '2024-01-31',
+            label: 'custom',
+          },
+          daily_usage: [],
+          totals: {
+            credits_consumed: 5000,
+            cost_usd: 15.0,
+            requests_count: 45,
+          },
+          averages: {
+            daily_credits: 161.29,
+            daily_requests: 1.45,
+          },
+          trends: {
+            credits_consumed: 12.5,
+            requests_count: 5.2,
+          },
+          top_services: [
+            {
+              service_type: 'docs',
+              credits_consumed: 5000,
+              requests_count: 45,
+            },
+          ],
+        },
+      }
+
+      mockAxios
+        .onGet(
+          '/usage/dashboard/analytics?start_date=2024-01-01&end_date=2024-01-31&service_type=docs'
+        )
+        .reply(200, response)
+
+      const result = await usageService.getDashboardAnalytics(params)
+
+      expect(result).toEqual(response)
+    })
+
+    it('should get dashboard analytics without parameters', async () => {
+      const response: DashboardAnalyticsResponse = {
+        status: 'success',
+        data: {
+          period: {
+            start: '2024-01-01',
+            end: '2024-01-07',
+            label: '7d',
+          },
+          daily_usage: [],
+          totals: {
+            credits_consumed: 1000,
+            cost_usd: 3.0,
+            requests_count: 10,
+          },
+          averages: {
+            daily_credits: 142.86,
+            daily_requests: 1.43,
+          },
+          trends: {
+            credits_consumed: 5.0,
+            requests_count: 2.0,
+          },
+          top_services: [],
+        },
+      }
+
+      mockAxios.onGet('/usage/dashboard/analytics').reply(200, response)
+
+      const result = await usageService.getDashboardAnalytics()
+
+      expect(result).toEqual(response)
+    })
+  })
+
+  describe('getUsageDetails', () => {
+    it('should get usage details with pagination parameters', async () => {
+      const params: UsageDetailsRequest = {
+        page: 1,
+        page_size: 25,
+        sort_by: 'credits_consumed',
+        sort_order: 'desc',
+      }
+
+      const response: UsageDetailsResponse = {
+        status: 'success',
+        data: [
+          {
+            id: 'rec_123456789',
+            created_at: '2024-01-31T14:30:15.123Z',
+            service_type: 'docs',
+            model_name: 'GPT-4',
+            usage_type: 'output_tokens',
+            units_consumed: 1250,
+            credits_consumed: 156,
+            cost_amount: 0.468,
+          },
+        ],
+        pagination: {
+          page: 1,
+          page_size: 25,
+          total_count: 142,
+          total_pages: 6,
+          has_next: true,
+          has_prev: false,
+        },
+        filters: {
+          period: null,
+          start_date: null,
+          end_date: null,
+          service_type: null,
+        },
+      }
+
+      mockAxios
+        .onGet(
+          '/usage/dashboard/details?page=1&page_size=25&sort_by=credits_consumed&sort_order=desc'
+        )
+        .reply(200, response)
+
+      const result = await usageService.getUsageDetails(params)
+
+      expect(result).toEqual(response)
+    })
+
+    it('should get usage details with filtering parameters', async () => {
+      const params: UsageDetailsRequest = {
+        period: '1m',
+        service_type: 'chat',
+      }
+
+      const response: UsageDetailsResponse = {
+        status: 'success',
+        data: [
+          {
+            id: 'rec_123456790',
+            created_at: '2024-01-30T10:15:20.456Z',
+            service_type: 'chat',
+            model_name: 'GPT-3.5 Turbo',
+            usage_type: 'input_tokens',
+            units_consumed: 890,
+            credits_consumed: 89,
+            cost_amount: null,
+          },
+        ],
+        pagination: {
+          page: 1,
+          page_size: 50,
+          total_count: 25,
+          total_pages: 1,
+          has_next: false,
+          has_prev: false,
+        },
+        filters: {
+          period: '1m',
+          start_date: null,
+          end_date: null,
+          service_type: 'chat',
+        },
+      }
+
+      mockAxios.onGet('/usage/dashboard/details?period=1m&service_type=chat').reply(200, response)
+
+      const result = await usageService.getUsageDetails(params)
+
+      expect(result).toEqual(response)
+    })
+  })
+
+  describe('getUsageSummary', () => {
+    it('should get usage summary dashboard with period parameter', async () => {
+      const params = {
+        period: '7d' as const,
+      }
+
+      const response: UsageSummaryResponse = {
+        status: 'success',
+        data: {
+          current_period: {
+            credits_consumed: 13870,
+            cost_usd: 41.61,
+            requests_count: 142,
+          },
+          previous_period: {
+            credits_consumed: 11990,
+            cost_usd: 35.97,
+            requests_count: 131,
+          },
+          billing_cycle: {
+            total_allotted: 50000,
+            total_consumed: 28450,
+            remaining_credits: 21550,
+          },
+          utilization_percentage: 56.9,
+          remaining_credits: 21550,
+          daily_average: 1981.43,
+          projected_monthly: 59443,
+        },
+      }
+
+      mockAxios.onGet('/usage/dashboard/summary?period=7d').reply(200, response)
+
+      const result = await usageService.getUsageSummary(params)
+
+      expect(result).toEqual(response)
+    })
+
+    it('should get usage summary dashboard with custom date range', async () => {
+      const params = {
+        start_date: '2024-01-01',
+        end_date: '2024-01-31',
+      }
+
+      const response: UsageSummaryResponse = {
+        status: 'success',
+        data: {
+          current_period: {
+            credits_consumed: 25000,
+            cost_usd: 75.0,
+            requests_count: 300,
+          },
+          previous_period: {
+            credits_consumed: 22000,
+            cost_usd: 66.0,
+            requests_count: 275,
+          },
+          billing_cycle: {
+            total_allotted: 50000,
+            total_consumed: 47000,
+            remaining_credits: 3000,
+          },
+          utilization_percentage: 94.0,
+          remaining_credits: 3000,
+          daily_average: 806.45,
+          projected_monthly: 25000,
+        },
+      }
+
+      mockAxios
+        .onGet('/usage/dashboard/summary?start_date=2024-01-01&end_date=2024-01-31')
+        .reply(200, response)
+
+      const result = await usageService.getUsageSummary(params)
+
+      expect(result).toEqual(response)
+    })
+  })
+
+  describe('getServiceBreakdown', () => {
+    it('should get service breakdown with period parameter', async () => {
+      const params: ServiceBreakdownRequest = {
+        period: '7d',
+      }
+
+      const response: ServiceBreakdownResponse = {
+        status: 'success',
+        data: {
+          period: {
+            start: '2024-01-25',
+            end: '2024-01-31',
+            label: '7d',
+          },
+          services: [
+            {
+              service_type: 'docs',
+              credits_consumed: 5230,
+              percentage: 37.71,
+              cost_usd: 15.69,
+              requests_count: 58,
+              trend: 12.5,
+            },
+            {
+              service_type: 'chat',
+              credits_consumed: 4120,
+              percentage: 29.71,
+              cost_usd: 12.36,
+              requests_count: 47,
+              trend: -5.2,
+            },
+          ],
+          total_credits: 13870,
+          total_cost: 41.61,
+        },
+      }
+
+      mockAxios.onGet('/usage/dashboard/services?period=7d').reply(200, response)
+
+      const result = await usageService.getServiceBreakdown(params)
+
+      expect(result).toEqual(response)
+    })
+
+    it('should get service breakdown with custom date range', async () => {
+      const params: ServiceBreakdownRequest = {
+        start_date: '2024-01-01',
+        end_date: '2024-01-31',
+      }
+
+      const response: ServiceBreakdownResponse = {
+        status: 'success',
+        data: {
+          period: {
+            start: '2024-01-01',
+            end: '2024-01-31',
+            label: 'custom',
+          },
+          services: [
+            {
+              service_type: 'codespace_task',
+              credits_consumed: 15000,
+              percentage: 60.0,
+              cost_usd: 45.0,
+              requests_count: 25,
+              trend: 28.4,
+            },
+          ],
+          total_credits: 25000,
+          total_cost: 75.0,
+        },
+      }
+
+      mockAxios
+        .onGet('/usage/dashboard/services?start_date=2024-01-01&end_date=2024-01-31')
+        .reply(200, response)
+
+      const result = await usageService.getServiceBreakdown(params)
+
+      expect(result).toEqual(response)
+    })
+
+    it('should get service breakdown without parameters', async () => {
+      const response: ServiceBreakdownResponse = {
+        status: 'success',
+        data: {
+          period: {
+            start: '2024-01-01',
+            end: '2024-01-07',
+            label: '7d',
+          },
+          services: [
+            {
+              service_type: 'api',
+              credits_consumed: 700,
+              percentage: 100.0,
+              cost_usd: 2.1,
+              requests_count: 5,
+              trend: 0.0,
+            },
+          ],
+          total_credits: 700,
+          total_cost: 2.1,
+        },
+      }
+
+      mockAxios.onGet('/usage/dashboard/services').reply(200, response)
+
+      const result = await usageService.getServiceBreakdown()
+
+      expect(result).toEqual(response)
+    })
+  })
 })