@libredb/studio 0.9.7

package/tests/unit/lib/time-series-buffer.test.ts

@@ -0,0 +1,212 @@
+import { describe, test, expect } from 'bun:test';
+import { TimeSeriesBuffer } from '@/lib/time-series-buffer';
+
+describe('TimeSeriesBuffer', () => {
+  // ==========================================================================
+  // Constructor
+  // ==========================================================================
+
+  describe('constructor', () => {
+    test('default maxSize is 120', () => {
+      const buffer = new TimeSeriesBuffer<number>();
+      // Push 121 items — only 120 should remain
+      for (let i = 0; i < 121; i++) {
+        buffer.push(i);
+      }
+      expect(buffer.size).toBe(120);
+    });
+
+    test('custom maxSize is respected', () => {
+      const buffer = new TimeSeriesBuffer<number>(5);
+      for (let i = 0; i < 10; i++) {
+        buffer.push(i);
+      }
+      expect(buffer.size).toBe(5);
+    });
+  });
+
+  // ==========================================================================
+  // push + getAll
+  // ==========================================================================
+
+  describe('push + getAll', () => {
+    test('single item can be pushed and retrieved', () => {
+      const buffer = new TimeSeriesBuffer<string>(10);
+      buffer.push('hello');
+      const all = buffer.getAll();
+      expect(all).toHaveLength(1);
+      expect(all[0].data).toBe('hello');
+      expect(typeof all[0].timestamp).toBe('number');
+    });
+
+    test('multiple items are returned in chronological order', () => {
+      const buffer = new TimeSeriesBuffer<number>(10);
+      buffer.push(1);
+      buffer.push(2);
+      buffer.push(3);
+      const all = buffer.getAll();
+      expect(all).toHaveLength(3);
+      expect(all[0].data).toBe(1);
+      expect(all[1].data).toBe(2);
+      expect(all[2].data).toBe(3);
+    });
+
+    test('getAll returns empty array when buffer is empty', () => {
+      const buffer = new TimeSeriesBuffer<number>(10);
+      expect(buffer.getAll()).toEqual([]);
+    });
+  });
+
+  // ==========================================================================
+  // size
+  // ==========================================================================
+
+  describe('size', () => {
+    test('empty buffer has size 0', () => {
+      const buffer = new TimeSeriesBuffer<number>(10);
+      expect(buffer.size).toBe(0);
+    });
+
+    test('size tracks number of pushes', () => {
+      const buffer = new TimeSeriesBuffer<number>(10);
+      buffer.push(1);
+      expect(buffer.size).toBe(1);
+      buffer.push(2);
+      expect(buffer.size).toBe(2);
+      buffer.push(3);
+      expect(buffer.size).toBe(3);
+    });
+  });
+
+  // ==========================================================================
+  // Circular overflow
+  // ==========================================================================
+
+  describe('circular overflow', () => {
+    test('pushing more than maxSize drops oldest items', () => {
+      const buffer = new TimeSeriesBuffer<number>(3);
+      buffer.push(1);
+      buffer.push(2);
+      buffer.push(3);
+      buffer.push(4); // overwrites 1
+
+      const all = buffer.getAll();
+      expect(all).toHaveLength(3);
+      expect(all.map(p => p.data)).toEqual([2, 3, 4]);
+    });
+
+    test('size stays at maxSize after overflow', () => {
+      const buffer = new TimeSeriesBuffer<number>(3);
+      for (let i = 0; i < 10; i++) {
+        buffer.push(i);
+      }
+      expect(buffer.size).toBe(3);
+    });
+
+    test('newest items are kept after overflow', () => {
+      const buffer = new TimeSeriesBuffer<number>(5);
+      for (let i = 0; i < 20; i++) {
+        buffer.push(i);
+      }
+      const all = buffer.getAll();
+      expect(all.map(p => p.data)).toEqual([15, 16, 17, 18, 19]);
+    });
+  });
+
+  // ==========================================================================
+  // getRange
+  // ==========================================================================
+
+  describe('getRange', () => {
+    test('returns points within the specified timestamp range', () => {
+      const buffer = new TimeSeriesBuffer<string>(10);
+      const now = Date.now();
+
+      // Push items with known timestamps by mocking Date.now
+      const originalNow = Date.now;
+      let fakeTime = now;
+      Date.now = () => fakeTime;
+
+      fakeTime = 1000;
+      buffer.push('a');
+      fakeTime = 2000;
+      buffer.push('b');
+      fakeTime = 3000;
+      buffer.push('c');
+      fakeTime = 4000;
+      buffer.push('d');
+
+      Date.now = originalNow;
+
+      const result = buffer.getRange(2000, 3000);
+      expect(result).toHaveLength(2);
+      expect(result[0].data).toBe('b');
+      expect(result[1].data).toBe('c');
+    });
+
+    test('returns empty array if no points match the range', () => {
+      const buffer = new TimeSeriesBuffer<number>(10);
+      const originalNow = Date.now;
+      Date.now = () => 1000;
+      buffer.push(1);
+      Date.now = originalNow;
+
+      const result = buffer.getRange(5000, 6000);
+      expect(result).toEqual([]);
+    });
+  });
+
+  // ==========================================================================
+  // getLast
+  // ==========================================================================
+
+  describe('getLast', () => {
+    test('returns last n items', () => {
+      const buffer = new TimeSeriesBuffer<number>(10);
+      buffer.push(1);
+      buffer.push(2);
+      buffer.push(3);
+      buffer.push(4);
+      buffer.push(5);
+
+      const last3 = buffer.getLast(3);
+      expect(last3).toHaveLength(3);
+      expect(last3.map(p => p.data)).toEqual([3, 4, 5]);
+    });
+
+    test('handles n greater than size by returning all items', () => {
+      const buffer = new TimeSeriesBuffer<number>(10);
+      buffer.push(1);
+      buffer.push(2);
+
+      const result = buffer.getLast(10);
+      expect(result).toHaveLength(2);
+      expect(result.map(p => p.data)).toEqual([1, 2]);
+    });
+  });
+
+  // ==========================================================================
+  // clear
+  // ==========================================================================
+
+  describe('clear', () => {
+    test('resets buffer to empty', () => {
+      const buffer = new TimeSeriesBuffer<number>(10);
+      buffer.push(1);
+      buffer.push(2);
+      buffer.push(3);
+
+      buffer.clear();
+      expect(buffer.getAll()).toEqual([]);
+    });
+
+    test('resets size to 0', () => {
+      const buffer = new TimeSeriesBuffer<number>(10);
+      buffer.push(1);
+      buffer.push(2);
+
+      buffer.clear();
+      expect(buffer.size).toBe(0);
+    });
+  });
+});

