@libredb/studio 0.9.7

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

@@ -0,0 +1,326 @@
+import { describe, test, expect, beforeEach } from 'bun:test';
+import {
+  AuditRingBuffer,
+  type AuditEvent,
+  type AuditEventType,
+  loadAuditFromStorage,
+  saveAuditToStorage,
+} from '@/lib/audit';
+
+describe('AuditRingBuffer', () => {
+  let buffer: AuditRingBuffer;
+
+  beforeEach(() => {
+    buffer = new AuditRingBuffer(10);
+  });
+
+  // ==========================================================================
+  // push
+  // ==========================================================================
+
+  describe('push', () => {
+    test('generates id and timestamp on pushed event', () => {
+      const result = buffer.push({
+        type: 'query_execution',
+        action: 'execute',
+        target: 'users',
+        user: 'admin',
+        result: 'success',
+      });
+
+      expect(result.id).toBeDefined();
+      expect(typeof result.id).toBe('string');
+      expect(result.id.length).toBeGreaterThan(0);
+      expect(result.timestamp).toBeDefined();
+      // ISO date string format check
+      expect(() => new Date(result.timestamp)).not.toThrow();
+    });
+
+    test('returns the full AuditEvent with all fields', () => {
+      const result = buffer.push({
+        type: 'maintenance',
+        action: 'vacuum',
+        target: 'orders',
+        connectionName: 'prod-db',
+        user: 'admin',
+        result: 'success',
+        duration: 1500,
+        details: 'Vacuum completed',
+      });
+
+      expect(result.type).toBe('maintenance');
+      expect(result.action).toBe('vacuum');
+      expect(result.target).toBe('orders');
+      expect(result.connectionName).toBe('prod-db');
+      expect(result.user).toBe('admin');
+      expect(result.result).toBe('success');
+      expect(result.duration).toBe(1500);
+      expect(result.details).toBe('Vacuum completed');
+    });
+  });
+
+  // ==========================================================================
+  // getAll
+  // ==========================================================================
+
+  describe('getAll', () => {
+    test('returns a copy of events (not the internal array)', () => {
+      buffer.push({ type: 'query_execution', action: 'run', target: 't1', user: 'u', result: 'success' });
+      const all1 = buffer.getAll();
+      const all2 = buffer.getAll();
+      expect(all1).not.toBe(all2);
+      expect(all1).toEqual(all2);
+    });
+
+    test('returns events in chronological order', () => {
+      buffer.push({ type: 'query_execution', action: 'a1', target: 't1', user: 'u', result: 'success' });
+      buffer.push({ type: 'maintenance', action: 'a2', target: 't2', user: 'u', result: 'failure' });
+      buffer.push({ type: 'kill_session', action: 'a3', target: 't3', user: 'u', result: 'success' });
+
+      const all = buffer.getAll();
+      expect(all[0].action).toBe('a1');
+      expect(all[1].action).toBe('a2');
+      expect(all[2].action).toBe('a3');
+    });
+  });
+
+  // ==========================================================================
+  // getRecent
+  // ==========================================================================
+
+  describe('getRecent', () => {
+    test('returns last N events', () => {
+      for (let i = 0; i < 5; i++) {
+        buffer.push({ type: 'query_execution', action: `action-${i}`, target: 't', user: 'u', result: 'success' });
+      }
+
+      const recent = buffer.getRecent(3);
+      expect(recent).toHaveLength(3);
+      expect(recent[0].action).toBe('action-2');
+      expect(recent[1].action).toBe('action-3');
+      expect(recent[2].action).toBe('action-4');
+    });
+  });
+
+  // ==========================================================================
+  // filter
+  // ==========================================================================
+
+  describe('filter', () => {
+    beforeEach(() => {
+      buffer.push({ type: 'query_execution', action: 'exec', target: 't1', connectionName: 'prod', user: 'admin', result: 'success' });
+      buffer.push({ type: 'maintenance', action: 'vacuum', target: 't2', connectionName: 'staging', user: 'admin', result: 'failure' });
+      buffer.push({ type: 'query_execution', action: 'exec', target: 't3', connectionName: 'prod', user: 'user1', result: 'failure' });
+      buffer.push({ type: 'kill_session', action: 'kill', target: 'pid-1', connectionName: 'prod', user: 'admin', result: 'success' });
+    });
+
+    test('filters by type', () => {
+      const result = buffer.filter({ type: 'query_execution' });
+      expect(result).toHaveLength(2);
+      result.forEach(e => expect(e.type).toBe('query_execution'));
+    });
+
+    test('filters by result', () => {
+      const result = buffer.filter({ result: 'failure' });
+      expect(result).toHaveLength(2);
+      result.forEach(e => expect(e.result).toBe('failure'));
+    });
+
+    test('filters by connectionName', () => {
+      const result = buffer.filter({ connectionName: 'staging' });
+      expect(result).toHaveLength(1);
+      expect(result[0].action).toBe('vacuum');
+    });
+
+    test('filters by since (timestamp string comparison)', () => {
+      const all = buffer.getAll();
+      // Use the timestamp of the 3rd event as "since"
+      const sinceTimestamp = all[2].timestamp;
+      const result = buffer.filter({ since: sinceTimestamp });
+      expect(result.length).toBeGreaterThanOrEqual(2);
+    });
+
+    test('combines multiple filters', () => {
+      const result = buffer.filter({ type: 'query_execution', result: 'success', connectionName: 'prod' });
+      expect(result).toHaveLength(1);
+      expect(result[0].action).toBe('exec');
+      expect(result[0].target).toBe('t1');
+    });
+  });
+
+  // ==========================================================================
+  // clear
+  // ==========================================================================
+
+  describe('clear', () => {
+    test('empties the buffer', () => {
+      buffer.push({ type: 'query_execution', action: 'x', target: 't', user: 'u', result: 'success' });
+      buffer.push({ type: 'maintenance', action: 'y', target: 't', user: 'u', result: 'success' });
+
+      buffer.clear();
+      expect(buffer.getAll()).toEqual([]);
+    });
+
+    test('resets size to 0', () => {
+      buffer.push({ type: 'query_execution', action: 'x', target: 't', user: 'u', result: 'success' });
+      buffer.clear();
+      expect(buffer.size).toBe(0);
+    });
+  });
+
+  // ==========================================================================
+  // size
+  // ==========================================================================
+
+  describe('size', () => {
+    test('tracks number of events correctly', () => {
+      expect(buffer.size).toBe(0);
+      buffer.push({ type: 'query_execution', action: 'a', target: 't', user: 'u', result: 'success' });
+      expect(buffer.size).toBe(1);
+      buffer.push({ type: 'maintenance', action: 'b', target: 't', user: 'u', result: 'success' });
+      expect(buffer.size).toBe(2);
+    });
+  });
+
+  // ==========================================================================
+  // toJSON
+  // ==========================================================================
+
+  describe('toJSON', () => {
+    test('returns events array', () => {
+      buffer.push({ type: 'query_execution', action: 'exec', target: 't', user: 'u', result: 'success' });
+      const json = buffer.toJSON();
+      expect(Array.isArray(json)).toBe(true);
+      expect(json).toHaveLength(1);
+      expect(json[0].action).toBe('exec');
+    });
+  });
+
+  // ==========================================================================
+  // loadFrom
+  // ==========================================================================
+
+  describe('loadFrom', () => {
+    test('loads events into the buffer', () => {
+      const events: AuditEvent[] = [
+        { id: '1', timestamp: '2026-01-01T00:00:00Z', type: 'query_execution', action: 'a1', target: 't', user: 'u', result: 'success' },
+        { id: '2', timestamp: '2026-01-02T00:00:00Z', type: 'maintenance', action: 'a2', target: 't', user: 'u', result: 'failure' },
+      ];
+
+      buffer.loadFrom(events);
+      expect(buffer.size).toBe(2);
+      expect(buffer.getAll()[0].id).toBe('1');
+      expect(buffer.getAll()[1].id).toBe('2');
+    });
+
+    test('trims to maxSize if loaded events exceed capacity', () => {
+      const smallBuffer = new AuditRingBuffer(3);
+      const events: AuditEvent[] = Array.from({ length: 10 }, (_, i) => ({
+        id: `id-${i}`,
+        timestamp: `2026-01-${String(i + 1).padStart(2, '0')}T00:00:00Z`,
+        type: 'query_execution' as AuditEventType,
+        action: `action-${i}`,
+        target: 't',
+        user: 'u',
+        result: 'success' as const,
+      }));
+
+      smallBuffer.loadFrom(events);
+      expect(smallBuffer.size).toBe(3);
+      // Should keep the last 3 events
+      const all = smallBuffer.getAll();
+      expect(all[0].id).toBe('id-7');
+      expect(all[1].id).toBe('id-8');
+      expect(all[2].id).toBe('id-9');
+    });
+  });
+
+  // ==========================================================================
+  // Max size enforcement
+  // ==========================================================================
+
+  describe('max size enforcement', () => {
+    test('pushing beyond maxSize drops oldest events', () => {
+      const smallBuffer = new AuditRingBuffer(3);
+      for (let i = 0; i < 5; i++) {
+        smallBuffer.push({ type: 'query_execution', action: `a-${i}`, target: 't', user: 'u', result: 'success' });
+      }
+
+      expect(smallBuffer.size).toBe(3);
+      const all = smallBuffer.getAll();
+      expect(all[0].action).toBe('a-2');
+      expect(all[1].action).toBe('a-3');
+      expect(all[2].action).toBe('a-4');
+    });
+  });
+});
+
+// ============================================================================
+// Storage Functions
+// Note: loadAuditFromStorage / saveAuditToStorage check
+// `typeof window === 'undefined'` and bail out in SSR.
+// We define globalThis.window so the code reaches localStorage.
+// ============================================================================
+
+// Set up window globally for storage tests — only once, non-deletable is fine
+if (typeof globalThis.window === 'undefined') {
+  Object.defineProperty(globalThis, 'window', {
+    value: globalThis,
+    writable: true,
+    configurable: true,
+  });
+}
+
+describe('loadAuditFromStorage', () => {
+  test('returns empty array when localStorage is empty', () => {
+    const result = loadAuditFromStorage();
+    expect(result).toEqual([]);
+  });
+
+  test('returns parsed events from localStorage', () => {
+    const events: AuditEvent[] = [
+      { id: '1', timestamp: '2026-01-01T00:00:00Z', type: 'query_execution', action: 'exec', target: 't', user: 'u', result: 'success' },
+    ];
+    localStorage.setItem('libredb_audit_log', JSON.stringify(events));
+
+    const result = loadAuditFromStorage();
+    expect(result).toHaveLength(1);
+    expect(result[0].id).toBe('1');
+  });
+});
+
+describe('saveAuditToStorage', () => {
+  test('saves events to localStorage', () => {
+    const events: AuditEvent[] = [
+      { id: '1', timestamp: '2026-01-01T00:00:00Z', type: 'query_execution', action: 'exec', target: 't', user: 'u', result: 'success' },
+    ];
+    saveAuditToStorage(events);
+
+    const stored = localStorage.getItem('libredb_audit_log');
+    expect(stored).not.toBeNull();
+    const parsed = JSON.parse(stored!);
+    expect(parsed).toHaveLength(1);
+    expect(parsed[0].id).toBe('1');
+  });
+
+  test('trims events to 1000 before saving', () => {
+    const events: AuditEvent[] = Array.from({ length: 1500 }, (_, i) => ({
+      id: `id-${i}`,
+      timestamp: '2026-01-01T00:00:00Z',
+      type: 'query_execution' as AuditEventType,
+      action: `action-${i}`,
+      target: 't',
+      user: 'u',
+      result: 'success' as const,
+    }));
+
+    saveAuditToStorage(events);
+
+    const stored = localStorage.getItem('libredb_audit_log');
+    const parsed = JSON.parse(stored!);
+    expect(parsed).toHaveLength(1000);
+    // Should keep the last 1000 (indices 500-1499)
+    expect(parsed[0].id).toBe('id-500');
+    expect(parsed[999].id).toBe('id-1499');
+  });
+});

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

