@codeguide/core 0.0.1

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

@@ -0,0 +1,334 @@
+import { TestService } from '../../test-service'
+import { APIServiceConfig, AuthenticationMethod } from '../../types'
+import axios from 'axios'
+import MockAdapter from 'axios-mock-adapter'
+
+describe('BaseService', () => {
+  let mockAxios: MockAdapter
+  let testService: TestService
+
+  beforeEach(() => {
+    mockAxios = new MockAdapter(axios)
+  })
+
+  afterEach(() => {
+    mockAxios.restore()
+  })
+
+  describe('Authentication Priority', () => {
+    it('should prioritize database API key when available', () => {
+      const config: APIServiceConfig = {
+        baseUrl: 'https://api.codeguide.app',
+        databaseApiKey: 'sk_test123',
+        apiKey: 'legacy_key',
+        userId: 'user123',
+        jwtToken: 'jwt_token',
+      }
+
+      testService = new TestService(config)
+      const authMethod = testService.testGetAuthenticationMethod()
+
+      expect(authMethod).toEqual({
+        type: 'database-api-key',
+        priority: 1,
+        headers: {
+          Authorization: 'Bearer sk_test123',
+          'Content-Type': 'application/json',
+        },
+      })
+    })
+
+    it('should use legacy API key + user ID when no database API key', () => {
+      const config: APIServiceConfig = {
+        baseUrl: 'https://api.codeguide.app',
+        apiKey: 'legacy_key',
+        userId: 'user123',
+        jwtToken: 'jwt_token',
+      }
+
+      testService = new TestService(config)
+      const authMethod = testService.testGetAuthenticationMethod()
+
+      expect(authMethod).toEqual({
+        type: 'legacy-api-key',
+        priority: 2,
+        headers: {
+          'X-API-Key': 'legacy_key',
+          'X-User-ID': 'user123',
+          'Content-Type': 'application/json',
+        },
+      })
+    })
+
+    it('should use JWT token when no other auth methods available', () => {
+      const config: APIServiceConfig = {
+        baseUrl: 'https://api.codeguide.app',
+        jwtToken: 'jwt_token',
+      }
+
+      testService = new TestService(config)
+      const authMethod = testService.testGetAuthenticationMethod()
+
+      expect(authMethod).toEqual({
+        type: 'clerk-jwt',
+        priority: 3,
+        headers: {
+          Authorization: 'Bearer jwt_token',
+          'Content-Type': 'application/json',
+        },
+      })
+    })
+
+    it('should fallback to legacy API key without user ID', () => {
+      const config: APIServiceConfig = {
+        baseUrl: 'https://api.codeguide.app',
+        apiKey: 'legacy_key',
+      }
+
+      testService = new TestService(config)
+      const authMethod = testService.testGetAuthenticationMethod()
+
+      expect(authMethod).toEqual({
+        type: 'legacy-api-key',
+        priority: 2,
+        headers: {
+          'X-API-Key': 'legacy_key',
+          'Content-Type': 'application/json',
+        },
+      })
+    })
+
+    it('should return null when no authentication methods available', () => {
+      const config: APIServiceConfig = {
+        baseUrl: 'https://api.codeguide.app',
+      }
+
+      testService = new TestService(config)
+      const authMethod = testService.testGetAuthenticationMethod()
+
+      expect(authMethod).toBeNull()
+    })
+  })
+
+  describe('Authentication Validation', () => {
+    it('should validate database API key format', () => {
+      const config: APIServiceConfig = {
+        baseUrl: 'https://api.codeguide.app',
+        databaseApiKey: 'invalid_key', // Missing sk_ prefix
+      }
+
+      testService = new TestService(config)
+      const result = testService.testValidateAuthentication()
+
+      expect(result.success).toBe(false)
+      expect(result.error).toBe('Database API key must start with "sk_"')
+    })
+
+    it('should validate legacy API key requires user ID', () => {
+      const config: APIServiceConfig = {
+        baseUrl: 'https://api.codeguide.app',
+        apiKey: 'legacy_key',
+        // No userId
+      }
+
+      testService = new TestService(config)
+      const result = testService.testValidateAuthentication()
+
+      expect(result.success).toBe(true)
+      expect(result.method?.type).toBe('legacy-api-key')
+    })
+
+    it('should return error when no authentication configured', () => {
+      const config: APIServiceConfig = {
+        baseUrl: 'https://api.codeguide.app',
+      }
+
+      testService = new TestService(config)
+      const result = testService.testValidateAuthentication()
+
+      expect(result.success).toBe(false)
+      expect(result.error).toContain('No authentication method configured')
+    })
+
+    it('should validate successful database API key authentication', () => {
+      const config: APIServiceConfig = {
+        baseUrl: 'https://api.codeguide.app',
+        databaseApiKey: 'sk_test123',
+      }
+
+      testService = new TestService(config)
+      const result = testService.testValidateAuthentication()
+
+      expect(result.success).toBe(true)
+      expect(result.method?.type).toBe('database-api-key')
+    })
+  })
+
+  describe('HTTP Methods', () => {
+    const config: APIServiceConfig = {
+      baseUrl: 'https://api.codeguide.app',
+      databaseApiKey: 'sk_test123',
+    }
+
+    beforeEach(() => {
+      testService = new TestService(config)
+    })
+
+    it('should make GET requests with authentication headers', async () => {
+      const mockResponse = { data: 'test' }
+      mockAxios.onGet('/v1/test').reply(200, mockResponse)
+
+      const result = await testService.testGet('/test')
+
+      expect(result).toEqual(mockResponse)
+      const request = mockAxios.history.get[0]
+      expect(request.headers?.Authorization).toBe('Bearer sk_test123')
+      expect(request.headers?.['Content-Type']).toBe('application/json')
+    })
+
+    it('should make POST requests with authentication headers', async () => {
+      const mockData = { name: 'test' }
+      const mockResponse = { id: 1, ...mockData }
+      mockAxios.onPost('/v1/test').reply(200, mockResponse)
+
+      const result = await testService.testPost('/test', mockData)
+
+      expect(result).toEqual(mockResponse)
+      const request = mockAxios.history.post[0]
+      expect(request.headers?.Authorization).toBe('Bearer sk_test123')
+      expect(request.headers?.['Content-Type']).toBe('application/json')
+      expect(JSON.parse(request.data)).toEqual(mockData)
+    })
+
+    it('should make PUT requests with authentication headers', async () => {
+      const mockData = { name: 'updated' }
+      const mockResponse = { id: 1, ...mockData }
+      mockAxios.onPut('/v1/test/1').reply(200, mockResponse)
+
+      const result = await testService.testPut('/test/1', mockData)
+
+      expect(result).toEqual(mockResponse)
+      const request = mockAxios.history.put[0]
+      expect(request.headers?.Authorization).toBe('Bearer sk_test123')
+    })
+
+    it('should make DELETE requests with authentication headers', async () => {
+      mockAxios.onDelete('/v1/test/1').reply(204)
+
+      const result = await testService.testDelete('/test/1')
+
+      expect(result).toBeUndefined()
+      const request = mockAxios.history.delete[0]
+      expect(request.headers?.Authorization).toBe('Bearer sk_test123')
+    })
+  })
+
+  describe('Error Handling', () => {
+    const config: APIServiceConfig = {
+      baseUrl: 'https://api.codeguide.app',
+      databaseApiKey: 'sk_test123',
+    }
+
+    beforeEach(() => {
+      testService = new TestService(config)
+    })
+
+    it('should handle 401 authentication errors', async () => {
+      mockAxios.onGet('/v1/test').reply(401, { detail: 'Invalid API key' })
+
+      await expect(testService.testGet('/test')).rejects.toThrow(
+        'Database API key authentication failed: Invalid API key'
+      )
+    })
+
+    it('should handle 403 permission errors', async () => {
+      mockAxios.onGet('/v1/test').reply(403, { detail: 'Insufficient permissions' })
+
+      await expect(testService.testGet('/test')).rejects.toThrow(
+        'Access denied: Insufficient permissions'
+      )
+    })
+
+    it('should handle 429 rate limiting errors', async () => {
+      mockAxios.onGet('/v1/test').reply(429, { detail: 'Too many requests' })
+
+      await expect(testService.testGet('/test')).rejects.toThrow(
+        'Rate limit exceeded: Too many requests'
+      )
+    })
+
+    it('should handle usage limit errors', async () => {
+      mockAxios.onGet('/v1/test').reply(402, { detail: 'Insufficient credits' })
+
+      await expect(testService.testGet('/test')).rejects.toThrow(
+        'Usage limit exceeded: Insufficient credits'
+      )
+    })
+
+    it('should handle generic API errors', async () => {
+      mockAxios.onGet('/v1/test').reply(500, { message: 'Internal server error' })
+
+      await expect(testService.testGet('/test')).rejects.toThrow('API Error: Internal server error')
+    })
+  })
+
+  describe('URL Building', () => {
+    const config: APIServiceConfig = {
+      baseUrl: 'https://api.codeguide.app',
+      databaseApiKey: 'sk_test123',
+    }
+
+    beforeEach(() => {
+      testService = new TestService(config)
+    })
+
+    it('should build URL with leading slash', () => {
+      const url = testService.testBuildUrl('/test')
+      expect(url).toBe('/test')
+    })
+
+    it('should build URL without leading slash', () => {
+      const url = (baseService as any).buildUrl('test')
+      expect(url).toBe('/test')
+    })
+  })
+
+  describe('Base URL Configuration', () => {
+    it('should add /v1 suffix to baseUrl if not present', () => {
+      const config: APIServiceConfig = {
+        baseUrl: 'https://api.codeguide.app',
+        databaseApiKey: 'sk_test123',
+      }
+
+      testService = new TestService(config)
+
+      // Access the internal client to check baseURL
+      const client = (testService as any).client
+      expect(client.defaults.baseURL).toBe('https://api.codeguide.app/v1')
+    })
+
+    it('should not add /v1 suffix if already present', () => {
+      const config: APIServiceConfig = {
+        baseUrl: 'https://api.codeguide.app/v1',
+        databaseApiKey: 'sk_test123',
+      }
+
+      testService = new TestService(config)
+
+      const client = (testService as any).client
+      expect(client.defaults.baseURL).toBe('https://api.codeguide.app/v1')
+    })
+
+    it('should handle baseUrl with trailing slash', () => {
+      const config: APIServiceConfig = {
+        baseUrl: 'https://api.codeguide.app/',
+        databaseApiKey: 'sk_test123',
+      }
+
+      testService = new TestService(config)
+
+      const client = (testService as any).client
+      expect(client.defaults.baseURL).toBe('https://api.codeguide.app/v1')
+    })
+  })
+})

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

