@jmruthers/pace-core 0.2.7 → 0.5.1

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

@@ -1,467 +0,0 @@
-/**
- * @file Error Handling Utils Unit Tests
- * @package @jmruthers/pace-core
- * @module Components/DataTable/Utils/ErrorHandling/Tests
- * @since 0.3.0
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import {
-  DataTableError,
-  DataTableErrorType,
-  DEFAULT_FALLBACK_CONFIG,
-  VirtualizationErrorRecovery,
-  SearchIndexErrorRecovery,
-  DataChunkErrorRecovery,
-  ServerFetchErrorRecovery,
-  MemoryErrorRecovery,
-  ErrorRecoveryManager,
-  safeExecute,
-  MemoryMonitor,
-  CircuitBreaker,
-} from '../errorHandling';
-
-describe('errorHandling', () => {
-  describe('DataTableError', () => {
-    it('should create error with all properties', () => {
-      const context = { component: 'DataTable', action: 'render' };
-      const error = new DataTableError(
-        'Test error',
-        DataTableErrorType.VIRTUALIZATION_ERROR,
-        context,
-        false
-      );
-
-      expect(error.message).toBe('Test error');
-      expect(error.name).toBe('DataTableError');
-      expect(error.type).toBe(DataTableErrorType.VIRTUALIZATION_ERROR);
-      expect(error.context).toEqual(context);
-      expect(error.recoverable).toBe(false);
-      expect(error.timestamp).toBeCloseTo(Date.now(), -2);
-    });
-
-    it('should have default recoverable true', () => {
-      const error = new DataTableError(
-        'Test error',
-        DataTableErrorType.SEARCH_INDEX_ERROR
-      );
-
-      expect(error.recoverable).toBe(true);
-    });
-
-    it('should work with instanceof', () => {
-      const error = new DataTableError(
-        'Test error',
-        DataTableErrorType.MEMORY_ERROR
-      );
-
-      expect(error instanceof Error).toBe(true);
-      expect(error instanceof DataTableError).toBe(true);
-    });
-  });
-
-  describe('VirtualizationErrorRecovery', () => {
-    let recovery: VirtualizationErrorRecovery;
-
-    beforeEach(() => {
-      recovery = new VirtualizationErrorRecovery();
-    });
-
-    it('should handle recoverable virtualization errors', () => {
-      const error = new DataTableError(
-        'Virtualization failed',
-        DataTableErrorType.VIRTUALIZATION_ERROR,
-        undefined,
-        true
-      );
-
-      expect(recovery.canRecover(error)).toBe(true);
-    });
-
-    it('should not handle non-recoverable virtualization errors', () => {
-      const error = new DataTableError(
-        'Critical error',
-        DataTableErrorType.VIRTUALIZATION_ERROR,
-        undefined,
-        false
-      );
-
-      expect(recovery.canRecover(error)).toBe(false);
-    });
-
-    it('should not handle other error types', () => {
-      const error = new DataTableError(
-        'Memory error',
-        DataTableErrorType.MEMORY_ERROR
-      );
-
-      expect(recovery.canRecover(error)).toBe(false);
-    });
-
-    it('should provide fallback configuration', () => {
-      const error = new DataTableError(
-        'Test error',
-        DataTableErrorType.VIRTUALIZATION_ERROR
-      );
-
-      const result = recovery.recover(error);
-      expect(result.enableVirtualization).toBe(false);
-      expect(result.fallbackMessage).toContain('Virtual scrolling disabled');
-    });
-
-    it('should provide fallback configuration via getFallback', () => {
-      const fallback = recovery.getFallback();
-      expect(fallback.enableVirtualization).toBe(false);
-      expect(fallback.height).toBe(400);
-      expect(fallback.overscan).toBe(0);
-    });
-  });
-
-  describe('SearchIndexErrorRecovery', () => {
-    let recovery: SearchIndexErrorRecovery;
-
-    beforeEach(() => {
-      recovery = new SearchIndexErrorRecovery();
-    });
-
-    it('should handle search index errors', () => {
-      const error = new DataTableError(
-        'Index failed',
-        DataTableErrorType.SEARCH_INDEX_ERROR
-      );
-
-      expect(recovery.canRecover(error)).toBe(true);
-    });
-
-    it('should provide search fallback', () => {
-      const error = new DataTableError(
-        'Index failed',
-        DataTableErrorType.SEARCH_INDEX_ERROR
-      );
-
-      const result = recovery.recover(error);
-      expect(result.enableSearchIndex).toBe(false);
-      expect(result.fallbackMessage).toContain('Advanced search disabled');
-    });
-
-    it('should provide fallback configuration', () => {
-      const fallback = recovery.getFallback();
-      expect(fallback.enableSearchIndex).toBe(false);
-      expect(fallback.fuzzySearch).toBe(false);
-    });
-  });
-
-  describe('DataChunkErrorRecovery', () => {
-    let recovery: DataChunkErrorRecovery;
-
-    beforeEach(() => {
-      recovery = new DataChunkErrorRecovery();
-    });
-
-    it('should handle data chunk errors', () => {
-      const error = new DataTableError(
-        'Chunking failed',
-        DataTableErrorType.DATA_CHUNK_ERROR
-      );
-
-      expect(recovery.canRecover(error)).toBe(true);
-    });
-
-    it('should provide chunking fallback', () => {
-      const error = new DataTableError(
-        'Chunking failed',
-        DataTableErrorType.DATA_CHUNK_ERROR
-      );
-
-      const result = recovery.recover(error);
-      expect(result.enableChunking).toBe(false);
-      expect(result.fallbackMessage).toContain('Memory optimization disabled');
-    });
-
-    it('should provide fallback configuration', () => {
-      const fallback = recovery.getFallback();
-      expect(fallback.enableChunking).toBe(false);
-      expect(fallback.chunkSize).toBe(Number.MAX_SAFE_INTEGER);
-    });
-  });
-
-  describe('ServerFetchErrorRecovery', () => {
-    let recovery: ServerFetchErrorRecovery;
-
-    beforeEach(() => {
-      recovery = new ServerFetchErrorRecovery();
-      vi.useFakeTimers();
-    });
-
-    afterEach(() => {
-      vi.useRealTimers();
-    });
-
-    it('should handle server fetch errors within retry limit', () => {
-      const error = new DataTableError(
-        'Server error',
-        DataTableErrorType.SERVER_FETCH_ERROR
-      );
-
-      expect(recovery.canRecover(error)).toBe(true);
-    });
-
-    it('should handle server fetch errors within retry limit', () => {
-      const error = new DataTableError(
-        'Server error',
-        DataTableErrorType.SERVER_FETCH_ERROR,
-        undefined,
-        true // recoverable
-      );
-      
-      expect(recovery.canRecover(error)).toBe(true);
-    });
-
-    it('should provide fallback configuration', () => {
-      const error = new DataTableError(
-        'Server error',
-        DataTableErrorType.SERVER_FETCH_ERROR
-      );
-
-      const fallback = recovery.getFallback(error);
-      expect(fallback.paginationMode).toBe('client');
-      expect(fallback.data).toEqual([]);
-      expect(fallback.totalCount).toBe(0);
-    });
-  });
-
-  describe('MemoryErrorRecovery', () => {
-    let recovery: MemoryErrorRecovery;
-
-    beforeEach(() => {
-      recovery = new MemoryErrorRecovery();
-    });
-
-    it('should handle memory errors', () => {
-      const error = new DataTableError(
-        'Memory exceeded',
-        DataTableErrorType.MEMORY_ERROR
-      );
-
-      expect(recovery.canRecover(error)).toBe(true);
-    });
-
-    it('should provide memory optimization', () => {
-      const error = new DataTableError(
-        'Memory exceeded',
-        DataTableErrorType.MEMORY_ERROR
-      );
-
-      const result = recovery.recover(error);
-      expect(result.enableChunking).toBe(true);
-      expect(result.chunkSize).toBe(100);
-      expect(result.maxChunksInMemory).toBe(2);
-      expect(result.enableVirtualization).toBe(true);
-    });
-
-    it('should provide fallback configuration', () => {
-      const fallback = recovery.getFallback();
-      expect(fallback.paginationMode).toBe('server');
-      expect(fallback.enableChunking).toBe(true);
-      expect(fallback.chunkSize).toBe(50);
-      expect(fallback.maxChunksInMemory).toBe(1);
-    });
-  });
-
-  describe('ErrorRecoveryManager', () => {
-    let manager: ErrorRecoveryManager;
-
-    beforeEach(() => {
-      manager = new ErrorRecoveryManager();
-    });
-
-    it('should handle recoverable errors', async () => {
-      const error = new DataTableError(
-        'Virtualization failed',
-        DataTableErrorType.VIRTUALIZATION_ERROR
-      );
-
-      const result = await manager.handleError(error);
-      expect(result.enableVirtualization).toBe(false);
-    });
-
-    it('should handle non-recoverable errors', async () => {
-      const error = new DataTableError(
-        'Critical error',
-        DataTableErrorType.VIRTUALIZATION_ERROR,
-        undefined,
-        false
-      );
-
-      const result = await manager.handleError(error);
-      // Even non-recoverable errors should get a fallback configuration
-      expect(result).toBeDefined();
-      expect(result.enableVirtualization).toBe(false);
-    });
-
-    it('should log errors', async () => {
-      const error = new DataTableError(
-        'Test error',
-        DataTableErrorType.MEMORY_ERROR
-      );
-
-      await manager.handleError(error);
-      
-      const stats = manager.getErrorStats();
-      expect(stats.totalErrors).toBe(1);
-      expect(stats.errorsByType[DataTableErrorType.MEMORY_ERROR]).toBe(1);
-      expect(stats.recentErrors).toHaveLength(1);
-    });
-
-    it('should clear error log', async () => {
-      const error = new DataTableError(
-        'Test error',
-        DataTableErrorType.MEMORY_ERROR
-      );
-
-      await manager.handleError(error);
-      manager.clearErrorLog();
-      
-      const stats = manager.getErrorStats();
-      expect(stats.totalErrors).toBe(0);
-      expect(stats.recentErrors).toHaveLength(0);
-    });
-
-    it('should handle errors with context', async () => {
-      const error = new DataTableError(
-        'Test error',
-        DataTableErrorType.MEMORY_ERROR
-      );
-
-      const context = { component: 'DataTable' };
-      const result = await manager.handleError(error, context);
-      
-      expect(result).toBeDefined();
-    });
-  });
-
-  describe('safeExecute', () => {
-    let manager: ErrorRecoveryManager;
-
-    beforeEach(() => {
-      manager = new ErrorRecoveryManager();
-    });
-
-    it('should execute operation successfully', async () => {
-      const operation = vi.fn().mockResolvedValue('success');
-      
-      const result = await safeExecute(
-        operation,
-        DataTableErrorType.SEARCH_INDEX_ERROR,
-        undefined,
-        manager
-      );
-
-      expect(result).toBe('success');
-      expect(operation).toHaveBeenCalledTimes(1);
-    });
-
-    it('should handle operation errors', async () => {
-      const operation = vi.fn().mockRejectedValue(new Error('Operation failed'));
-      
-      const result = await safeExecute(
-        operation,
-        DataTableErrorType.SEARCH_INDEX_ERROR,
-        { component: 'test' },
-        manager
-      );
-
-      // Should return fallback configuration rather than null
-      expect(result).toBeDefined();
-      expect(result.enableSearchIndex).toBe(false);
-    });
-
-    it('should execute sync operations', async () => {
-      const operation = vi.fn().mockReturnValue('sync success');
-      
-      const result = await safeExecute(
-        operation,
-        DataTableErrorType.MEMORY_ERROR
-      );
-
-      expect(result).toBe('sync success');
-    });
-
-    it('should handle sync operation errors', async () => {
-      const operation = vi.fn().mockImplementation(() => {
-        throw new Error('Sync error');
-      });
-      
-      // Should throw error when no recovery manager is provided
-      await expect(
-        safeExecute(operation, DataTableErrorType.MEMORY_ERROR)
-      ).rejects.toThrow('Sync error');
-    });
-  });
-
-  describe('CircuitBreaker', () => {
-    let circuitBreaker: CircuitBreaker;
-
-    beforeEach(() => {
-      circuitBreaker = new CircuitBreaker(3, 1000); // 3 failures, 1 second timeout
-      vi.useFakeTimers();
-    });
-
-    afterEach(() => {
-      vi.useRealTimers();
-    });
-
-    it('should execute operation when circuit is closed', async () => {
-      const operation = vi.fn().mockResolvedValue('success');
-      
-      const result = await circuitBreaker.execute(operation);
-      expect(result).toBe('success');
-      expect(operation).toHaveBeenCalledTimes(1);
-    });
-
-    it('should open circuit after threshold failures', async () => {
-      const operation = vi.fn().mockRejectedValue(new Error('Failed'));
-      
-      // Reach failure threshold
-      for (let i = 0; i < 3; i++) {
-        try {
-          await circuitBreaker.execute(operation);
-        } catch (error) {
-          // Expected to fail
-        }
-      }
-
-      const state = circuitBreaker.getState();
-      expect(state.state).toBe('OPEN');
-      expect(state.failureCount).toBe(3);
-    });
-
-    it('should reject immediately when circuit is open', async () => {
-      const operation = vi.fn().mockRejectedValue(new Error('Failed'));
-      
-      // Open the circuit
-      for (let i = 0; i < 3; i++) {
-        try {
-          await circuitBreaker.execute(operation);
-        } catch (error) {
-          // Expected to fail
-        }
-      }
-
-      // Next call should be rejected immediately
-      try {
-        await circuitBreaker.execute(operation);
-        fail('Should have thrown');
-      } catch (error) {
-        expect((error as Error).message).toContain('Circuit breaker is OPEN');
-      }
-    });
-
-    it('should get current state', () => {
-      const state = circuitBreaker.getState();
-      expect(state.state).toBe('CLOSED');
-      expect(state.failureCount).toBe(0);
-      expect(state.lastFailureTime).toBe(0);
-    });
-  });
-});