@@ -0,0 +1,146 @@
+import { describe, test, expect, mock, beforeEach } from 'bun:test';
+
+// ============================================================================
+// Mock State — only mock next/headers (cookies), NOT jose
+// jose is used for real JWT sign/verify with JWT_SECRET from setup.ts
+// ============================================================================
+
+let mockCookieStore: Record<string, { value: string } | undefined> = {};
+let mockSetCalls: Array<{ name: string; value: string; opts: unknown }> = [];
+let mockDeleteCalls: string[] = [];
+
+// ============================================================================
+// Module Mocks — only next/headers
+// ============================================================================
+
+mock.module('next/headers', () => ({
+  cookies: async () => ({
+    get: (name: string) => mockCookieStore[name],
+    set: (name: string, value: string, opts: unknown) => {
+      mockSetCalls.push({ name, value, opts });
+      mockCookieStore[name] = { value };
+    },
+    delete: (name: string) => {
+      mockDeleteCalls.push(name);
+      delete mockCookieStore[name];
+    },
+  }),
+}));
+
+// ============================================================================
+// Import module under test (after mocks)
+// ============================================================================
+
+const { signJWT, verifyJWT, getSession, login, logout } = await import('@/lib/auth');
+
+// ============================================================================
+// Tests — use real jose sign/verify with JWT_SECRET from tests/setup.ts
+// ============================================================================
+
+describe('auth', () => {
+  beforeEach(() => {
+    mockCookieStore = {};
+    mockSetCalls = [];
+    mockDeleteCalls = [];
+  });
+
+  // --------------------------------------------------------------------------
+  // signJWT()
+  // --------------------------------------------------------------------------
+
+  describe('signJWT()', () => {
+    test('returns a token string', async () => {
+      const token = await signJWT({ role: 'admin', username: 'admin' });
+      expect(typeof token).toBe('string');
+      expect(token.length).toBeGreaterThan(0);
+      // Real JWT has 3 dot-separated parts
+      expect(token.split('.').length).toBe(3);
+    });
+
+    test('accepts admin role', async () => {
+      const token = await signJWT({ role: 'admin', username: 'admin' });
+      expect(typeof token).toBe('string');
+    });
+
+    test('accepts user role', async () => {
+      const token = await signJWT({ role: 'user', username: 'user' });
+      expect(typeof token).toBe('string');
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // verifyJWT()
+  // --------------------------------------------------------------------------
+
+  describe('verifyJWT()', () => {
+    test('valid token returns UserPayload', async () => {
+      const token = await signJWT({ role: 'admin', username: 'admin' });
+      const payload = await verifyJWT(token);
+      expect(payload).not.toBeNull();
+      expect(payload!.role).toBe('admin');
+      expect(payload!.username).toBe('admin');
+    });
+
+    test('invalid token returns null', async () => {
+      const payload = await verifyJWT('invalid-token-string');
+      expect(payload).toBeNull();
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // getSession()
+  // --------------------------------------------------------------------------
+
+  describe('getSession()', () => {
+    test('returns payload when auth-token cookie exists', async () => {
+      const token = await signJWT({ role: 'user', username: 'user' });
+      mockCookieStore['auth-token'] = { value: token };
+
+      const session = await getSession();
+      expect(session).not.toBeNull();
+      expect(session!.role).toBe('user');
+      expect(session!.username).toBe('user');
+    });
+
+    test('returns null when no cookie', async () => {
+      const session = await getSession();
+      expect(session).toBeNull();
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // login()
+  // --------------------------------------------------------------------------
+
+  describe('login()', () => {
+    test('sets auth-token cookie with admin role', async () => {
+      await login('admin', 'admin');
+      expect(mockSetCalls.length).toBeGreaterThan(0);
+      expect(mockSetCalls[0].name).toBe('auth-token');
+      // Verify the token is valid
+      const token = mockSetCalls[0].value;
+      const payload = await verifyJWT(token);
+      expect(payload).not.toBeNull();
+      expect(payload!.role).toBe('admin');
+    });
+
+    test('sets auth-token cookie with user role', async () => {
+      await login('user', 'user');
+      expect(mockSetCalls.length).toBeGreaterThan(0);
+      const token = mockSetCalls[0].value;
+      const payload = await verifyJWT(token);
+      expect(payload!.role).toBe('user');
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // logout()
+  // --------------------------------------------------------------------------
+
+  describe('logout()', () => {
+    test('deletes auth-token cookie', async () => {
+      await logout();
+      expect(mockDeleteCalls).toContain('auth-token');
+    });
+  });
+});