package/tests/unit/lib/utils.test.ts

@@ -0,0 +1,24 @@
+import { describe, test, expect } from 'bun:test';
+import { cn } from '@/lib/utils';
+
+describe('cn (classname merge utility)', () => {
+  test('merges multiple class strings', () => {
+    expect(cn('foo', 'bar')).toBe('foo bar');
+  });
+
+  test('handles conditional classes', () => {
+    expect(cn('base', false && 'hidden', 'extra')).toBe('base extra');
+  });
+
+  test('merges tailwind classes correctly', () => {
+    expect(cn('p-4', 'p-2')).toBe('p-2');
+  });
+
+  test('handles undefined and null inputs', () => {
+    expect(cn('foo', undefined, null, 'bar')).toBe('foo bar');
+  });
+
+  test('returns empty string for no inputs', () => {
+    expect(cn()).toBe('');
+  });
+});

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

@@ -0,0 +1,238 @@
+import { describe, test, expect } from 'bun:test';
+import {
+  type LLMConfig,
+  type LLMStreamOptions,
+  LLMConfigError,
+} from '@/lib/llm/types';
+import { BaseLLMProvider } from '@/lib/llm/base-provider';
+
+// ============================================================================
+// Concrete Test Provider (BaseLLMProvider is abstract)
+// ============================================================================
+
+class TestProvider extends BaseLLMProvider {
+  constructor(config: LLMConfig) {
+    super(config);
+  }
+
+  async stream(): Promise<ReadableStream<Uint8Array>> {
+    return new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.close();
+      },
+    });
+  }
+}
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+function makeConfig(overrides?: Partial<LLMConfig>): LLMConfig {
+  return {
+    provider: 'gemini',
+    apiKey: 'test-api-key',
+    model: 'test-model',
+    apiUrl: 'https://api.example.com/v1',
+    ...overrides,
+  };
+}
+
+function makeStreamOptions(overrides?: Partial<LLMStreamOptions>): LLMStreamOptions {
+  return {
+    messages: [{ role: 'user', content: 'Hello' }],
+    ...overrides,
+  };
+}
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+describe('BaseLLMProvider', () => {
+  // --------------------------------------------------------------------------
+  // constructor
+  // --------------------------------------------------------------------------
+
+  describe('constructor', () => {
+    test('sets name from config.provider', () => {
+      const provider = new TestProvider(makeConfig({ provider: 'openai' }));
+      expect(provider.name).toBe('openai');
+    });
+
+    test('sets config', () => {
+      const config = makeConfig({ model: 'my-model', apiKey: 'my-key' });
+      const provider = new TestProvider(config);
+      expect(provider.config).toEqual(config);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // validate()
+  // --------------------------------------------------------------------------
+
+  describe('validate()', () => {
+    test('calls validateConfig', () => {
+      // Valid config should not throw
+      const provider = new TestProvider(
+        makeConfig({ provider: 'gemini', apiKey: 'key', model: 'model' })
+      );
+      expect(() => provider.validate()).not.toThrow();
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // getModel() — accessed via stream behavior, tested indirectly
+  // We can test by creating a subclass that exposes the protected method
+  // --------------------------------------------------------------------------
+
+  describe('getModel()', () => {
+    class ExposedProvider extends TestProvider {
+      public exposedGetModel(options: LLMStreamOptions): string {
+        return this.getModel(options);
+      }
+    }
+
+    test('returns options.model when provided', () => {
+      const provider = new ExposedProvider(makeConfig({ model: 'config-model' }));
+      const model = provider.exposedGetModel(
+        makeStreamOptions({ model: 'options-model' })
+      );
+      expect(model).toBe('options-model');
+    });
+
+    test('falls back to config.model', () => {
+      const provider = new ExposedProvider(makeConfig({ model: 'config-model' }));
+      const model = provider.exposedGetModel(makeStreamOptions());
+      expect(model).toBe('config-model');
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // getSystemMessage()
+  // --------------------------------------------------------------------------
+
+  describe('getSystemMessage()', () => {
+    class ExposedProvider extends TestProvider {
+      public exposedGetSystemMessage(options: LLMStreamOptions): string | undefined {
+        return this.getSystemMessage(options);
+      }
+    }
+
+    test('returns system message content', () => {
+      const provider = new ExposedProvider(makeConfig());
+      const systemMsg = provider.exposedGetSystemMessage(
+        makeStreamOptions({
+          messages: [
+            { role: 'system', content: 'You are a helpful assistant.' },
+            { role: 'user', content: 'Hello' },
+          ],
+        })
+      );
+      expect(systemMsg).toBe('You are a helpful assistant.');
+    });
+
+    test('returns undefined when no system message', () => {
+      const provider = new ExposedProvider(makeConfig());
+      const systemMsg = provider.exposedGetSystemMessage(
+        makeStreamOptions({
+          messages: [{ role: 'user', content: 'Hello' }],
+        })
+      );
+      expect(systemMsg).toBeUndefined();
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // getNonSystemMessages()
+  // --------------------------------------------------------------------------
+
+  describe('getNonSystemMessages()', () => {
+    class ExposedProvider extends TestProvider {
+      public exposedGetNonSystemMessages(
+        options: LLMStreamOptions
+      ): Array<{ role: 'user' | 'assistant'; content: string }> {
+        return this.getNonSystemMessages(options);
+      }
+    }
+
+    test('filters out system messages', () => {
+      const provider = new ExposedProvider(makeConfig());
+      const messages = provider.exposedGetNonSystemMessages(
+        makeStreamOptions({
+          messages: [
+            { role: 'system', content: 'System prompt' },
+            { role: 'user', content: 'User message' },
+          ],
+        })
+      );
+      expect(messages).toHaveLength(1);
+      expect(messages[0].role).toBe('user');
+      expect(messages[0].content).toBe('User message');
+    });
+
+    test('returns user and assistant messages', () => {
+      const provider = new ExposedProvider(makeConfig());
+      const messages = provider.exposedGetNonSystemMessages(
+        makeStreamOptions({
+          messages: [
+            { role: 'system', content: 'Be helpful' },
+            { role: 'user', content: 'Hello' },
+            { role: 'assistant', content: 'Hi!' },
+            { role: 'user', content: 'How are you?' },
+          ],
+        })
+      );
+      expect(messages).toHaveLength(3);
+      expect(messages[0]).toEqual({ role: 'user', content: 'Hello' });
+      expect(messages[1]).toEqual({ role: 'assistant', content: 'Hi!' });
+      expect(messages[2]).toEqual({ role: 'user', content: 'How are you?' });
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // ensureApiKey()
+  // --------------------------------------------------------------------------
+
+  describe('ensureApiKey()', () => {
+    class ExposedProvider extends TestProvider {
+      public exposedEnsureApiKey(): string {
+        return this.ensureApiKey();
+      }
+    }
+
+    test('returns apiKey when present', () => {
+      const provider = new ExposedProvider(makeConfig({ apiKey: 'my-key-123' }));
+      expect(provider.exposedEnsureApiKey()).toBe('my-key-123');
+    });
+
+    test('throws LLMConfigError when missing', () => {
+      const provider = new ExposedProvider(makeConfig({ apiKey: undefined }));
+      expect(() => provider.exposedEnsureApiKey()).toThrow(LLMConfigError);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // ensureApiUrl()
+  // --------------------------------------------------------------------------
+
+  describe('ensureApiUrl()', () => {
+    class ExposedProvider extends TestProvider {
+      public exposedEnsureApiUrl(): string {
+        return this.ensureApiUrl();
+      }
+    }
+
+    test('returns apiUrl when present', () => {
+      const provider = new ExposedProvider(
+        makeConfig({ apiUrl: 'https://api.example.com/v1' })
+      );
+      expect(provider.exposedEnsureApiUrl()).toBe('https://api.example.com/v1');
+    });
+
+    test('throws LLMConfigError when missing', () => {
+      const provider = new ExposedProvider(makeConfig({ apiUrl: undefined }));
+      expect(() => provider.exposedEnsureApiUrl()).toThrow(LLMConfigError);
+    });
+  });
+});