@libredb/studio 0.9.7 → 0.9.13

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

@@ -1,248 +0,0 @@
-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

@@ -1,155 +0,0 @@
-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

@@ -1,288 +0,0 @@
-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
-      );
-    });
-  });
-});