claw-dashboard 2.1.1 → 2.2.0

package/tests/database.test.js

@@ -1,438 +0,0 @@
-/**
- * Unit tests for database.js
- * Tests history persistence and metrics storage
- */
-
-import {
-  initDatabase,
-  closeDatabase,
-  storeSessionSnapshot,
-  storeCpuMetrics,
-  storeMemoryMetrics,
-  storeNetworkMetrics,
-  storeMetricsSnapshot,
-  getSessionsLast24Hours,
-  getSessionsLast7Days,
-  getSessionsByHours,
-  getSessionsByDays,
-  getCpuMetricsHistory,
-  getMemoryMetricsHistory,
-  getNetworkMetricsHistory,
-  getMetricsSummary,
-  cleanupOldData,
-} from '../src/database.js';
-
-describe('Database', () => {
-  // Clean up after each test
-  afterEach(async () => {
-    await closeDatabase();
-  });
-
-  describe('initDatabase', () => {
-    test('should initialize database successfully', async () => {
-      const result = await initDatabase();
-      expect(result).toBe(true);
-    });
-
-    test('should handle errors gracefully', async () => {
-      // Second initialization should still work
-      await initDatabase();
-      const result = await initDatabase();
-      expect(result).toBe(true);
-    });
-  });
-
-  describe('storeSessionSnapshot', () => {
-    test('should store session with all fields', async () => {
-      await initDatabase();
-
-      const session = {
-        sessionId: 'test-session-1',
-        key: 'agent:main:main',
-        agent: 'test-agent',
-        deliveryContext: { channel: 'test-channel' },
-        model: 'gpt-4',
-        totalTokens: 1500,
-        status: 'running',
-      };
-
-      // Should not throw
-      expect(() => storeSessionSnapshot(session)).not.toThrow();
-    });
-
-    test('should handle null session gracefully', () => {
-      // Should not throw even without database
-      expect(() => storeSessionSnapshot(null)).not.toThrow();
-    });
-
-    test('should handle session with minimal fields', async () => {
-      await initDatabase();
-
-      const session = {
-        sessionId: 'minimal-session',
-        key: 'agent:test',
-      };
-
-      expect(() => storeSessionSnapshot(session)).not.toThrow();
-    });
-
-    test('should extract agent from session key', async () => {
-      await initDatabase();
-
-      const session = {
-        key: 'agent:my-agent:instance',
-        sessionId: 'test',
-      };
-
-      expect(() => storeSessionSnapshot(session)).not.toThrow();
-    });
-
-    test('should handle alternative field names', async () => {
-      await initDatabase();
-
-      const session = {
-        key: 'test-key',
-        llmModel: 'claude',
-        tokens: 500,
-        systemRunning: true,
-      };
-
-      expect(() => storeSessionSnapshot(session)).not.toThrow();
-    });
-  });
-
-  describe('storeCpuMetrics', () => {
-    test('should store CPU metrics', async () => {
-      await initDatabase();
-
-      const cpuData = {
-        cpus: [
-          {
-            load: 50,
-            loadAvg1: 0.5,
-            loadAvg5: 0.6,
-            loadAvg15: 0.7,
-            cpuUsageUser: 20,
-            cpuUsageSystem: 10,
-            cpuUsageIdle: 70,
-          },
-        ],
-      };
-
-      expect(() => storeCpuMetrics(cpuData)).not.toThrow();
-    });
-
-    test('should handle null data', () => {
-      // Should not throw
-      expect(() => storeCpuMetrics(null)).not.toThrow();
-    });
-
-    test('should handle empty data', () => {
-      // Should not throw
-      expect(() => storeCpuMetrics({})).not.toThrow();
-    });
-
-    test('should handle object format (non-array)', async () => {
-      await initDatabase();
-
-      const cpuData = {
-        loadAvg1: 1.0,
-        loadAvg5: 2.0,
-        loadAvg15: 3.0,
-        cpuUsageUser: 25,
-        cpuUsageSystem: 15,
-        cpuUsageIdle: 60,
-      };
-
-      expect(() => storeCpuMetrics(cpuData)).not.toThrow();
-    });
-
-    test('should handle alternative field names', async () => {
-      await initDatabase();
-
-      const cpuData = {
-        cpu_count: 8,
-        load_avg_1: 1.5,
-        loadavg: [1.0, 2.0, 3.0],
-        cpuUsage: [20, 10, 70, 0, 0, 0],
-      };
-
-      expect(() => storeCpuMetrics(cpuData)).not.toThrow();
-    });
-  });
-
-  describe('storeMemoryMetrics', () => {
-    test('should store memory metrics', async () => {
-      await initDatabase();
-
-      const memoryData = {
-        totalBytes: 16000000000,
-        usedBytes: 8000000000,
-        freeBytes: 7000000000,
-        availableBytes: 7500000000,
-        usedPercent: 50,
-        swapTotalBytes: 2000000000,
-        swapUsedBytes: 500000000,
-        swapFreeBytes: 1500000000,
-        swapUsedPercent: 25,
-      };
-
-      expect(() => storeMemoryMetrics(memoryData)).not.toThrow();
-    });
-
-    test('should handle null data', () => {
-      expect(() => storeMemoryMetrics(null)).not.toThrow();
-    });
-
-    test('should handle alternative field names', async () => {
-      await initDatabase();
-
-      const memoryData = {
-        total_bytes: 16000000000,
-        used_bytes: 8000000000,
-        free_bytes: 7000000000,
-        available_bytes: 7500000000,
-        used_percent: 50,
-      };
-
-      expect(() => storeMemoryMetrics(memoryData)).not.toThrow();
-    });
-  });
-
-  describe('storeNetworkMetrics', () => {
-    test('should store network metrics', async () => {
-      await initDatabase();
-
-      const networkData = {
-        interfaceName: 'eth0',
-        rxBytes: 1000000,
-        txBytes: 500000,
-        rxSec: 1000,
-        txSec: 500,
-      };
-
-      expect(() => storeNetworkMetrics(networkData)).not.toThrow();
-    });
-
-    test('should handle array of interfaces', async () => {
-      await initDatabase();
-
-      const interfaces = [
-        { interfaceName: 'eth0', rxBytes: 100 },
-        { interfaceName: 'eth1', rxBytes: 200 },
-      ];
-
-      expect(() => storeNetworkMetrics(interfaces)).not.toThrow();
-    });
-
-    test('should handle null data', () => {
-      expect(() => storeNetworkMetrics(null)).not.toThrow();
-    });
-
-    test('should handle alternative field names', async () => {
-      await initDatabase();
-
-      const networkData = {
-        interface_name: 'wlan0',
-        rx_bytes: 1000000,
-        tx_bytes: 500000,
-        rx_sec: 1000,
-        tx_sec: 500,
-      };
-
-      expect(() => storeNetworkMetrics(networkData)).not.toThrow();
-    });
-  });
-
-  describe('storeMetricsSnapshot', () => {
-    test('should store all metrics from data object', async () => {
-      await initDatabase();
-
-      const data = {
-        cpu: { cpus: [{ load: 50 }] },
-        memory: { totalBytes: 16000000000, usedBytes: 8000000000 },
-        network: { interfaceName: 'eth0', rxBytes: 100 },
-        sessions: [
-          { sessionId: 's1', tokens: 100 },
-          { sessionId: 's2', tokens: 200 },
-        ],
-      };
-
-      expect(() => storeMetricsSnapshot(data)).not.toThrow();
-    });
-
-    test('should handle empty data', () => {
-      expect(() => storeMetricsSnapshot({})).not.toThrow();
-    });
-
-    test('should handle null data', () => {
-      expect(() => storeMetricsSnapshot(null)).not.toThrow();
-    });
-
-    test('should handle partial data', async () => {
-      await initDatabase();
-
-      // Only CPU data
-      expect(() => storeMetricsSnapshot({ cpu: { cpus: [] } })).not.toThrow();
-
-      // Only memory data
-      expect(() => storeMetricsSnapshot({ memory: {} })).not.toThrow();
-
-      // Only network data
-      expect(() => storeMetricsSnapshot({ network: {} })).not.toThrow();
-
-      // Only sessions
-      expect(() => storeMetricsSnapshot({ sessions: [] })).not.toThrow();
-    });
-  });
-
-  describe('getSessionsLast24Hours', () => {
-    test('should return array even when not initialized', () => {
-      const sessions = getSessionsLast24Hours();
-      expect(Array.isArray(sessions)).toBe(true);
-    });
-
-    test('should return array when initialized', async () => {
-      await initDatabase();
-      const sessions = getSessionsLast24Hours();
-      expect(Array.isArray(sessions)).toBe(true);
-    });
-  });
-
-  describe('getSessionsByHours', () => {
-    test('should return array even when not initialized', () => {
-      const sessions = getSessionsByHours(12);
-      expect(Array.isArray(sessions)).toBe(true);
-    });
-
-    test('should return array when initialized', async () => {
-      await initDatabase();
-      const sessions = getSessionsByHours(12);
-      expect(Array.isArray(sessions)).toBe(true);
-    });
-
-    test('should handle default hours parameter', async () => {
-      await initDatabase();
-      const sessions = getSessionsByHours();
-      expect(Array.isArray(sessions)).toBe(true);
-    });
-  });
-
-  describe('getSessionsByDays', () => {
-    test('should return array', async () => {
-      await initDatabase();
-      const sessions = getSessionsByDays(7);
-      expect(Array.isArray(sessions)).toBe(true);
-    });
-
-    test('should handle default days parameter', async () => {
-      await initDatabase();
-      const sessions = getSessionsByDays();
-      expect(Array.isArray(sessions)).toBe(true);
-    });
-  });
-
-  describe('getCpuMetricsHistory', () => {
-    test('should return empty array when not initialized', () => {
-      const metrics = getCpuMetricsHistory(24);
-      expect(metrics).toEqual([]);
-    });
-
-    test('should return array when initialized', async () => {
-      await initDatabase();
-      const metrics = getCpuMetricsHistory(24);
-      expect(Array.isArray(metrics)).toBe(true);
-    });
-
-    test('should handle default hours parameter', async () => {
-      await initDatabase();
-      const metrics = getCpuMetricsHistory();
-      expect(Array.isArray(metrics)).toBe(true);
-    });
-  });
-
-  describe('getMemoryMetricsHistory', () => {
-    test('should return empty array when not initialized', () => {
-      const metrics = getMemoryMetricsHistory(24);
-      expect(metrics).toEqual([]);
-    });
-
-    test('should return array when initialized', async () => {
-      await initDatabase();
-      const metrics = getMemoryMetricsHistory(24);
-      expect(Array.isArray(metrics)).toBe(true);
-    });
-  });
-
-  describe('getNetworkMetricsHistory', () => {
-    test('should return empty array when not initialized', () => {
-      const metrics = getNetworkMetricsHistory(24);
-      expect(metrics).toEqual([]);
-    });
-
-    test('should return array when initialized', async () => {
-      await initDatabase();
-      const metrics = getNetworkMetricsHistory(24);
-      expect(Array.isArray(metrics)).toBe(true);
-    });
-  });
-
-  describe('getMetricsSummary', () => {
-    test('should return null when not initialized', () => {
-      const summary = getMetricsSummary(24);
-      expect(summary).toBeNull();
-    });
-
-    test('should return summary when initialized', async () => {
-      await initDatabase();
-      const summary = getMetricsSummary(24);
-      expect(summary).toHaveProperty('cpu');
-      expect(summary).toHaveProperty('memory');
-      expect(summary).toHaveProperty('sessions');
-      expect(summary).toHaveProperty('tokens');
-    });
-
-    test('should handle default hours parameter', async () => {
-      await initDatabase();
-      const summary = getMetricsSummary();
-      expect(summary).toHaveProperty('cpu');
-      expect(summary).toHaveProperty('memory');
-    });
-  });
-
-  describe('cleanupOldData', () => {
-    test('should run without errors when initialized', async () => {
-      await initDatabase();
-      // Should not throw
-      expect(() => cleanupOldData(30)).not.toThrow();
-    });
-
-    test('should run without errors when not initialized', () => {
-      // Should not throw
-      expect(() => cleanupOldData(30)).not.toThrow();
-    });
-
-    test('should handle default days parameter', async () => {
-      await initDatabase();
-      expect(() => cleanupOldData()).not.toThrow();
-    });
-  });
-
-  describe('closeDatabase', () => {
-    test('should close database gracefully', async () => {
-      await initDatabase();
-      expect(() => closeDatabase()).not.toThrow();
-    });
-
-    test('should handle closing when not initialized', async () => {
-      expect(() => closeDatabase()).not.toThrow();
-    });
-
-    test('should allow re-initialization after close', async () => {
-      await initDatabase();
-      await closeDatabase();
-      const result = await initDatabase();
-      expect(result).toBe(true);
-    });
-  });
-});