@@ -0,0 +1,294 @@
+import { GenerationService } from '../../../services/generation/generation-service'
+import { APIServiceConfig } from '../../../types'
+import axios from 'axios'
+import MockAdapter from 'axios-mock-adapter'
+
+describe('GenerationService', () => {
+  let mockAxios: MockAdapter
+  let generationService: GenerationService
+  let config: APIServiceConfig
+
+  beforeEach(() => {
+    mockAxios = new MockAdapter(axios)
+    config = {
+      baseUrl: 'https://api.codeguide.app',
+      databaseApiKey: 'sk_test123',
+    }
+    generationService = new GenerationService(config)
+  })
+
+  afterEach(() => {
+    mockAxios.restore()
+  })
+
+  describe('refinePrompt', () => {
+    it('should refine prompt successfully', async () => {
+      const request = {
+        user_prompt: 'How to create a React component?',
+        language: 'typescript',
+        context: 'CLI testing',
+      }
+
+      const response = {
+        refined_prompt:
+          'To create a React component in TypeScript, you can define a functional component with proper typing...',
+        original_prompt: 'How to create a React component?',
+      }
+
+      mockAxios.onPost('/v1/generation/refine-prompt', request).reply(200, response)
+
+      const result = await generationService.refinePrompt(request)
+
+      expect(result).toEqual(response)
+    })
+
+    it('should handle refine prompt errors', async () => {
+      const request = {
+        user_prompt: 'Invalid prompt',
+      }
+
+      mockAxios.onPost('/v1/generation/refine-prompt', request).reply(400, {
+        detail: 'Prompt cannot be empty',
+      })
+
+      await expect(generationService.refinePrompt(request)).rejects.toThrow(
+        'API Error: Prompt cannot be empty'
+      )
+    })
+
+    it('should work with minimal request', async () => {
+      const request = {
+        user_prompt: 'Simple prompt',
+      }
+
+      const response = {
+        refined_prompt: 'Refined response',
+        original_prompt: 'Simple prompt',
+      }
+
+      mockAxios.onPost('/v1/generation/refine-prompt', request).reply(200, response)
+
+      const result = await generationService.refinePrompt(request)
+
+      expect(result).toEqual(response)
+    })
+  })
+
+  describe('generateCode', () => {
+    it('should generate code successfully', async () => {
+      const request = {
+        prompt: 'Create a function to calculate factorial',
+        language: 'javascript',
+        context: 'Math utility function',
+      }
+
+      const response = {
+        generated_code:
+          'function factorial(n) {\n  if (n <= 1) return 1;\n  return n * factorial(n - 1);\n}',
+        explanation: 'This function calculates the factorial of a number using recursion.',
+        language: 'javascript',
+      }
+
+      mockAxios.onPost('/v1/generation/generate-code', request).reply(200, response)
+
+      const result = await generationService.generateCode(request)
+
+      expect(result).toEqual(response)
+    })
+
+    it('should handle code generation errors', async () => {
+      const request = {
+        prompt: 'Create malicious code',
+        language: 'javascript',
+      }
+
+      mockAxios.onPost('/v1/generation/generate-code', request).reply(400, {
+        detail: 'Request cannot be fulfilled due to safety constraints',
+      })
+
+      await expect(generationService.generateCode(request)).rejects.toThrow(
+        'API Error: Request cannot be fulfilled due to safety constraints'
+      )
+    })
+  })
+
+  describe('refineCode', () => {
+    it('should refine code successfully', async () => {
+      const request = {
+        code: 'function add(a, b) { return a + b; }',
+        language: 'javascript',
+        refinement_prompt: 'Add input validation',
+        context: 'Utility function',
+      }
+
+      const response = {
+        refined_code:
+          'function add(a, b) {\n  if (typeof a !== "number" || typeof b !== "number") {\n    throw new Error("Both arguments must be numbers");\n  }\n  return a + b;\n}',
+        explanation: 'Added type validation to ensure both arguments are numbers.',
+        original_code: 'function add(a, b) { return a + b; }',
+        language: 'javascript',
+      }
+
+      mockAxios.onPost('/v1/generation/refine-code', request).reply(200, response)
+
+      const result = await generationService.refineCode(request)
+
+      expect(result).toEqual(response)
+    })
+
+    it('should handle code refinement errors', async () => {
+      const request = {
+        code: 'invalid code syntax',
+        language: 'javascript',
+      }
+
+      mockAxios.onPost('/v1/generation/refine-code', request).reply(400, {
+        detail: 'Invalid code syntax',
+      })
+
+      await expect(generationService.refineCode(request)).rejects.toThrow(
+        'API Error: Invalid code syntax'
+      )
+    })
+  })
+
+  describe('explainCode', () => {
+    it('should explain code successfully', async () => {
+      const request = {
+        code: 'const factorial = n => n <= 1 ? 1 : n * factorial(n - 1);',
+        language: 'javascript',
+      }
+
+      const response = {
+        explanation:
+          'This is a recursive arrow function that calculates the factorial of a number.',
+        breakdown: [
+          {
+            line: 1,
+            explanation: 'Defines a constant factorial using arrow function syntax',
+          },
+          {
+            line: 1,
+            explanation: 'Uses ternary operator for base case (n <= 1) and recursive case',
+          },
+        ],
+        language: 'javascript',
+      }
+
+      mockAxios.onPost('/v1/generation/explain-code', request).reply(200, response)
+
+      const result = await generationService.explainCode(request)
+
+      expect(result).toEqual(response)
+    })
+
+    it('should handle code explanation errors', async () => {
+      const request = {
+        code: 'incomplete code',
+        language: 'python',
+      }
+
+      mockAxios.onPost('/v1/generation/explain-code', request).reply(400, {
+        detail: 'Cannot explain incomplete code',
+      })
+
+      await expect(generationService.explainCode(request)).rejects.toThrow(
+        'API Error: Cannot explain incomplete code'
+      )
+    })
+  })
+
+  describe('getSuggestions', () => {
+    it('should get code suggestions successfully', async () => {
+      const request = {
+        code: 'function calculateSum(arr) {\n  // TODO: Implement sum calculation\n}',
+        language: 'javascript',
+        cursor_position: 50,
+        context: 'Array processing function',
+      }
+
+      const response = {
+        suggestions: [
+          {
+            suggestion: 'return arr.reduce((sum, num) => sum + num, 0);',
+            explanation: 'Use reduce method to calculate sum of array elements',
+            confidence: 0.95,
+          },
+          {
+            suggestion: 'let sum = 0;\nfor (const num of arr) {\n  sum += num;\n}\nreturn sum;',
+            explanation: 'Use traditional for loop for better performance with large arrays',
+            confidence: 0.85,
+          },
+        ],
+        language: 'javascript',
+      }
+
+      mockAxios.onPost('/v1/generation/suggestions', request).reply(200, response)
+
+      const result = await generationService.getSuggestions(request)
+
+      expect(result).toEqual(response)
+    })
+
+    it('should handle suggestion request errors', async () => {
+      const request = {
+        code: 'invalid code',
+        language: 'javascript',
+      }
+
+      mockAxios.onPost('/v1/generation/suggestions', request).reply(400, {
+        detail: 'Cannot generate suggestions for invalid code',
+      })
+
+      await expect(generationService.getSuggestions(request)).rejects.toThrow(
+        'API Error: Cannot generate suggestions for invalid code'
+      )
+    })
+  })
+
+  describe('Authentication Integration', () => {
+    it('should use correct authentication headers for all requests', async () => {
+      const request = {
+        user_prompt: 'Test prompt',
+      }
+
+      const response = {
+        refined_prompt: 'Test response',
+      }
+
+      mockAxios.onPost('/v1/generation/refine-prompt', request).reply(200, response)
+
+      await generationService.refinePrompt(request)
+
+      const mockRequest = mockAxios.history.post[0]
+      expect(mockRequest.headers?.Authorization).toBe('Bearer sk_test123')
+      expect(mockRequest.headers?.['Content-Type']).toBe('application/json')
+    })
+
+    it('should work with different authentication methods', async () => {
+      const legacyConfig: APIServiceConfig = {
+        baseUrl: 'https://api.codeguide.app',
+        apiKey: 'legacy_key',
+        userId: 'user123',
+      }
+
+      const legacyService = new GenerationService(legacyConfig)
+
+      const request = {
+        user_prompt: 'Test prompt',
+      }
+
+      const response = {
+        refined_prompt: 'Test response',
+      }
+
+      mockAxios.onPost('/v1/generation/refine-prompt', request).reply(200, response)
+
+      await legacyService.refinePrompt(request)
+
+      const mockRequest = mockAxios.history.post[0]
+      expect(mockRequest.headers?.['X-API-Key']).toBe('legacy_key')
+      expect(mockRequest.headers?.['X-User-ID']).toBe('user123')
+    })
+  })
+})