@jmruthers/pace-core 0.5.117 → 0.5.119

package/src/components/DataTable/utils/__tests__/errorHandling.test.ts

@@ -0,0 +1,266 @@
+/**
+ * @file Error Handling Tests
+ * @package @jmruthers/pace-core
+ * @module Components/DataTable/Utils/__tests__
+ * @since 0.3.0
+ * 
+ * Tests for error handling stubs. These are minimal implementations
+ * required by useDataTablePerformance.ts to provide a consistent API contract.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  DataTableError,
+  DataTableErrorType,
+  ErrorRecoveryManager,
+  MemoryMonitor,
+  CircuitBreaker,
+  safeExecute,
+  DEFAULT_FALLBACK_CONFIG,
+  type FallbackConfig,
+} from '../errorHandling';
+
+describe('[unit] errorHandling', () => {
+  describe('DataTableErrorType', () => {
+    it('contains all expected error types', () => {
+      expect(DataTableErrorType.VIRTUALIZATION).toBe('virtualization');
+      expect(DataTableErrorType.SEARCH_INDEX).toBe('search_index');
+      expect(DataTableErrorType.DATA_CHUNK).toBe('data_chunk');
+      expect(DataTableErrorType.SERVER_FETCH).toBe('server_fetch');
+      expect(DataTableErrorType.MEMORY).toBe('memory');
+    });
+  });
+
+  describe('DataTableError', () => {
+    it('creates error with message and type', () => {
+      const error = new DataTableError('Test error', DataTableErrorType.VIRTUALIZATION);
+      
+      expect(error.message).toBe('Test error');
+      expect(error.type).toBe(DataTableErrorType.VIRTUALIZATION);
+      expect(error.name).toBe('DataTableError');
+      expect(error.recoverable).toBe(true);
+    });
+
+    it('creates error with custom recoverable flag', () => {
+      const error = new DataTableError('Test error', DataTableErrorType.MEMORY, false);
+      
+      expect(error.recoverable).toBe(false);
+    });
+
+    it('defaults recoverable to true', () => {
+      const error = new DataTableError('Test error', DataTableErrorType.SERVER_FETCH);
+      
+      expect(error.recoverable).toBe(true);
+    });
+
+    it('extends Error class', () => {
+      const error = new DataTableError('Test error', DataTableErrorType.DATA_CHUNK);
+      
+      expect(error).toBeInstanceOf(Error);
+      expect(error.stack).toBeDefined();
+    });
+
+    it('handles all error types', () => {
+      const types = [
+        DataTableErrorType.VIRTUALIZATION,
+        DataTableErrorType.SEARCH_INDEX,
+        DataTableErrorType.DATA_CHUNK,
+        DataTableErrorType.SERVER_FETCH,
+        DataTableErrorType.MEMORY,
+      ];
+
+      types.forEach((type) => {
+        const error = new DataTableError('Test', type);
+        expect(error.type).toBe(type);
+      });
+    });
+  });
+
+  describe('DEFAULT_FALLBACK_CONFIG', () => {
+    it('has enabled set to false', () => {
+      expect(DEFAULT_FALLBACK_CONFIG.enabled).toBe(false);
+    });
+
+    it('matches FallbackConfig interface', () => {
+      const config: FallbackConfig = DEFAULT_FALLBACK_CONFIG;
+      expect(config).toBeDefined();
+      expect(typeof config.enabled).toBe('boolean');
+    });
+  });
+
+  describe('ErrorRecoveryManager', () => {
+    it('creates instance with config', () => {
+      const config: FallbackConfig = { enabled: false };
+      const manager = new ErrorRecoveryManager(config);
+      
+      expect(manager).toBeInstanceOf(ErrorRecoveryManager);
+    });
+
+    it('handles error and returns recovery result', async () => {
+      const manager = new ErrorRecoveryManager(DEFAULT_FALLBACK_CONFIG);
+      const error = new DataTableError('Test error', DataTableErrorType.VIRTUALIZATION);
+      
+      const result = await manager.handleError(error);
+      
+      expect(result).toEqual({ recovered: false, strategy: null });
+    });
+
+    it('handles different error types', async () => {
+      const manager = new ErrorRecoveryManager(DEFAULT_FALLBACK_CONFIG);
+      
+      const types = [
+        DataTableErrorType.VIRTUALIZATION,
+        DataTableErrorType.SEARCH_INDEX,
+        DataTableErrorType.DATA_CHUNK,
+        DataTableErrorType.SERVER_FETCH,
+        DataTableErrorType.MEMORY,
+      ];
+
+      for (const type of types) {
+        const error = new DataTableError('Test', type);
+        const result = await manager.handleError(error);
+        expect(result).toEqual({ recovered: false, strategy: null });
+      }
+    });
+
+    it('clears error log without throwing', () => {
+      const manager = new ErrorRecoveryManager(DEFAULT_FALLBACK_CONFIG);
+      
+      expect(() => manager.clearErrorLog()).not.toThrow();
+    });
+  });
+
+  describe('MemoryMonitor', () => {
+    it('creates instance with threshold', () => {
+      const monitor = new MemoryMonitor(100);
+      
+      expect(monitor).toBeInstanceOf(MemoryMonitor);
+    });
+
+    it('creates instance with default threshold', () => {
+      const monitor = new MemoryMonitor();
+      
+      expect(monitor).toBeInstanceOf(MemoryMonitor);
+    });
+
+    it('returns zero for current usage', () => {
+      const monitor = new MemoryMonitor(100);
+      
+      expect(monitor.getCurrentUsage()).toBe(0);
+    });
+
+    it('returns true for threshold check', () => {
+      const monitor = new MemoryMonitor(100);
+      
+      expect(monitor.checkThreshold()).toBe(true);
+    });
+
+    it('stops monitoring without throwing', () => {
+      const monitor = new MemoryMonitor(100);
+      
+      expect(() => monitor.stopMonitoring()).not.toThrow();
+    });
+
+    it('handles multiple threshold values', () => {
+      const monitors = [50, 100, 200, 500].map((threshold) => new MemoryMonitor(threshold));
+      
+      monitors.forEach((monitor) => {
+        expect(monitor.getCurrentUsage()).toBe(0);
+        expect(monitor.checkThreshold()).toBe(true);
+      });
+    });
+  });
+
+  describe('CircuitBreaker', () => {
+    it('creates instance', () => {
+      const breaker = new CircuitBreaker();
+      
+      expect(breaker).toBeInstanceOf(CircuitBreaker);
+    });
+
+    it('returns false for isOpen()', () => {
+      const breaker = new CircuitBreaker();
+      
+      expect(breaker.isOpen()).toBe(false);
+    });
+
+    it('records success without throwing', () => {
+      const breaker = new CircuitBreaker();
+      
+      expect(() => breaker.recordSuccess()).not.toThrow();
+    });
+
+    it('records failure without throwing', () => {
+      const breaker = new CircuitBreaker();
+      
+      expect(() => breaker.recordFailure()).not.toThrow();
+    });
+
+    it('resets without throwing', () => {
+      const breaker = new CircuitBreaker();
+      
+      expect(() => breaker.reset()).not.toThrow();
+    });
+
+    it('handles multiple operations', () => {
+      const breaker = new CircuitBreaker();
+      
+      expect(breaker.isOpen()).toBe(false);
+      breaker.recordSuccess();
+      breaker.recordFailure();
+      breaker.reset();
+      expect(breaker.isOpen()).toBe(false);
+    });
+  });
+
+  describe('safeExecute', () => {
+    it('returns function result when execution succeeds', () => {
+      const result = safeExecute(() => 42, 0);
+      
+      expect(result).toBe(42);
+    });
+
+    it('returns fallback when function throws', () => {
+      const result = safeExecute(() => {
+        throw new Error('Test error');
+      }, 'fallback');
+      
+      expect(result).toBe('fallback');
+    });
+
+    it('handles different return types', () => {
+      expect(safeExecute(() => 'success', 'fallback')).toBe('success');
+      expect(safeExecute(() => 123, 0)).toBe(123);
+      expect(safeExecute(() => true, false)).toBe(true);
+      expect(safeExecute(() => ({ key: 'value' }), {})).toEqual({ key: 'value' });
+    });
+
+    it('handles different fallback types', () => {
+      expect(safeExecute(() => {
+        throw new Error('Error');
+      }, 'string-fallback')).toBe('string-fallback');
+      
+      expect(safeExecute(() => {
+        throw new Error('Error');
+      }, 999)).toBe(999);
+      
+      expect(safeExecute(() => {
+        throw new Error('Error');
+      }, false)).toBe(false);
+      
+      expect(safeExecute(() => {
+        throw new Error('Error');
+      }, { fallback: 'object' })).toEqual({ fallback: 'object' });
+    });
+
+    it('handles null and undefined', () => {
+      expect(safeExecute(() => null, 'fallback')).toBeNull();
+      expect(safeExecute(() => {
+        throw new Error('Error');
+      }, null)).toBeNull();
+      
+      expect(safeExecute(() => undefined, 'fallback')).toBeUndefined();
+    });
+  });
+});
+