qa360 2.1.2 → 2.1.4

package/core/src/ai/__tests__/deepseek-provider.test.ts

@@ -0,0 +1,586 @@
+/**
+ * DeepSeek Provider Tests
+ *
+ * Comprehensive test suite for DeepSeek LLM provider.
+ * Target: ≥80% coverage
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  DeepSeekProvider,
+  createDeepSeekProvider,
+  checkDeepSeekSetup,
+  getDeepSeekSetupInstructions,
+  DeepSeekError,
+  type DeepSeekConfig
+} from '../deepseek-provider.js';
+
+// Mock fetch for testing
+const mockFetch = vi.fn();
+global.fetch = mockFetch;
+
+describe('DeepSeekProvider', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('Constructor', () => {
+    it('should create provider with default config', () => {
+      const provider = new DeepSeekProvider();
+
+      expect(provider.name).toBe('deepseek');
+      expect(provider.models).toEqual([
+        'deepseek-chat',
+        'deepseek-coder',
+        'deepseek-reasoner'
+      ]);
+    });
+
+    it('should use custom config when provided', () => {
+      const config: DeepSeekConfig = {
+        apiKey: 'test-key',
+        baseURL: 'https://custom.api.com',
+        model: 'deepseek-coder',
+        timeout: 30000
+      };
+      const provider = new DeepSeekProvider(config);
+
+      expect(provider.name).toBe('deepseek');
+    });
+
+    it('should read API key from environment variable', () => {
+      process.env.DEEPSEEK_API_KEY = 'env-key';
+
+      const provider = new DeepSeekProvider();
+      expect(provider).toBeDefined();
+
+      delete process.env.DEEPSEEK_API_KEY;
+    });
+
+    it('should use default base URL', () => {
+      const provider = new DeepSeekProvider();
+      expect(provider).toBeDefined();
+    });
+
+    it('should use default model', () => {
+      process.env.DEEPSEEK_MODEL = 'deepseek-coder';
+      const provider = new DeepSeekProvider();
+      expect(provider).toBeDefined();
+      delete process.env.DEEPSEEK_MODEL;
+    });
+  });
+
+  describe('isAvailable', () => {
+    it('should return false when no API key', async () => {
+      const provider = new DeepSeekProvider({ apiKey: '' });
+
+      const available = await provider.isAvailable();
+
+      expect(available).toBe(false);
+      expect(mockFetch).not.toHaveBeenCalled();
+    });
+
+    it('should return true when API call succeeds', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ object: 'list' })
+      });
+
+      const provider = new DeepSeekProvider({ apiKey: 'test-key' });
+      const available = await provider.isAvailable();
+
+      expect(available).toBe(true);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'https://api.deepseek.com/v1/models',
+        expect.objectContaining({
+          method: 'GET',
+          headers: { Authorization: 'Bearer test-key' }
+        })
+      );
+    });
+
+    it('should return false when API call fails', async () => {
+      mockFetch.mockRejectedValueOnce(new Error('Network error'));
+
+      const provider = new DeepSeekProvider({ apiKey: 'test-key' });
+      const available = await provider.isAvailable();
+
+      expect(available).toBe(false);
+    });
+
+    it('should return false on 401 response', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 401
+      });
+
+      const provider = new DeepSeekProvider({ apiKey: 'invalid-key' });
+      const available = await provider.isAvailable();
+
+      expect(available).toBe(false);
+    });
+
+    it('should timeout after 5 seconds', async () => {
+      // Mock fetch to hang indefinitely, but with AbortSignal handling
+      mockFetch.mockImplementationOnce((_url: string, options: RequestInit = {}) => {
+        return new Promise((resolve, reject) => {
+          const signal = options.signal as AbortSignal;
+          if (signal) {
+            signal.addEventListener('abort', () => {
+              reject(new DOMException('Aborted', 'AbortError'));
+            });
+          }
+          // Never resolve normally
+        });
+      });
+
+      const provider = new DeepSeekProvider({ apiKey: 'test-key' });
+      const start = Date.now();
+      const available = await provider.isAvailable();
+      const duration = Date.now() - start;
+
+      expect(available).toBe(false);
+      expect(duration).toBeLessThan(8000); // Should timeout around 5s (with margin)
+    }, 15000);
+  });
+
+  describe('generate', () => {
+    const mockSuccessResponse = {
+      choices: [
+        {
+          message: { content: 'Test response' },
+          finish_reason: 'stop'
+        }
+      ],
+      usage: {
+        prompt_tokens: 10,
+        completion_tokens: 20,
+        total_tokens: 30
+      },
+      model: 'deepseek-chat'
+    };
+
+    it('should throw error when no API key', async () => {
+      const provider = new DeepSeekProvider({ apiKey: '' });
+
+      await expect(provider.generate({ prompt: 'test' }))
+        .rejects.toThrow(DeepSeekError);
+    });
+
+    it('should send correct request to API', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockSuccessResponse
+      });
+
+      const provider = new DeepSeekProvider({ apiKey: 'test-key' });
+      const response = await provider.generate({
+        prompt: 'Hello, world!'
+      });
+
+      expect(response.content).toBe('Test response');
+      expect(response.usage.promptTokens).toBe(10);
+      expect(response.usage.completionTokens).toBe(20);
+      expect(response.usage.totalTokens).toBe(30);
+      expect(response.model).toBe('deepseek-chat');
+      expect(response.finishReason).toBe('stop');
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        'https://api.deepseek.com/v1/chat/completions',
+        expect.objectContaining({
+          method: 'POST',
+          headers: {
+            Authorization: 'Bearer test-key',
+            'Content-Type': 'application/json'
+          }
+        })
+      );
+    });
+
+    it('should include system prompt in messages', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockSuccessResponse
+      });
+
+      const provider = new DeepSeekProvider({ apiKey: 'test-key' });
+      await provider.generate({
+        prompt: 'Test',
+        systemPrompt: 'You are a helpful assistant'
+      });
+
+      const callArgs = JSON.parse(mockFetch.mock.calls[0][1].body);
+      expect(callArgs.messages).toEqual([
+        { role: 'system', content: 'You are a helpful assistant' },
+        { role: 'user', content: 'Test' }
+      ]);
+    });
+
+    it('should use custom temperature', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockSuccessResponse
+      });
+
+      const provider = new DeepSeekProvider({ apiKey: 'test-key' });
+      await provider.generate({
+        prompt: 'Test',
+        temperature: 0.3
+      });
+
+      const callArgs = JSON.parse(mockFetch.mock.calls[0][1].body);
+      expect(callArgs.temperature).toBe(0.3);
+    });
+
+    it('should use custom max tokens', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockSuccessResponse
+      });
+
+      const provider = new DeepSeekProvider({ apiKey: 'test-key' });
+      await provider.generate({
+        prompt: 'Test',
+        maxTokens: 2048
+      });
+
+      const callArgs = JSON.parse(mockFetch.mock.calls[0][1].body);
+      expect(callArgs.max_tokens).toBe(2048);
+    });
+
+    it('should handle API error response', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 400,
+        text: async () => 'Invalid request'
+      });
+
+      const provider = new DeepSeekProvider({ apiKey: 'test-key' });
+
+      await expect(provider.generate({ prompt: 'Test' }))
+        .rejects.toThrow(DeepSeekError);
+    });
+
+    it('should handle network error', async () => {
+      mockFetch.mockRejectedValueOnce(new Error('Network error'));
+
+      const provider = new DeepSeekProvider({ apiKey: 'test-key' });
+
+      await expect(provider.generate({ prompt: 'Test' }))
+        .rejects.toThrow();
+    });
+
+    it('should throw when no choices in response', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ choices: [] })
+      });
+
+      const provider = new DeepSeekProvider({ apiKey: 'test-key' });
+
+      await expect(provider.generate({ prompt: 'Test' }))
+        .rejects.toThrow(DeepSeekError);
+    });
+
+    it('should set finish_reason to length when not stop', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          choices: [
+            {
+              message: { content: 'Test' },
+              finish_reason: 'length'
+            }
+          ],
+          usage: { prompt_tokens: 10, completion_tokens: 10, total_tokens: 20 },
+          model: 'deepseek-chat'
+        })
+      });
+
+      const provider = new DeepSeekProvider({ apiKey: 'test-key' });
+      const response = await provider.generate({ prompt: 'Test' });
+
+      expect(response.finishReason).toBe('length');
+    });
+
+    it('should use default temperature when not provided', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockSuccessResponse
+      });
+
+      const provider = new DeepSeekProvider({ apiKey: 'test-key' });
+      await provider.generate({ prompt: 'Test' });
+
+      const callArgs = JSON.parse(mockFetch.mock.calls[0][1].body);
+      expect(callArgs.temperature).toBe(0.7);
+    });
+
+    it('should use default maxTokens when not provided', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockSuccessResponse
+      });
+
+      const provider = new DeepSeekProvider({ apiKey: 'test-key' });
+      await provider.generate({ prompt: 'Test' });
+
+      const callArgs = JSON.parse(mockFetch.mock.calls[0][1].body);
+      expect(callArgs.max_tokens).toBe(4096);
+    });
+  });
+
+  describe('stream', () => {
+    it('should throw error when no API key', async () => {
+      const provider = new DeepSeekProvider({ apiKey: '' });
+
+      const stream = provider.stream({ prompt: 'test' });
+      const chunks: string[] = [];
+
+      try {
+        for await (const chunk of stream) {
+          chunks.push(chunk);
+        }
+        expect(true).toBe(false); // Should not reach here
+      } catch (error) {
+        expect(error).toBeInstanceOf(DeepSeekError);
+      }
+    });
+
+    it('should stream response chunks', async () => {
+      const streamData = [
+        'data: {"choices":[{"delta":{"content":"Hello"}}]}\n\n',
+        'data: {"choices":[{"delta":{"content":" world"}}]}\n\n',
+        'data: {"choices":[{"delta":{"content":"!"}}]}\n\n',
+        'data: [DONE]\n\n'
+      ].join('');
+
+      let readCount = 0;
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        body: {
+          getReader: () => ({
+            read: async () => {
+              readCount++;
+              if (readCount === 1) {
+                return { done: false, value: new TextEncoder().encode(streamData) };
+              }
+              return { done: true, value: new Uint8Array() };
+            }
+          })
+        }
+      });
+
+      const provider = new DeepSeekProvider({ apiKey: 'test-key' });
+      const chunks: string[] = [];
+
+      for await (const chunk of provider.stream({ prompt: 'Test' })) {
+        chunks.push(chunk);
+      }
+
+      expect(chunks).toEqual(['Hello', ' world', '!']);
+    });
+
+    it('should handle incomplete JSON in stream', async () => {
+      const streamData = [
+        'data: {"choices":[{"delta":{"content":"Valid"}}]}\n\n',
+        'data: invalid json\n\n',  // Should be ignored
+        'data: {"choices":[{"delta":{"content":" data"}}]}\n\n',
+        'data: [DONE]\n\n'
+      ].join('');
+
+      let readCount = 0;
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        body: {
+          getReader: () => ({
+            read: async () => {
+              readCount++;
+              if (readCount === 1) {
+                return { done: false, value: new TextEncoder().encode(streamData) };
+              }
+              return { done: true, value: new Uint8Array() };
+            }
+          })
+        }
+      });
+
+      const provider = new DeepSeekProvider({ apiKey: 'test-key' });
+      const chunks: string[] = [];
+
+      for await (const chunk of provider.stream({ prompt: 'Test' })) {
+        chunks.push(chunk);
+      }
+
+      expect(chunks).toEqual(['Valid', ' data']);
+    });
+
+    it('should handle empty content in stream', async () => {
+      const streamData = [
+        'data: {"choices":[]}\n\n',
+        'data: [DONE]\n\n'
+      ].join('');
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        body: {
+          getReader: () => ({
+            read: async () => ({
+              done: true,
+              value: new TextEncoder().encode(streamData)
+            })
+          })
+        }
+      });
+
+      const provider = new DeepSeekProvider({ apiKey: 'test-key' });
+      const chunks: string[] = [];
+
+      for await (const chunk of provider.stream({ prompt: 'Test' })) {
+        chunks.push(chunk);
+      }
+
+      expect(chunks).toEqual([]);
+    });
+  });
+
+  describe('countTokens', () => {
+    it('should estimate token count for short text', () => {
+      const provider = new DeepSeekProvider();
+      const tokens = provider.countTokens('Hello world');
+
+      expect(tokens).toBeGreaterThan(0);
+      expect(tokens).toBeLessThan(20);
+    });
+
+    it('should estimate token count for long text', () => {
+      const provider = new DeepSeekProvider();
+      const longText = 'a'.repeat(1000);
+      const tokens = provider.countTokens(longText);
+
+      expect(tokens).toBe(250); // 1000 / 4
+    });
+
+    it('should handle empty string', () => {
+      const provider = new DeepSeekProvider();
+      const tokens = provider.countTokens('');
+
+      expect(tokens).toBe(0);
+    });
+  });
+
+  describe('estimateCost', () => {
+    it('should estimate cost for generation', () => {
+      const provider = new DeepSeekProvider({ apiKey: 'test' });
+      const cost = provider.estimateCost(1000, 500);
+
+      // Input: 1000/1M * $0.14 = $0.00014
+      // Output: 500/1M * $0.28 = $0.00014
+      // Total: $0.00028
+      expect(cost).toBeCloseTo(0.00028, 6);
+    });
+
+    it('should estimate cost for large generation', () => {
+      const provider = new DeepSeekProvider({ apiKey: 'test' });
+      const cost = provider.estimateCost(1_000_000, 1_000_000);
+
+      expect(cost).toBeCloseTo(0.42, 2); // $0.14 + $0.28
+    });
+  });
+
+  describe('compareGPT4', () => {
+    it('should compare costs with GPT-4', () => {
+      const provider = new DeepSeekProvider({ apiKey: 'test' });
+      const comparison = provider.compareGPT4(1000, 500);
+
+      // DeepSeek: ~$0.00028
+      // GPT-4: 1000/1M * $30 + 500/1M * $60 = $0.03 + $0.03 = $0.06
+      expect(comparison.deepseekCost).toBeCloseTo(0.00028, 6);
+      expect(comparison.gpt4Cost).toBeCloseTo(0.06, 4);
+      expect(comparison.savings).toBeCloseTo(0.0597, 4);
+      expect(comparison.savingsPercent).toBeGreaterThan(99);
+    });
+
+    it('should calculate savings percentage correctly', () => {
+      const provider = new DeepSeekProvider({ apiKey: 'test' });
+      const comparison = provider.compareGPT4(100_000, 50_000);
+
+      // Should be ~99.5% savings
+      expect(comparison.savingsPercent).toBeGreaterThan(99);
+      expect(comparison.savingsPercent).toBeLessThan(100);
+    });
+  });
+
+  describe('createDeepSeekProvider', () => {
+    it('should create provider instance', () => {
+      const provider = createDeepSeekProvider();
+
+      expect(provider).toBeInstanceOf(DeepSeekProvider);
+    });
+
+    it('should pass config to provider', () => {
+      const config: DeepSeekConfig = { apiKey: 'test-key' };
+      const provider = createDeepSeekProvider(config);
+
+      expect(provider).toBeInstanceOf(DeepSeekProvider);
+    });
+  });
+
+  describe('checkDeepSeekSetup', () => {
+    it('should return false when API unavailable', async () => {
+      mockFetch.mockRejectedValueOnce(new Error('Network error'));
+
+      const result = await checkDeepSeekSetup();
+
+      expect(result).toBe(false);
+    });
+
+    it('should return true when API available', async () => {
+      // Set API key for this test
+      process.env.DEEPSEEK_API_KEY = 'test-key';
+      mockFetch.mockResolvedValueOnce({
+        ok: true
+      });
+
+      const result = await checkDeepSeekSetup();
+
+      expect(result).toBe(true);
+
+      // Clean up
+      delete process.env.DEEPSEEK_API_KEY;
+    });
+  });
+
+  describe('getDeepSeekSetupInstructions', () => {
+    it('should return setup instructions', () => {
+      const instructions = getDeepSeekSetupInstructions();
+
+      expect(instructions).toContain('DeepSeek API Setup');
+      expect(instructions).toContain('platform.deepseek.com');
+      expect(instructions).toContain('DEEPSEEK_API_KEY');
+      expect(instructions).toContain('deepseek-chat');
+      expect(instructions).toContain('$0.14');
+    });
+  });
+
+  describe('DeepSeekError', () => {
+    it('should create error with message', () => {
+      const error = new DeepSeekError('Test error');
+
+      expect(error.message).toBe('Test error');
+      expect(error.name).toBe('DeepSeekError');
+      expect(error.code).toBe('DEEPSEEK_ERROR');
+    });
+
+    it('should store error details', () => {
+      const details = { status: 400, response: 'Bad request' };
+      const error = new DeepSeekError('Test error', details);
+
+      expect(error.details).toEqual(details);
+    });
+  });
+});