@libredb/studio 0.9.7

package/tests/unit/llm/gemini-provider.test.ts

@@ -0,0 +1,248 @@
+import { describe, test, expect, mock, beforeEach } from 'bun:test';
+import {
+  LLMAuthError,
+  LLMRateLimitError,
+  LLMSafetyError,
+  LLMStreamError,
+  LLMConfigError,
+  type LLMConfig,
+  type LLMStreamOptions,
+} from '@/lib/llm/types';
+
+// ============================================================================
+// Mock State
+// ============================================================================
+
+let mockGenerateContentStream: (prompt: string) => Promise<unknown>;
+
+// ============================================================================
+// Module Mocks (must be before await import)
+// ============================================================================
+
+mock.module('@google/generative-ai', () => ({
+  GoogleGenerativeAI: function () {
+    return {
+      getGenerativeModel: function () {
+        return {
+          generateContentStream: async (prompt: string) =>
+            mockGenerateContentStream(prompt),
+        };
+      },
+    };
+  },
+}));
+
+// ============================================================================
+// Import module under test (after mocks)
+// ============================================================================
+
+const { GeminiProvider } = await import('@/lib/llm/providers/gemini');
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+async function* mockStreamChunks(texts: string[]) {
+  for (const t of texts) {
+    yield { text: () => t };
+  }
+}
+
+async function readStream(stream: ReadableStream<Uint8Array>): Promise<string> {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let result = '';
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    result += decoder.decode(value);
+  }
+  return result;
+}
+
+function makeConfig(overrides?: Partial<LLMConfig>): LLMConfig {
+  return {
+    provider: 'gemini',
+    apiKey: 'test-gemini-api-key',
+    model: 'gemini-2.0-flash',
+    ...overrides,
+  };
+}
+
+function makeStreamOptions(overrides?: Partial<LLMStreamOptions>): LLMStreamOptions {
+  return {
+    messages: [{ role: 'user', content: 'Hello' }],
+    ...overrides,
+  };
+}
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+describe('GeminiProvider', () => {
+  beforeEach(() => {
+    mockGenerateContentStream = async () => ({
+      stream: mockStreamChunks(['Hello', ' World']),
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // constructor
+  // --------------------------------------------------------------------------
+
+  describe('constructor', () => {
+    test('creates instance with valid config', () => {
+      const provider = new GeminiProvider(makeConfig());
+      expect(provider.name).toBe('gemini');
+      expect(provider.config.model).toBe('gemini-2.0-flash');
+    });
+
+    test('throws LLMConfigError without apiKey', () => {
+      expect(() => new GeminiProvider(makeConfig({ apiKey: undefined }))).toThrow(
+        LLMConfigError
+      );
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // stream()
+  // --------------------------------------------------------------------------
+
+  describe('stream()', () => {
+    test('returns ReadableStream on success', async () => {
+      const provider = new GeminiProvider(makeConfig());
+      const stream = await provider.stream(makeStreamOptions());
+
+      expect(stream).toBeInstanceOf(ReadableStream);
+      const text = await readStream(stream);
+      expect(text).toBe('Hello World');
+    });
+
+    test('passes model from options', async () => {
+      const provider = new GeminiProvider(makeConfig());
+      const stream = await provider.stream(
+        makeStreamOptions({ model: 'gemini-pro' })
+      );
+      expect(stream).toBeInstanceOf(ReadableStream);
+    });
+
+    test('passes system instruction', async () => {
+      const provider = new GeminiProvider(makeConfig());
+      const stream = await provider.stream(
+        makeStreamOptions({
+          messages: [
+            { role: 'system', content: 'You are helpful.' },
+            { role: 'user', content: 'Hello' },
+          ],
+        })
+      );
+      expect(stream).toBeInstanceOf(ReadableStream);
+    });
+
+    test('handles empty stream', async () => {
+      mockGenerateContentStream = async () => ({
+        stream: mockStreamChunks([]),
+      });
+
+      const provider = new GeminiProvider(makeConfig());
+      const stream = await provider.stream(makeStreamOptions());
+      const text = await readStream(stream);
+      expect(text).toBe('');
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // error mapping
+  // --------------------------------------------------------------------------
+
+  describe('error mapping', () => {
+    test('api key error maps to LLMAuthError', async () => {
+      mockGenerateContentStream = async () => {
+        throw new Error('Invalid API key provided');
+      };
+
+      const provider = new GeminiProvider(makeConfig());
+      await expect(provider.stream(makeStreamOptions())).rejects.toBeInstanceOf(
+        LLMAuthError
+      );
+    });
+
+    test('unauthorized error maps to LLMAuthError', async () => {
+      mockGenerateContentStream = async () => {
+        throw new Error('Unauthorized access');
+      };
+
+      const provider = new GeminiProvider(makeConfig());
+      await expect(provider.stream(makeStreamOptions())).rejects.toBeInstanceOf(
+        LLMAuthError
+      );
+    });
+
+    test('quota error maps to LLMRateLimitError', async () => {
+      mockGenerateContentStream = async () => {
+        throw new Error('Quota exceeded for this project');
+      };
+
+      const provider = new GeminiProvider(makeConfig());
+      await expect(provider.stream(makeStreamOptions())).rejects.toBeInstanceOf(
+        LLMRateLimitError
+      );
+    });
+
+    test('rate limit error maps to LLMRateLimitError', async () => {
+      mockGenerateContentStream = async () => {
+        throw new Error('Rate limit reached');
+      };
+
+      const provider = new GeminiProvider(makeConfig());
+      await expect(provider.stream(makeStreamOptions())).rejects.toBeInstanceOf(
+        LLMRateLimitError
+      );
+    });
+
+    test('safety error maps to LLMSafetyError', async () => {
+      mockGenerateContentStream = async () => {
+        throw new Error('Content blocked by safety filters');
+      };
+
+      const provider = new GeminiProvider(makeConfig());
+      await expect(provider.stream(makeStreamOptions())).rejects.toBeInstanceOf(
+        LLMSafetyError
+      );
+    });
+
+    test('blocked error maps to LLMSafetyError', async () => {
+      mockGenerateContentStream = async () => {
+        throw new Error('Response was blocked');
+      };
+
+      const provider = new GeminiProvider(makeConfig());
+      await expect(provider.stream(makeStreamOptions())).rejects.toBeInstanceOf(
+        LLMSafetyError
+      );
+    });
+
+    test('generic error maps to LLMStreamError', async () => {
+      mockGenerateContentStream = async () => {
+        throw new Error('Something unexpected happened');
+      };
+
+      const provider = new GeminiProvider(makeConfig());
+      await expect(provider.stream(makeStreamOptions())).rejects.toBeInstanceOf(
+        LLMStreamError
+      );
+    });
+
+    test('non-Error value maps to LLMStreamError', async () => {
+      mockGenerateContentStream = async () => {
+        throw 'string error value';
+      };
+
+      const provider = new GeminiProvider(makeConfig());
+      await expect(provider.stream(makeStreamOptions())).rejects.toBeInstanceOf(
+        LLMStreamError
+      );
+    });
+  });
+});

package/tests/unit/llm/llm-factory.test.ts

@@ -0,0 +1,155 @@
+import { describe, test, expect, mock, beforeEach, afterEach } from 'bun:test';
+import { LLMConfigError } from '@/lib/llm/types';
+
+// ============================================================================
+// Environment Variable Management
+// ============================================================================
+
+let savedEnv: Record<string, string | undefined>;
+
+const LLM_ENV_KEYS = ['LLM_PROVIDER', 'LLM_API_KEY', 'LLM_MODEL', 'LLM_API_URL'];
+
+// ============================================================================
+// Module Mocks (must be before await import)
+// Mocking provider constructors to avoid real SDK initialization
+// ============================================================================
+
+mock.module('@google/generative-ai', () => ({
+  GoogleGenerativeAI: function () {
+    return {
+      getGenerativeModel: () => ({
+        generateContentStream: async () => ({ stream: (async function* () {})() }),
+      }),
+    };
+  },
+}));
+
+// ============================================================================
+// Import module under test (after mocks)
+// ============================================================================
+
+const { createLLMProvider, getDefaultProvider, resetDefaultProvider } = await import(
+  '@/lib/llm/factory'
+);
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+describe('LLM Factory', () => {
+  beforeEach(() => {
+    savedEnv = {};
+    for (const key of LLM_ENV_KEYS) {
+      savedEnv[key] = process.env[key];
+      delete process.env[key];
+    }
+    resetDefaultProvider();
+  });
+
+  afterEach(() => {
+    for (const key of LLM_ENV_KEYS) {
+      if (savedEnv[key] !== undefined) {
+        process.env[key] = savedEnv[key];
+      } else {
+        delete process.env[key];
+      }
+    }
+    resetDefaultProvider();
+  });
+
+  // --------------------------------------------------------------------------
+  // createLLMProvider()
+  // --------------------------------------------------------------------------
+
+  describe('createLLMProvider()', () => {
+    test('creates GeminiProvider for gemini type', async () => {
+      const provider = await createLLMProvider({
+        provider: 'gemini',
+        apiKey: 'test-gemini-key',
+        model: 'gemini-2.0-flash',
+      });
+      expect(provider.name).toBe('gemini');
+    });
+
+    test('creates OpenAIProvider for openai type', async () => {
+      const provider = await createLLMProvider({
+        provider: 'openai',
+        apiKey: 'sk-test-key',
+        model: 'gpt-4o',
+      });
+      expect(provider.name).toBe('openai');
+    });
+
+    test('creates OllamaProvider for ollama type', async () => {
+      const provider = await createLLMProvider({
+        provider: 'ollama',
+        model: 'llama3.2',
+      });
+      expect(provider.name).toBe('ollama');
+    });
+
+    test('creates CustomProvider for custom type', async () => {
+      const provider = await createLLMProvider({
+        provider: 'custom',
+        apiUrl: 'https://my-endpoint.com/v1',
+        model: 'custom-model',
+      });
+      expect(provider.name).toBe('custom');
+    });
+
+    test('throws LLMConfigError for unknown provider', async () => {
+      await expect(
+        createLLMProvider({
+          provider: 'nonexistent' as 'gemini',
+          model: 'some-model',
+        })
+      ).rejects.toThrow(LLMConfigError);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // getDefaultProvider()
+  // --------------------------------------------------------------------------
+
+  describe('getDefaultProvider()', () => {
+    test('returns singleton instance', async () => {
+      process.env.LLM_PROVIDER = 'gemini';
+      process.env.LLM_API_KEY = 'test-key-for-singleton';
+      process.env.LLM_MODEL = 'gemini-2.0-flash';
+
+      const provider = await getDefaultProvider();
+      expect(provider).toBeDefined();
+      expect(provider.name).toBe('gemini');
+    });
+
+    test('returns same instance on second call', async () => {
+      process.env.LLM_PROVIDER = 'gemini';
+      process.env.LLM_API_KEY = 'test-key-for-singleton';
+      process.env.LLM_MODEL = 'gemini-2.0-flash';
+
+      const first = await getDefaultProvider();
+      const second = await getDefaultProvider();
+      expect(first).toBe(second);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // resetDefaultProvider()
+  // --------------------------------------------------------------------------
+
+  describe('resetDefaultProvider()', () => {
+    test('clears singleton so next call creates new', async () => {
+      process.env.LLM_PROVIDER = 'gemini';
+      process.env.LLM_API_KEY = 'test-key-for-singleton';
+      process.env.LLM_MODEL = 'gemini-2.0-flash';
+
+      const first = await getDefaultProvider();
+
+      resetDefaultProvider();
+
+      const second = await getDefaultProvider();
+      // They should be different object references
+      expect(first).not.toBe(second);
+    });
+  });
+});

package/tests/unit/llm/ollama-provider.test.ts

@@ -0,0 +1,288 @@
+import { describe, test, expect, beforeEach, afterEach, spyOn } from 'bun:test';
+import {
+  LLMStreamError,
+  LLMConfigError,
+  type LLMConfig,
+  type LLMStreamOptions,
+} from '@/lib/llm/types';
+
+// ============================================================================
+// Import module under test (no mock.module needed — Ollama uses globalThis.fetch)
+// ============================================================================
+
+const { OllamaProvider } = await import('@/lib/llm/providers/ollama');
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+function makeSSEChunk(content: string): string {
+  return `data: ${JSON.stringify({ choices: [{ delta: { content } }] })}\n\n`;
+}
+
+function createSSEResponse(chunks: string[], status = 200): Response {
+  const body = new ReadableStream<Uint8Array>({
+    start(controller) {
+      for (const chunk of chunks) {
+        controller.enqueue(new TextEncoder().encode(chunk));
+      }
+      controller.close();
+    },
+  });
+  return new Response(body, {
+    status,
+    headers: { 'Content-Type': 'text/event-stream' },
+  });
+}
+
+function createJsonResponse(body: unknown, status: number): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { 'Content-Type': 'application/json' },
+  });
+}
+
+async function readStream(stream: ReadableStream<Uint8Array>): Promise<string> {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let result = '';
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    result += decoder.decode(value);
+  }
+  return result;
+}
+
+function makeConfig(overrides?: Partial<LLMConfig>): LLMConfig {
+  return {
+    provider: 'ollama',
+    model: 'llama3.2',
+    ...overrides,
+  };
+}
+
+function makeStreamOptions(overrides?: Partial<LLMStreamOptions>): LLMStreamOptions {
+  return {
+    messages: [{ role: 'user', content: 'Hello' }],
+    ...overrides,
+  };
+}
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+describe('OllamaProvider', () => {
+  let fetchSpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    fetchSpy = spyOn(globalThis, 'fetch');
+  });
+
+  afterEach(() => {
+    fetchSpy.mockRestore();
+  });
+
+  // --------------------------------------------------------------------------
+  // constructor
+  // --------------------------------------------------------------------------
+
+  describe('constructor', () => {
+    test('creates without apiKey (not required for Ollama)', () => {
+      const provider = new OllamaProvider(makeConfig());
+      expect(provider.name).toBe('ollama');
+      expect(provider.config.apiKey).toBeUndefined();
+    });
+
+    test('uses default Ollama URL (localhost:11434)', () => {
+      const provider = new OllamaProvider(makeConfig());
+      // The default URL is set internally; config.apiUrl remains undefined
+      expect(provider.config.apiUrl).toBeUndefined();
+    });
+
+    test('uses custom apiUrl', () => {
+      const provider = new OllamaProvider(
+        makeConfig({ apiUrl: 'http://remote-ollama:11434/v1' })
+      );
+      expect(provider.config.apiUrl).toBe('http://remote-ollama:11434/v1');
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // validate()
+  // --------------------------------------------------------------------------
+
+  describe('validate()', () => {
+    test('throws LLMConfigError without model', () => {
+      // Ollama constructor does NOT call validate() automatically,
+      // so we call it explicitly
+      const provider = new OllamaProvider(
+        makeConfig({ model: undefined as unknown as string })
+      );
+      expect(() => provider.validate()).toThrow(LLMConfigError);
+    });
+
+    test('throws LLMConfigError with empty model', () => {
+      const provider = new OllamaProvider(makeConfig({ model: '' }));
+      expect(() => provider.validate()).toThrow(LLMConfigError);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // stream()
+  // --------------------------------------------------------------------------
+
+  describe('stream()', () => {
+    test('sends Bearer ollama auth header', async () => {
+      const sseData = [makeSSEChunk('Hi'), 'data: [DONE]\n\n'];
+      fetchSpy.mockResolvedValueOnce(createSSEResponse(sseData));
+
+      const provider = new OllamaProvider(makeConfig());
+      await provider.stream(makeStreamOptions());
+
+      expect(fetchSpy).toHaveBeenCalledTimes(1);
+      const [, opts] = fetchSpy.mock.calls[0] as [string, RequestInit];
+      const headers = opts.headers as Record<string, string>;
+      expect(headers.Authorization).toBe('Bearer ollama');
+    });
+
+    test('returns parsed stream content', async () => {
+      const sseData = [
+        makeSSEChunk('Hello'),
+        makeSSEChunk(' from'),
+        makeSSEChunk(' Ollama'),
+        'data: [DONE]\n\n',
+      ];
+      fetchSpy.mockResolvedValueOnce(createSSEResponse(sseData));
+
+      const provider = new OllamaProvider(makeConfig());
+      const stream = await provider.stream(makeStreamOptions());
+
+      expect(stream).toBeInstanceOf(ReadableStream);
+      const text = await readStream(stream);
+      expect(text).toBe('Hello from Ollama');
+    });
+
+    test('passes model and messages', async () => {
+      const sseData = [makeSSEChunk('ok'), 'data: [DONE]\n\n'];
+      fetchSpy.mockResolvedValueOnce(createSSEResponse(sseData));
+
+      const provider = new OllamaProvider(makeConfig());
+      await provider.stream(
+        makeStreamOptions({
+          messages: [
+            { role: 'system', content: 'Be concise' },
+            { role: 'user', content: 'Hi' },
+          ],
+        })
+      );
+
+      const body = JSON.parse(fetchSpy.mock.calls[0][1]!.body as string);
+      expect(body.model).toBe('llama3.2');
+      expect(body.messages).toHaveLength(2);
+      expect(body.stream).toBe(true);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // validateResponse()
+  // --------------------------------------------------------------------------
+
+  describe('validateResponse()', () => {
+    test('404 throws LLMConfigError with model pull message', async () => {
+      fetchSpy.mockImplementation(async () =>
+        createJsonResponse({ error: { message: 'model not found' } }, 404)
+      );
+
+      const provider = new OllamaProvider(makeConfig());
+      try {
+        await provider.stream(makeStreamOptions());
+        expect(true).toBe(false); // should not reach here
+      } catch (err) {
+        expect(err).toBeInstanceOf(LLMConfigError);
+        expect((err as Error).message).toContain('pulled');
+      }
+    });
+
+    test('500 throws LLMStreamError', async () => {
+      fetchSpy.mockImplementation(async () =>
+        createJsonResponse({ error: { message: 'Internal error' } }, 500)
+      );
+
+      const provider = new OllamaProvider(makeConfig());
+      await expect(provider.stream(makeStreamOptions())).rejects.toBeInstanceOf(
+        LLMStreamError
+      );
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // error mapping
+  // --------------------------------------------------------------------------
+
+  describe('error mapping', () => {
+    test('ECONNREFUSED maps to connection error', async () => {
+      fetchSpy.mockImplementation(async () => {
+        throw new Error('connect ECONNREFUSED 127.0.0.1:11434');
+      });
+
+      const provider = new OllamaProvider(makeConfig());
+      try {
+        await provider.stream(makeStreamOptions());
+        expect(true).toBe(false);
+      } catch (err) {
+        expect(err).toBeInstanceOf(LLMStreamError);
+        expect((err as Error).message).toContain('Cannot connect to Ollama');
+      }
+    });
+
+    test('fetch failed maps to connection error', async () => {
+      fetchSpy.mockImplementation(async () => {
+        throw new TypeError('fetch failed');
+      });
+
+      const provider = new OllamaProvider(makeConfig());
+      try {
+        await provider.stream(makeStreamOptions());
+        expect(true).toBe(false);
+      } catch (err) {
+        expect(err).toBeInstanceOf(LLMStreamError);
+        expect((err as Error).message).toContain('Cannot connect to Ollama');
+      }
+    });
+
+    test('LLMConfigError passes through', async () => {
+      fetchSpy.mockImplementation(async () =>
+        createJsonResponse({ error: { message: 'not found' } }, 404)
+      );
+
+      const provider = new OllamaProvider(makeConfig());
+      await expect(provider.stream(makeStreamOptions())).rejects.toBeInstanceOf(
+        LLMConfigError
+      );
+    });
+
+    test('generic error maps to LLMStreamError', async () => {
+      fetchSpy.mockImplementation(async () => {
+        throw new Error('Unexpected error');
+      });
+
+      const provider = new OllamaProvider(makeConfig());
+      await expect(provider.stream(makeStreamOptions())).rejects.toBeInstanceOf(
+        LLMStreamError
+      );
+    });
+
+    test('non-Error maps to LLMStreamError', async () => {
+      fetchSpy.mockImplementation(async () => {
+        throw 'string error value';
+      });
+
+      const provider = new OllamaProvider(makeConfig());
+      await expect(provider.stream(makeStreamOptions())).rejects.toBeInstanceOf(
+        LLMStreamError
+      );
+    });
+  });
+});