@cobbl-ai/sdk 0.1.0

package/src/__tests__/client.test.ts

@@ -0,0 +1,650 @@
+import { CobblClient } from '../client'
+import { CobblError } from '../errors'
+
+// Mock fetch globally
+const mockFetch = jest.fn()
+global.fetch = mockFetch as any
+
+describe('CobblClient', () => {
+  const validApiKey = 'test-api-key-123'
+  const mockBaseUrl = 'https://api.cobbl.ai'
+
+  beforeEach(() => {
+    mockFetch.mockClear()
+    delete process.env.COBBL_API_URL
+  })
+
+  describe('constructor', () => {
+    it('should create a client with valid API key', () => {
+      const client = new CobblClient({ apiKey: validApiKey })
+
+      expect(client).toBeInstanceOf(CobblClient)
+    })
+
+    it('should throw error when API key is missing', () => {
+      expect(() => new CobblClient({ apiKey: '' })).toThrow(CobblError)
+      expect(() => new CobblClient({ apiKey: '' })).toThrow(
+        'API key is required'
+      )
+    })
+
+    it('should throw error when API key is only whitespace', () => {
+      expect(() => new CobblClient({ apiKey: '   ' })).toThrow(CobblError)
+      expect(() => new CobblClient({ apiKey: '   ' })).toThrow(
+        'API key is required'
+      )
+    })
+
+    it('should throw INVALID_CONFIG error code', () => {
+      try {
+        new CobblClient({ apiKey: '' })
+        fail('Should have thrown')
+      } catch (error) {
+        expect(error).toBeInstanceOf(CobblError)
+        expect((error as CobblError).code).toBe('INVALID_CONFIG')
+      }
+    })
+  })
+
+  describe('runPrompt', () => {
+    let client: CobblClient
+
+    beforeEach(() => {
+      client = new CobblClient({ apiKey: validApiKey })
+    })
+
+    it('should successfully run a prompt', async () => {
+      const mockResponse = {
+        runId: 'run-123',
+        output: 'AI generated response',
+        tokenUsage: { promptTokens: 10, completionTokens: 20, totalTokens: 30 },
+        renderedPrompt: 'Summarize Q4 Results in a friendly tone',
+        promptVersion: {
+          id: 'version-1',
+          promptId: 'prompt-1',
+          version: 1,
+          provider: 'openai',
+          model: 'gpt-4',
+          template: 'Summarize {{topic}} in a {{tone}} tone',
+          variables: ['topic', 'tone'],
+          isActive: true,
+          createdAt: new Date('2024-01-01'),
+          metadata: {},
+        },
+      }
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockResponse,
+      })
+
+      const result = await client.runPrompt('sales_summary', {
+        topic: 'Q4 Results',
+        tone: 'friendly',
+      })
+
+      expect(result).toEqual(mockResponse)
+      expect(mockFetch).toHaveBeenCalledTimes(1)
+      expect(mockFetch).toHaveBeenCalledWith(
+        `${mockBaseUrl}/prompt/run`,
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining({
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${validApiKey}`,
+          }),
+          body: JSON.stringify({
+            promptSlug: 'sales_summary',
+            input: { topic: 'Q4 Results', tone: 'friendly' },
+          }),
+        })
+      )
+    })
+
+    it('should trim the promptSlug', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          runId: 'run-123',
+          output: 'test',
+          tokenUsage: {
+            promptTokens: 10,
+            completionTokens: 20,
+            totalTokens: 30,
+          },
+          renderedPrompt: 'test',
+          promptVersion: {
+            id: 'v1',
+            promptId: 'p1',
+            version: 1,
+            provider: 'openai',
+            model: 'gpt-4',
+            template: 'test',
+            variables: [],
+            isActive: true,
+            createdAt: new Date(),
+            metadata: {},
+          },
+        }),
+      })
+
+      await client.runPrompt('  sales_summary  ', {})
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          body: expect.stringContaining('"promptSlug":"sales_summary"'),
+        })
+      )
+    })
+
+    it('should throw error when promptSlug is empty', async () => {
+      await expect(client.runPrompt('', {})).rejects.toThrow(CobblError)
+      await expect(client.runPrompt('', {})).rejects.toThrow(
+        'promptSlug is required'
+      )
+    })
+
+    it('should throw error when promptSlug is only whitespace', async () => {
+      await expect(client.runPrompt('   ', {})).rejects.toThrow(CobblError)
+    })
+
+    it('should throw INVALID_REQUEST error for empty promptSlug', async () => {
+      try {
+        await client.runPrompt('', {})
+        fail('Should have thrown')
+      } catch (error) {
+        expect(error).toBeInstanceOf(CobblError)
+        expect((error as CobblError).code).toBe('INVALID_REQUEST')
+      }
+    })
+
+    it('should handle 400 Bad Request', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 400,
+        statusText: 'Bad Request',
+        json: async () => ({ error: 'Invalid input variables' }),
+      })
+
+      try {
+        await client.runPrompt('test', {})
+        fail('Should have thrown')
+      } catch (error) {
+        expect(error).toBeInstanceOf(CobblError)
+        expect((error as CobblError).message).toBe('Invalid input variables')
+      }
+    })
+
+    it('should handle 401 Unauthorized', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 401,
+        statusText: 'Unauthorized',
+        json: async () => ({ error: 'Invalid API key' }),
+      })
+
+      try {
+        await client.runPrompt('test', {})
+        fail('Should have thrown')
+      } catch (error) {
+        expect(error).toBeInstanceOf(CobblError)
+        expect((error as CobblError).code).toBe('UNAUTHORIZED')
+        expect((error as CobblError).message).toBe('Invalid API key')
+      }
+    })
+
+    it('should handle 404 Not Found', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 404,
+        statusText: 'Not Found',
+        json: async () => ({ error: 'Prompt not found' }),
+      })
+
+      try {
+        await client.runPrompt('nonexistent', {})
+        fail('Should have thrown')
+      } catch (error) {
+        expect(error).toBeInstanceOf(CobblError)
+        expect((error as CobblError).code).toBe('NOT_FOUND')
+      }
+    })
+
+    it('should handle 429 Rate Limit Exceeded', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 429,
+        statusText: 'Too Many Requests',
+        json: async () => ({ error: 'Rate limit exceeded' }),
+      })
+
+      try {
+        await client.runPrompt('test', {})
+        fail('Should have thrown')
+      } catch (error) {
+        expect(error).toBeInstanceOf(CobblError)
+        expect((error as CobblError).code).toBe('RATE_LIMIT_EXCEEDED')
+      }
+    })
+
+    it('should handle 500 Server Error', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 500,
+        statusText: 'Internal Server Error',
+        json: async () => ({ error: 'Server error' }),
+      })
+
+      try {
+        await client.runPrompt('test', {})
+        fail('Should have thrown')
+      } catch (error) {
+        expect(error).toBeInstanceOf(CobblError)
+        expect((error as CobblError).code).toBe('SERVER_ERROR')
+      }
+    })
+
+    it('should handle network errors', async () => {
+      mockFetch.mockRejectedValueOnce(new Error('Network failure'))
+
+      try {
+        await client.runPrompt('test', {})
+        fail('Should have thrown')
+      } catch (error) {
+        expect(error).toBeInstanceOf(CobblError)
+        expect((error as CobblError).code).toBe('NETWORK_ERROR')
+        expect((error as CobblError).message).toContain('Network failure')
+      }
+    })
+
+    it('should handle non-JSON error responses', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 500,
+        statusText: 'Internal Server Error',
+        json: async () => {
+          throw new Error('Invalid JSON')
+        },
+      })
+
+      try {
+        await client.runPrompt('test', {})
+        fail('Should have thrown')
+      } catch (error) {
+        expect(error).toBeInstanceOf(CobblError)
+        expect((error as CobblError).code).toBe('API_ERROR')
+        expect((error as CobblError).message).toContain('HTTP 500')
+      }
+    })
+
+    it('should use custom API URL from environment', async () => {
+      process.env.COBBL_API_URL = 'https://custom.api.com'
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          runId: 'run-123',
+          output: 'test',
+          tokenUsage: {
+            promptTokens: 10,
+            completionTokens: 20,
+            totalTokens: 30,
+          },
+          renderedPrompt: 'test',
+          promptVersion: {
+            id: 'v1',
+            promptId: 'p1',
+            version: 1,
+            provider: 'openai',
+            model: 'gpt-4',
+            template: 'test',
+            variables: [],
+            isActive: true,
+            createdAt: new Date(),
+            metadata: {},
+          },
+        }),
+      })
+
+      await client.runPrompt('test', {})
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        'https://custom.api.com/prompt/run',
+        expect.any(Object)
+      )
+    })
+
+    it('should have a request timeout configured', () => {
+      // This test verifies that the client has timeout logic
+      // The actual timeout behavior is tested through integration tests
+      // Testing with real timers would make the test suite slow
+      expect(client).toBeDefined()
+
+      // The timeout is hardcoded in client.ts as REQUEST_TIMEOUT_MS = 30_000
+      // This test ensures we remember to test timeout behavior if we change it
+    })
+  })
+
+  describe('submitFeedback', () => {
+    let client: CobblClient
+
+    beforeEach(() => {
+      client = new CobblClient({ apiKey: validApiKey })
+    })
+
+    it('should successfully submit feedback', async () => {
+      const mockResponse = {
+        feedbackId: 'feedback-123',
+        message: 'Feedback submitted successfully',
+      }
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockResponse,
+      })
+
+      const result = await client.submitFeedback({
+        runId: 'run-123',
+        helpful: 'not_helpful',
+        userFeedback: 'Too formal',
+      })
+
+      expect(result).toEqual(mockResponse)
+      expect(mockFetch).toHaveBeenCalledTimes(1)
+      expect(mockFetch).toHaveBeenCalledWith(
+        `${mockBaseUrl}/feedback`,
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining({
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${validApiKey}`,
+          }),
+          body: JSON.stringify({
+            runId: 'run-123',
+            helpful: 'not_helpful',
+            userFeedback: 'Too formal',
+          }),
+        })
+      )
+    })
+
+    it('should trim runId and userFeedback', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ feedbackId: 'fb-123', message: 'Success' }),
+      })
+
+      await client.submitFeedback({
+        runId: '  run-123  ',
+        helpful: 'helpful',
+        userFeedback: '  Great response!  ',
+      })
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          body: expect.stringContaining('"runId":"run-123"'),
+        })
+      )
+      expect(mockFetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          body: expect.stringContaining('"userFeedback":"Great response!"'),
+        })
+      )
+    })
+
+    it('should throw error when runId is empty', async () => {
+      await expect(
+        client.submitFeedback({
+          runId: '',
+          helpful: 'helpful',
+          userFeedback: 'test',
+        })
+      ).rejects.toThrow(CobblError)
+      await expect(
+        client.submitFeedback({
+          runId: '',
+          helpful: 'helpful',
+          userFeedback: 'test',
+        })
+      ).rejects.toThrow('runId is required')
+    })
+
+    it('should throw error when userFeedback is empty', async () => {
+      await expect(
+        client.submitFeedback({
+          runId: 'run-123',
+          helpful: 'helpful',
+          userFeedback: '',
+        })
+      ).rejects.toThrow(CobblError)
+      await expect(
+        client.submitFeedback({
+          runId: 'run-123',
+          helpful: 'helpful',
+          userFeedback: '',
+        })
+      ).rejects.toThrow('userFeedback is required')
+    })
+
+    it('should throw error when helpful is invalid', async () => {
+      await expect(
+        client.submitFeedback({
+          runId: 'run-123',
+          helpful: 'invalid' as any,
+          userFeedback: 'test',
+        })
+      ).rejects.toThrow(CobblError)
+      await expect(
+        client.submitFeedback({
+          runId: 'run-123',
+          helpful: 'invalid' as any,
+          userFeedback: 'test',
+        })
+      ).rejects.toThrow('helpful must be either "helpful" or "not_helpful"')
+    })
+
+    it('should throw error when helpful is missing', async () => {
+      await expect(
+        client.submitFeedback({
+          runId: 'run-123',
+          helpful: '' as any,
+          userFeedback: 'test',
+        })
+      ).rejects.toThrow(CobblError)
+    })
+
+    it('should accept "helpful" value', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ feedbackId: 'fb-123', message: 'Success' }),
+      })
+
+      await client.submitFeedback({
+        runId: 'run-123',
+        helpful: 'helpful',
+        userFeedback: 'Great!',
+      })
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          body: expect.stringContaining('"helpful":"helpful"'),
+        })
+      )
+    })
+
+    it('should accept "not_helpful" value', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ feedbackId: 'fb-123', message: 'Success' }),
+      })
+
+      await client.submitFeedback({
+        runId: 'run-123',
+        helpful: 'not_helpful',
+        userFeedback: 'Needs work',
+      })
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          body: expect.stringContaining('"helpful":"not_helpful"'),
+        })
+      )
+    })
+
+    it('should handle 400 Bad Request', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 400,
+        statusText: 'Bad Request',
+        json: async () => ({ error: 'Invalid feedback data' }),
+      })
+
+      try {
+        await client.submitFeedback({
+          runId: 'run-123',
+          helpful: 'helpful',
+          userFeedback: 'test',
+        })
+        fail('Should have thrown')
+      } catch (error) {
+        expect(error).toBeInstanceOf(CobblError)
+        expect((error as CobblError).code).toBe('INVALID_REQUEST')
+      }
+    })
+
+    it('should handle 401 Unauthorized', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 401,
+        statusText: 'Unauthorized',
+        json: async () => ({ error: 'Invalid API key' }),
+      })
+
+      try {
+        await client.submitFeedback({
+          runId: 'run-123',
+          helpful: 'helpful',
+          userFeedback: 'test',
+        })
+        fail('Should have thrown')
+      } catch (error) {
+        expect(error).toBeInstanceOf(CobblError)
+        expect((error as CobblError).code).toBe('UNAUTHORIZED')
+      }
+    })
+
+    it('should handle 404 Not Found', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 404,
+        statusText: 'Not Found',
+        json: async () => ({ error: 'Run ID not found' }),
+      })
+
+      try {
+        await client.submitFeedback({
+          runId: 'nonexistent',
+          helpful: 'helpful',
+          userFeedback: 'test',
+        })
+        fail('Should have thrown')
+      } catch (error) {
+        expect(error).toBeInstanceOf(CobblError)
+        expect((error as CobblError).code).toBe('NOT_FOUND')
+      }
+    })
+
+    it('should handle network errors', async () => {
+      mockFetch.mockRejectedValueOnce(new Error('Network failure'))
+
+      try {
+        await client.submitFeedback({
+          runId: 'run-123',
+          helpful: 'helpful',
+          userFeedback: 'test',
+        })
+        fail('Should have thrown')
+      } catch (error) {
+        expect(error).toBeInstanceOf(CobblError)
+        expect((error as CobblError).code).toBe('NETWORK_ERROR')
+        expect((error as CobblError).message).toContain('Network failure')
+      }
+    })
+  })
+
+  describe('error handling with details', () => {
+    let client: CobblClient
+
+    beforeEach(() => {
+      client = new CobblClient({ apiKey: validApiKey })
+    })
+
+    it('should include error details from API response', async () => {
+      const errorDetails = {
+        missingVariables: ['topic', 'tone'],
+        promptId: 'prompt-123',
+      }
+
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 400,
+        statusText: 'Bad Request',
+        json: async () => ({
+          error: 'Missing required variables',
+          details: errorDetails,
+        }),
+      })
+
+      try {
+        await client.runPrompt('test', {})
+        fail('Should have thrown')
+      } catch (error) {
+        expect(error).toBeInstanceOf(CobblError)
+        expect((error as CobblError).details).toEqual(errorDetails)
+      }
+    })
+
+    it('should handle error with message field instead of error field', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 400,
+        statusText: 'Bad Request',
+        json: async () => ({ message: 'Custom error message' }),
+      })
+
+      try {
+        await client.runPrompt('test', {})
+        fail('Should have thrown')
+      } catch (error) {
+        expect(error).toBeInstanceOf(CobblError)
+        expect((error as CobblError).message).toBe('Custom error message')
+      }
+    })
+
+    it('should handle generic server errors (502, 503, 504)', async () => {
+      const statuses = [502, 503, 504]
+
+      for (const status of statuses) {
+        mockFetch.mockResolvedValueOnce({
+          ok: false,
+          status,
+          statusText: 'Server Error',
+          json: async () => ({ error: 'Server unavailable' }),
+        })
+
+        try {
+          await client.runPrompt('test', {})
+          fail('Should have thrown')
+        } catch (error) {
+          expect(error).toBeInstanceOf(CobblError)
+          expect((error as CobblError).code).toBe('SERVER_ERROR')
+        }
+      }
+    })
+  })
+})