qa360 2.1.7 → 2.2.0

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

@@ -0,0 +1,641 @@
+/**
+ * OllamaProvider - Unit Tests
+ *
+ * Tests the Ollama LLM provider for AI-powered test generation.
+ * All tests use mocked fetch to avoid requiring Ollama to be installed.
+ */
+
+import { describe, it, expect, vi, beforeAll, afterAll, afterEach } from 'vitest';
+import { OllamaProvider, OllamaError, checkOllamaSetup, GenerationRequest } from '../index.js';
+
+// Mock fetch before all tests
+const originalFetch = globalThis.fetch;
+const mockFetch = vi.fn();
+
+beforeAll(() => {
+  globalThis.fetch = mockFetch;
+});
+
+afterAll(() => {
+  globalThis.fetch = originalFetch;
+});
+
+describe('OllamaProvider', () => {
+  let provider: OllamaProvider;
+  const defaultBaseUrl = 'http://localhost:11434';
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    provider = new OllamaProvider();
+  });
+
+  afterEach(() => {
+    mockFetch.mockReset();
+  });
+
+  // ============================================================
+  // Constructor Tests
+  // ============================================================
+  describe('constructor', () => {
+    it('should create provider with default values', () => {
+      expect(provider.name).toBe('ollama');
+      expect(provider.models).toEqual(expect.arrayContaining(['deepseek-coder', 'codellama', 'llama3.2']));
+    });
+
+    it('should accept custom base URL', () => {
+      const customProvider = new OllamaProvider({ baseUrl: 'http://custom:11434' });
+      expect(customProvider).toBeDefined();
+    });
+
+    it('should accept custom model', () => {
+      const customProvider = new OllamaProvider({ model: 'llama3.2' });
+      expect(customProvider).toBeDefined();
+    });
+
+    it('should have default timeout', () => {
+      expect(provider).toBeDefined();
+    });
+  });
+
+  // ============================================================
+  // isAvailable Tests
+  // ============================================================
+  describe('isAvailable', () => {
+    it('should return true when Ollama is running', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => ({ models: [] })
+      } as Response);
+
+      const available = await provider.isAvailable();
+      expect(available).toBe(true);
+      expect(mockFetch).toHaveBeenCalledWith(`${defaultBaseUrl}/api/tags`, expect.any(Object));
+    });
+
+    it('should return false when Ollama is not reachable', async () => {
+      mockFetch.mockRejectedValue(new Error('ECONNREFUSED'));
+
+      const available = await provider.isAvailable();
+      expect(available).toBe(false);
+    });
+
+    it('should return false on non-OK response', async () => {
+      mockFetch.mockResolvedValue({
+        ok: false,
+        status: 500
+      } as Response);
+
+      const available = await provider.isAvailable();
+      expect(available).toBe(false);
+    });
+  });
+
+  // ============================================================
+  // listModels Tests
+  // ============================================================
+  describe('listModels', () => {
+    it('should return list of models', async () => {
+      const mockModels = [
+        { name: 'deepseek-coder:latest', size: 7234390929, modifiedAt: '2024-01-15T10:00:00Z' },
+        { name: 'llama3.2:latest', size: 2010382970, modifiedAt: '2024-01-10T10:00:00Z' },
+        { name: 'codellama:latest', size: 3825387622, modifiedAt: '2024-01-05T10:00:00Z' }
+      ];
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => ({ models: mockModels })
+      } as Response);
+
+      const models = await provider.listModels();
+
+      expect(models).toHaveLength(3);
+      expect(models[0].name).toBe('deepseek-coder:latest');
+      expect(models[0].size).toBe(7234390929);
+      // Verify fetch was called with the right URL
+      expect(mockFetch.mock.calls[0][0]).toBe(`${defaultBaseUrl}/api/tags`);
+    });
+
+    it('should throw OllamaError on fetch failure', async () => {
+      mockFetch.mockRejectedValue(new Error('Network error'));
+
+      await expect(provider.listModels()).rejects.toThrow();
+      await expect(provider.listModels()).rejects.toThrow('Network error');
+    });
+
+    it('should throw OllamaError on non-OK response', async () => {
+      mockFetch.mockResolvedValue({
+        ok: false,
+        status: 500,
+        statusText: 'Internal Server Error'
+      } as Response);
+
+      await expect(provider.listModels()).rejects.toThrow(OllamaError);
+    });
+
+    it('should return empty array when no models installed', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => ({ models: [] })
+      } as Response);
+
+      const models = await provider.listModels();
+      expect(models).toHaveLength(0);
+    });
+  });
+
+  // ============================================================
+  // generate Tests
+  // ============================================================
+  describe('generate', () => {
+    const mockResponse = {
+      model: 'deepseek-coder:latest',
+      created_at: '2024-01-15T10:00:00Z',
+      response: 'function test() { return true; }',
+      done: true,
+      prompt_eval_count: 10,
+      eval_count: 20,
+      done_reason: 'stop'
+    };
+
+    it('should generate text from prompt', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => mockResponse
+      } as Response);
+
+      const request: GenerationRequest = {
+        prompt: 'Write a test function'
+      };
+
+      const response = await provider.generate(request);
+
+      expect(response.content).toBe('function test() { return true; }');
+      expect(response.usage.promptTokens).toBe(10);
+      expect(response.usage.completionTokens).toBe(20);
+      expect(response.usage.totalTokens).toBe(30);
+      expect(response.model).toBe('deepseek-coder'); // defaultModel, not from response
+      expect(response.finishReason).toBe('stop');
+    });
+
+    it('should include system prompt in full prompt', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => mockResponse
+      } as Response);
+
+      const request: GenerationRequest = {
+        systemPrompt: 'You are a test generator',
+        prompt: 'Write a test'
+      };
+
+      await provider.generate(request);
+
+      const fetchCall = mockFetch.mock.calls[0];
+      const body = JSON.parse(fetchCall[1].body);
+      // The system prompt is incorporated into the main prompt
+      expect(body.prompt).toContain('You are a test generator');
+      expect(body.prompt).toContain('Write a test');
+    });
+
+    it('should respect maxTokens parameter as num_predict', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => mockResponse
+      } as Response);
+
+      const request: GenerationRequest = {
+        prompt: 'Write a test',
+        maxTokens: 100
+      };
+
+      await provider.generate(request);
+
+      const fetchCall = mockFetch.mock.calls[0];
+      const body = JSON.parse(fetchCall[1].body);
+      expect(body.options.num_predict).toBe(100);
+    });
+
+    it('should respect temperature parameter', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => mockResponse
+      } as Response);
+
+      const request: GenerationRequest = {
+        prompt: 'Write a test',
+        temperature: 0.5
+      };
+
+      await provider.generate(request);
+
+      const fetchCall = mockFetch.mock.calls[0];
+      const body = JSON.parse(fetchCall[1].body);
+      expect(body.options.temperature).toBe(0.5);
+    });
+
+    it('should use custom model from constructor', async () => {
+      const customProvider = new OllamaProvider({ model: 'llama3.2' });
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => mockResponse
+      } as Response);
+
+      await customProvider.generate({ prompt: 'Test' });
+
+      const fetchCall = mockFetch.mock.calls[0];
+      const body = JSON.parse(fetchCall[1].body);
+      expect(body.model).toBe('llama3.2');
+    });
+
+    it('should throw OllamaError on generation failure', async () => {
+      mockFetch.mockRejectedValue(new Error('Generation failed'));
+
+      const request: GenerationRequest = {
+        prompt: 'Write a test'
+      };
+
+      await expect(provider.generate(request)).rejects.toThrow();
+      await expect(provider.generate(request)).rejects.toThrow('Generation failed');
+    });
+
+    it('should throw OllamaError on non-OK response', async () => {
+      mockFetch.mockResolvedValue({
+        ok: false,
+        status: 500,
+        statusText: 'Server Error',
+        text: async () => 'Internal Server Error'
+      } as Response);
+
+      const request: GenerationRequest = {
+        prompt: 'Write a test'
+      };
+
+      await expect(provider.generate(request)).rejects.toThrow(OllamaError);
+    });
+
+    it('should throw OllamaError when response contains error', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => ({ error: 'Model not found' })
+      } as Response);
+
+      const request: GenerationRequest = {
+        prompt: 'Write a test'
+      };
+
+      await expect(provider.generate(request)).rejects.toThrow(OllamaError);
+      await expect(provider.generate(request)).rejects.toThrow('Model not found');
+    });
+
+    it('should handle streaming disabled by default', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => mockResponse
+      } as Response);
+
+      await provider.generate({ prompt: 'Test' });
+
+      const fetchCall = mockFetch.mock.calls[0];
+      const body = JSON.parse(fetchCall[1].body);
+      expect(body.stream).toBe(false);
+    });
+  });
+
+  // ============================================================
+  // stream Tests
+  // ============================================================
+  describe('stream', () => {
+    it('should stream response chunks', async () => {
+      const mockChunks = [
+        { response: 'func', done: false },
+        { response: 'tion', done: false },
+        { response: ' test()', done: false },
+        { response: '{}', done: true }
+      ];
+
+      const mockStream = new ReadableStream({
+        async start(controller) {
+          for (const chunk of mockChunks) {
+            const encoder = new TextEncoder();
+            controller.enqueue(encoder.encode(JSON.stringify(chunk) + '\n'));
+          }
+          controller.close();
+        }
+      });
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        body: mockStream
+      } as Response);
+
+      const chunks: string[] = [];
+      const stream = provider.stream({ prompt: 'Write a test' });
+
+      for await (const chunk of stream) {
+        chunks.push(chunk);
+      }
+
+      expect(chunks).toEqual(['func', 'tion', ' test()', '{}']);
+    });
+
+    it('should throw OllamaError on stream failure', async () => {
+      mockFetch.mockResolvedValue({
+        ok: false,
+        status: 500
+      } as Response);
+
+      const stream = provider.stream({ prompt: 'Test' });
+
+      let error: Error | null = null;
+      try {
+        for await (const _ of stream) {
+          // Should not reach here
+        }
+      } catch (e) {
+        error = e as Error;
+      }
+
+      expect(error).toBeInstanceOf(OllamaError);
+    });
+
+    it('should handle empty stream', async () => {
+      const mockStream = new ReadableStream({
+        async start(controller) {
+          controller.close();
+        }
+      });
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        body: mockStream
+      } as Response);
+
+      const chunks: string[] = [];
+      const stream = provider.stream({ prompt: 'Test' });
+
+      for await (const chunk of stream) {
+        chunks.push(chunk);
+      }
+
+      expect(chunks).toHaveLength(0);
+    });
+  });
+
+  // ============================================================
+  // countTokens Tests
+  // ============================================================
+  describe('countTokens', () => {
+    it('should estimate token count for simple text', () => {
+      const text = 'Hello world';
+      const count = provider.countTokens(text);
+      expect(count).toBeGreaterThan(0);
+      expect(count).toBeLessThan(10);
+    });
+
+    it('should handle empty string', () => {
+      const count = provider.countTokens('');
+      expect(count).toBe(0);
+    });
+
+    it('should estimate higher for code', () => {
+      const code = 'function test() { const x = 1; return x; }';
+      const count = provider.countTokens(code);
+      expect(count).toBeGreaterThan(0);
+    });
+
+    it('should provide consistent estimates', () => {
+      const text = 'The quick brown fox jumps over the lazy dog';
+      const count1 = provider.countTokens(text);
+      const count2 = provider.countTokens(text);
+      expect(count1).toBe(count2);
+    });
+  });
+
+  // ============================================================
+  // checkOllamaSetup Tests (utility function)
+  // ============================================================
+  describe('checkOllamaSetup', () => {
+    it('should return available=true when Ollama is running with models', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => ({
+          models: [
+            { name: 'deepseek-coder:latest', size: 7000000000 },
+            { name: 'llama3.2:latest', size: 2000000000 }
+          ]
+        })
+      } as Response);
+
+      const result = await checkOllamaSetup('deepseek-coder');
+
+      expect(result.available).toBe(true);
+      expect(result.modelInstalled).toBe(true);
+      expect(result.models).toHaveLength(2);
+    });
+
+    it('should return available=true but modelInstalled=false when model missing', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => ({
+          models: [
+            { name: 'llama3.2:latest', size: 2000000000 }
+          ]
+        })
+      } as Response);
+
+      const result = await checkOllamaSetup('deepseek-coder');
+
+      expect(result.available).toBe(true);
+      expect(result.modelInstalled).toBe(false);
+      expect(result.models).toHaveLength(1);
+    });
+
+    it('should return available=false when Ollama is not running', async () => {
+      mockFetch.mockRejectedValue(new Error('ECONNREFUSED'));
+
+      const result = await checkOllamaSetup();
+
+      expect(result.available).toBe(false);
+      expect(result.modelInstalled).toBe(false);
+      expect(result.models).toHaveLength(0);
+    });
+
+    it('should use default model when none specified', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => ({
+          models: [{ name: 'deepseek-coder:latest', size: 7000000000 }]
+        })
+      } as Response);
+
+      const result = await checkOllamaSetup();
+
+      expect(result.available).toBe(true);
+      expect(result.modelInstalled).toBe(true);
+    });
+  });
+
+  // ============================================================
+  // OllamaError Tests
+  // ============================================================
+  describe('OllamaError', () => {
+    it('should create error with message', () => {
+      const error = new OllamaError('Test error');
+      expect(error.message).toBe('Test error');
+      expect(error.name).toBe('OllamaError');
+    });
+
+    it('should be instanceof Error', () => {
+      const error = new OllamaError('Test');
+      expect(error instanceof Error).toBe(true);
+    });
+
+    it('should maintain stack trace', () => {
+      const error = new OllamaError('Test');
+      expect(error.stack).toBeDefined();
+    });
+
+    it('should accept metadata', () => {
+      const error = new OllamaError('Test', { code: 'TEST_001', details: 'test' });
+      expect(error.message).toBe('Test');
+    });
+  });
+
+  // ============================================================
+  // Integration-like Tests
+  // ============================================================
+  describe('integration scenarios', () => {
+    it('should handle complete workflow: check -> list -> generate', async () => {
+      // Mock listModels
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => ({
+          models: [{ name: 'deepseek-coder:latest', size: 7000000000 }]
+        })
+      } as Response);
+
+      // Check availability
+      const available = await provider.isAvailable();
+      expect(available).toBe(true);
+
+      // List models
+      const models = await provider.listModels();
+      expect(models).toHaveLength(1);
+
+      // Generate
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          model: 'deepseek-coder:latest',
+          response: 'test code here',
+          done: true,
+          prompt_eval_count: 5,
+          eval_count: 10,
+          done_reason: 'stop'
+        })
+      } as Response);
+
+      const response = await provider.generate({ prompt: 'Generate test' });
+      expect(response.content).toBe('test code here');
+    });
+
+    it('should handle different model requests', async () => {
+      const models = ['deepseek-coder', 'llama3.2', 'codellama', 'mistral'];
+
+      for (const model of models) {
+        const p = new OllamaProvider({ model });
+
+        mockFetch.mockResolvedValue({
+          ok: true,
+          json: async () => ({
+            model: `${model}:latest`,
+            response: 'code',
+            done: true,
+            prompt_eval_count: 1,
+            eval_count: 1,
+            done_reason: 'stop'
+          })
+        } as Response);
+
+        const response = await p.generate({ prompt: 'Test' });
+        expect(response).toBeDefined();
+      }
+    });
+  });
+
+  // ============================================================
+  // Edge Cases
+  // ============================================================
+  describe('edge cases', () => {
+    it('should handle very long prompts', async () => {
+      const longPrompt = 'a'.repeat(10000);
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => ({
+          model: 'deepseek-coder:latest',
+          response: 'response',
+          done: true,
+          prompt_eval_count: 8000,
+          eval_count: 100,
+          done_reason: 'stop'
+        })
+      } as Response);
+
+      const response = await provider.generate({ prompt: longPrompt });
+      expect(response.content).toBe('response');
+    });
+
+    it('should handle special characters in prompt', async () => {
+      const specialPrompt = 'Test with émojis 🎉 and spëcial çhars';
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => ({
+          model: 'deepseek-coder:latest',
+          response: 'response',
+          done: true,
+          prompt_eval_count: 10,
+          eval_count: 5,
+          done_reason: 'stop'
+        })
+      } as Response);
+
+      const response = await provider.generate({ prompt: specialPrompt });
+      expect(response.content).toBe('response');
+    });
+
+    it('should handle empty prompt', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => ({
+          model: 'deepseek-coder:latest',
+          response: '',
+          done: true,
+          prompt_eval_count: 0,
+          eval_count: 0,
+          done_reason: 'stop'
+        })
+      } as Response);
+
+      const response = await provider.generate({ prompt: '' });
+      expect(response.content).toBe('');
+    });
+
+    it('should handle null token counts', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => ({
+          model: 'deepseek-coder:latest',
+          response: 'test',
+          done: true,
+          done_reason: 'stop'
+        })
+      } as Response);
+
+      const response = await provider.generate({ prompt: 'Test' });
+      expect(response.usage.totalTokens).toBe(0);
+    });
+  });
+});