transduck 0.5.3 → 0.6.1

package/tests/shared-store.test.ts

@@ -0,0 +1,210 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { createHash } from 'crypto';
+
+function contentHash(sourceText: string, projectContextHash: string, stringContextHash: string): string {
+  return createHash('sha256')
+    .update(sourceText + '\x00' + projectContextHash + '\x00' + stringContextHash)
+    .digest('hex');
+}
+
+// Mock pg module
+const mockQuery = vi.fn();
+const mockEnd = vi.fn();
+
+vi.mock('pg', () => ({
+  default: {
+    Pool: vi.fn(() => ({
+      query: mockQuery,
+      end: mockEnd,
+    })),
+  },
+  Pool: vi.fn(() => ({
+    query: mockQuery,
+    end: mockEnd,
+  })),
+}));
+
+const { SharedStore } = await import('../src/shared-store.js');
+
+describe('SharedStore', () => {
+  let store: InstanceType<typeof SharedStore>;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    store = new SharedStore('postgres://localhost/test');
+    mockQuery.mockResolvedValueOnce({}); // for CREATE TABLE
+    await store.initialize();
+    vi.clearAllMocks(); // clear the initialize call
+  });
+
+  it('creates the table on initialize', async () => {
+    const fresh = new SharedStore('postgres://localhost/test');
+    mockQuery.mockResolvedValueOnce({});
+    await fresh.initialize();
+    expect(mockQuery).toHaveBeenCalledOnce();
+    expect(mockQuery.mock.calls[0][0]).toContain('CREATE TABLE IF NOT EXISTS');
+    expect(mockQuery.mock.calls[0][0]).toContain('transduck_translations');
+  });
+
+  it('lookup returns translated text when found', async () => {
+    mockQuery.mockResolvedValueOnce({
+      rows: [{ translated_text: 'Hallo' }],
+    });
+    const result = await store.lookup({
+      sourceText: 'Hello',
+      sourceLang: 'EN',
+      targetLang: 'DE',
+      projectContextHash: 'ph',
+      stringContextHash: 'sh',
+    });
+    expect(result).toBe('Hallo');
+    expect(mockQuery.mock.calls[0][1]).toEqual([
+      'EN', 'DE', contentHash('Hello', 'ph', 'sh'),
+    ]);
+  });
+
+  it('lookup returns null when not found', async () => {
+    mockQuery.mockResolvedValueOnce({ rows: [] });
+    mockQuery.mockResolvedValueOnce({ rows: [] }); // secondary context check
+    const result = await store.lookup({
+      sourceText: 'Hello',
+      sourceLang: 'EN',
+      targetLang: 'DE',
+      projectContextHash: 'ph',
+      stringContextHash: 'sh',
+    });
+    expect(result).toBeNull();
+  });
+
+  it('lookup logs debug when same text exists with different context hash', async () => {
+    // Primary lookup misses
+    mockQuery.mockResolvedValueOnce({ rows: [] });
+    // Secondary check finds a row with different context
+    mockQuery.mockResolvedValueOnce({ rows: [{ '?column?': 1 }] });
+    const debugSpy = vi.spyOn(console, 'debug').mockImplementation(() => {});
+    const result = await store.lookup({
+      sourceText: 'Hello',
+      sourceLang: 'EN',
+      targetLang: 'DE',
+      projectContextHash: 'ph',
+      stringContextHash: 'sh',
+    });
+    expect(result).toBeNull();
+    expect(debugSpy).toHaveBeenCalledOnce();
+    expect(debugSpy.mock.calls[0][0]).toContain('different project context hash');
+    debugSpy.mockRestore();
+  });
+
+  it('lookup does not log debug when no alternative context exists', async () => {
+    // Primary lookup misses
+    mockQuery.mockResolvedValueOnce({ rows: [] });
+    // Secondary check also misses
+    mockQuery.mockResolvedValueOnce({ rows: [] });
+    const debugSpy = vi.spyOn(console, 'debug').mockImplementation(() => {});
+    const result = await store.lookup({
+      sourceText: 'Hello',
+      sourceLang: 'EN',
+      targetLang: 'DE',
+      projectContextHash: 'ph',
+      stringContextHash: 'sh',
+    });
+    expect(result).toBeNull();
+    expect(debugSpy).not.toHaveBeenCalled();
+    debugSpy.mockRestore();
+  });
+
+  it('insert calls query with correct params', async () => {
+    mockQuery.mockResolvedValueOnce({});
+    await store.insert({
+      sourceText: 'Hello',
+      sourceLang: 'EN',
+      targetLang: 'DE',
+      projectContextHash: 'ph',
+      stringContextHash: 'sh',
+      stringContext: 'greeting',
+      translatedText: 'Hallo',
+      model: 'gpt-4.1-mini',
+      status: 'translated',
+    });
+    expect(mockQuery).toHaveBeenCalledOnce();
+    const [sql, params] = mockQuery.mock.calls[0];
+    expect(sql).toContain('INSERT INTO');
+    expect(sql).toContain('ON CONFLICT DO NOTHING');
+    expect(params[0]).toBe('EN');
+    expect(params[1]).toBe('DE');
+    expect(params[3]).toBe('Hello');
+    expect(params[4]).toBe('Hallo');
+    expect(params[5]).toBe('gpt-4.1-mini');
+    expect(params[6]).toBe('translated');
+  });
+
+  it('lookupPlural returns category map', async () => {
+    mockQuery.mockResolvedValueOnce({
+      rows: [
+        { plural_category: 'one', translated_text: 'ein Hund' },
+        { plural_category: 'other', translated_text: 'Hunde' },
+      ],
+    });
+    const result = await store.lookupPlural({
+      sourceText: 'dog\x00dogs',
+      sourceLang: 'EN',
+      targetLang: 'DE',
+      projectContextHash: 'ph',
+      stringContextHash: 'sh',
+    });
+    expect(result).toEqual({ one: 'ein Hund', other: 'Hunde' });
+  });
+
+  it('lookupPlural returns empty object when no rows', async () => {
+    mockQuery.mockResolvedValueOnce({ rows: [] });
+    const result = await store.lookupPlural({
+      sourceText: 'dog\x00dogs',
+      sourceLang: 'EN',
+      targetLang: 'DE',
+      projectContextHash: 'ph',
+      stringContextHash: 'sh',
+    });
+    expect(result).toEqual({});
+  });
+
+  it('insertPlural calls query with plural category', async () => {
+    mockQuery.mockResolvedValueOnce({});
+    await store.insertPlural({
+      sourceText: 'dog\x00dogs',
+      sourceLang: 'EN',
+      targetLang: 'DE',
+      projectContextHash: 'ph',
+      stringContextHash: 'sh',
+      stringContext: '',
+      pluralCategory: 'one',
+      translatedText: 'ein Hund',
+      model: 'gpt-4.1-mini',
+      status: 'translated',
+    });
+    expect(mockQuery).toHaveBeenCalledOnce();
+    const [sql, params] = mockQuery.mock.calls[0];
+    expect(sql).toContain('INSERT INTO');
+    expect(params[3]).toBe('one');
+    expect(params[5]).toBe('ein Hund');
+  });
+
+  it('stats returns aggregated counts', async () => {
+    mockQuery.mockResolvedValueOnce({
+      rows: [
+        { target_lang: 'DE', status: 'translated', count: '10' },
+        { target_lang: 'DE', status: 'failed', count: '2' },
+        { target_lang: 'ES', status: 'translated', count: '5' },
+      ],
+    });
+    const st = await store.stats();
+    expect(st.totalTranslations).toBe(15);
+    expect(st.totalFailed).toBe(2);
+    expect(st.byLanguage).toEqual({ DE: 10, ES: 5 });
+  });
+
+  it('close ends the pool', async () => {
+    mockEnd.mockResolvedValueOnce(undefined);
+    await store.close();
+    expect(mockEnd).toHaveBeenCalledOnce();
+  });
+});