package/tests/errors.test.js

@@ -1,189 +0,0 @@
-import {
-  DashboardError,
-  ConfigError,
-  SettingsError,
-  GatewayError,
-  SessionError,
-  DataFetchError,
-  AuthError,
-  NetworkError,
-  UIError,
-  DatabaseError,
-  ValidationError,
-  TimeoutError,
-  ERROR_CODES,
-  isDashboardError,
-  getErrorCode
-} from '../src/errors.js';
-
-describe('Custom Error Classes', () => {
-  describe('DashboardError', () => {
-    test('creates error with message, code, and details', () => {
-      const error = new DashboardError('Test error', 'TEST_CODE', { foo: 'bar' });
-      expect(error.message).toBe('Test error');
-      expect(error.code).toBe('TEST_CODE');
-      expect(error.details).toEqual({ foo: 'bar' });
-      expect(error.name).toBe('DashboardError');
-      expect(error.timestamp).toBeDefined();
-    });
-
-    test('provides default values for missing params', () => {
-      const error = new DashboardError('Test error');
-      expect(error.code).toBe('DASHBOARD_ERROR');
-      expect(error.details).toEqual({});
-    });
-
-    test('toJSON includes all properties', () => {
-      const error = new DashboardError('Test error', 'CODE', { key: 'value' });
-      const json = error.toJSON();
-      expect(json.message).toBe('Test error');
-      expect(json.code).toBe('CODE');
-      expect(json.details).toEqual({ key: 'value' });
-      expect(json.timestamp).toBeDefined();
-      expect(json.stack).toBeDefined();
-    });
-  });
-
-  describe('ConfigError', () => {
-    test('creates config error with correct code', () => {
-      const error = new ConfigError('Invalid config', { key: 'theme' });
-      expect(error.name).toBe('ConfigError');
-      expect(error.code).toBe('CONFIG_ERROR');
-    });
-  });
-
-  describe('SettingsError', () => {
-    test('creates settings error with correct code', () => {
-      const error = new SettingsError('Settings invalid', { path: '/path' });
-      expect(error.name).toBe('SettingsError');
-      expect(error.code).toBe('SETTINGS_ERROR');
-    });
-  });
-
-  describe('GatewayError', () => {
-    test('creates gateway error with correct code', () => {
-      const error = new GatewayError('Connection failed', { port: 18789 });
-      expect(error.name).toBe('GatewayError');
-      expect(error.code).toBe('GATEWAY_ERROR');
-    });
-  });
-
-  describe('SessionError', () => {
-    test('creates session error with correct code', () => {
-      const error = new SessionError('Session not found', { sessionId: 'abc' });
-      expect(error.name).toBe('SessionError');
-      expect(error.code).toBe('SESSION_ERROR');
-    });
-  });
-
-  describe('DataFetchError', () => {
-    test('creates data fetch error with correct code', () => {
-      const error = new DataFetchError('Failed to fetch CPU', { type: 'cpu' });
-      expect(error.name).toBe('DataFetchError');
-      expect(error.code).toBe('DATA_FETCH_ERROR');
-    });
-  });
-
-  describe('AuthError', () => {
-    test('creates auth error with correct code', () => {
-      const error = new AuthError('Unauthorized');
-      expect(error.name).toBe('AuthError');
-      expect(error.code).toBe('AUTH_ERROR');
-    });
-  });
-
-  describe('NetworkError', () => {
-    test('creates network error with correct code', () => {
-      const error = new NetworkError('Connection refused', { host: 'localhost' });
-      expect(error.name).toBe('NetworkError');
-      expect(error.code).toBe('NETWORK_ERROR');
-    });
-  });
-
-  describe('UIError', () => {
-    test('creates UI error with correct code', () => {
-      const error = new UIError('Render failed', { widget: 'cpu' });
-      expect(error.name).toBe('UIError');
-      expect(error.code).toBe('UI_ERROR');
-    });
-  });
-
-  describe('DatabaseError', () => {
-    test('creates database error with correct code', () => {
-      const error = new DatabaseError('Query failed', { operation: 'SELECT' });
-      expect(error.name).toBe('DatabaseError');
-      expect(error.code).toBe('DATABASE_ERROR');
-    });
-  });
-
-  describe('ValidationError', () => {
-    test('creates validation error with correct code', () => {
-      const error = new ValidationError('Invalid input', { field: 'refreshInterval' });
-      expect(error.name).toBe('ValidationError');
-      expect(error.code).toBe('VALIDATION_ERROR');
-    });
-  });
-
-  describe('TimeoutError', () => {
-    test('creates timeout error with correct code', () => {
-      const error = new TimeoutError('Operation timed out', { timeout: 5000 });
-      expect(error.name).toBe('TimeoutError');
-      expect(error.code).toBe('TIMEOUT_ERROR');
-    });
-  });
-
-  describe('ERROR_CODES constant', () => {
-    test('exports all expected error codes', () => {
-      expect(ERROR_CODES.CONFIG_ERROR).toBe('CONFIG_ERROR');
-      expect(ERROR_CODES.SETTINGS_ERROR).toBe('SETTINGS_ERROR');
-      expect(ERROR_CODES.GATEWAY_ERROR).toBe('GATEWAY_ERROR');
-      expect(ERROR_CODES.SESSION_ERROR).toBe('SESSION_ERROR');
-      expect(ERROR_CODES.DATA_FETCH_ERROR).toBe('DATA_FETCH_ERROR');
-      expect(ERROR_CODES.AUTH_ERROR).toBe('AUTH_ERROR');
-      expect(ERROR_CODES.NETWORK_ERROR).toBe('NETWORK_ERROR');
-      expect(ERROR_CODES.UI_ERROR).toBe('UI_ERROR');
-      expect(ERROR_CODES.DATABASE_ERROR).toBe('DATABASE_ERROR');
-      expect(ERROR_CODES.VALIDATION_ERROR).toBe('VALIDATION_ERROR');
-      expect(ERROR_CODES.TIMEOUT_ERROR).toBe('TIMEOUT_ERROR');
-    });
-  });
-
-  describe('isDashboardError', () => {
-    test('returns true for DashboardError instances', () => {
-      const error = new DashboardError('test');
-      expect(isDashboardError(error)).toBe(true);
-    });
-
-    test('returns true for subclass instances', () => {
-      const error = new ConfigError('test');
-      expect(isDashboardError(error)).toBe(true);
-    });
-
-    test('returns false for regular Error', () => {
-      const error = new Error('test');
-      expect(isDashboardError(error)).toBe(false);
-    });
-
-    test('returns false for null/undefined', () => {
-      expect(isDashboardError(null)).toBe(false);
-      expect(isDashboardError(undefined)).toBe(false);
-    });
-  });
-
-  describe('getErrorCode', () => {
-    test('returns code for DashboardError', () => {
-      const error = new GatewayError('test');
-      expect(getErrorCode(error)).toBe('GATEWAY_ERROR');
-    });
-
-    test('returns UNKNOWN_ERROR for regular Error', () => {
-      const error = new Error('test');
-      expect(getErrorCode(error)).toBe('UNKNOWN_ERROR');
-    });
-
-    test('returns UNKNOWN_ERROR for non-error values', () => {
-      expect(getErrorCode('string')).toBe('UNKNOWN_ERROR');
-      expect(getErrorCode({})).toBe('UNKNOWN_ERROR');
-    });
-  });
-});