@jmruthers/pace-core 0.6.8 → 0.6.10

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

@@ -0,0 +1,288 @@
+/**
+ * @file Unit Tests for Aggregation Utilities
+ * @package @jmruthers/pace-core
+ * @module Components/DataTable/Utils/__tests__
+ */
+
+import { describe, it, expect } from 'vitest';
+import { sum, average, count, min, max } from '../aggregationUtils';
+import type { DataTableColumn, DataRecord } from '../../types';
+
+interface TestRow extends DataRecord {
+  cost: number;
+  quantity: number;
+  price: number;
+  name: string;
+}
+
+describe('[unit] aggregationUtils', () => {
+  const createMockColumn = (): DataTableColumn<TestRow> => ({
+    id: 'test-column',
+    accessorKey: 'cost',
+  } as DataTableColumn<TestRow>);
+
+  describe('sum', () => {
+    it('sums numeric values correctly', () => {
+      const rows: TestRow[] = [
+        { id: '1', cost: 10, quantity: 2, price: 5, name: 'Item 1' },
+        { id: '2', cost: 20, quantity: 3, price: 7, name: 'Item 2' },
+        { id: '3', cost: 30, quantity: 1, price: 10, name: 'Item 3' },
+      ];
+      const column = createMockColumn();
+      const aggregateFn = sum<TestRow>('cost');
+
+      const result = aggregateFn(rows, column);
+
+      expect(result).toBe(60);
+    });
+
+    it('handles string numbers by converting to numeric', () => {
+      const rows: TestRow[] = [
+        { id: '1', cost: '10' as any, quantity: 2, price: 5, name: 'Item 1' },
+        { id: '2', cost: '20' as any, quantity: 3, price: 7, name: 'Item 2' },
+      ];
+      const column = createMockColumn();
+      const aggregateFn = sum<TestRow>('cost');
+
+      const result = aggregateFn(rows, column);
+
+      expect(result).toBe(30);
+    });
+
+    it('handles null and undefined values as zero', () => {
+      const rows: TestRow[] = [
+        { id: '1', cost: 10, quantity: 2, price: 5, name: 'Item 1' },
+        { id: '2', cost: null as any, quantity: 3, price: 7, name: 'Item 2' },
+        { id: '3', cost: undefined as any, quantity: 1, price: 10, name: 'Item 3' },
+      ];
+      const column = createMockColumn();
+      const aggregateFn = sum<TestRow>('cost');
+
+      const result = aggregateFn(rows, column);
+
+      expect(result).toBe(10);
+    });
+
+    it('handles invalid numeric strings as zero', () => {
+      const rows: TestRow[] = [
+        { id: '1', cost: 10, quantity: 2, price: 5, name: 'Item 1' },
+        { id: '2', cost: 'invalid' as any, quantity: 3, price: 7, name: 'Item 2' },
+      ];
+      const column = createMockColumn();
+      const aggregateFn = sum<TestRow>('cost');
+
+      const result = aggregateFn(rows, column);
+
+      expect(result).toBe(10);
+    });
+
+    it('returns zero for empty array', () => {
+      const rows: TestRow[] = [];
+      const column = createMockColumn();
+      const aggregateFn = sum<TestRow>('cost');
+
+      const result = aggregateFn(rows, column);
+
+      expect(result).toBe(0);
+    });
+  });
+
+  describe('average', () => {
+    it('calculates average of numeric values correctly', () => {
+      const rows: TestRow[] = [
+        { id: '1', cost: 10, quantity: 2, price: 5, name: 'Item 1' },
+        { id: '2', cost: 20, quantity: 3, price: 7, name: 'Item 2' },
+        { id: '3', cost: 30, quantity: 1, price: 10, name: 'Item 3' },
+      ];
+      const column = createMockColumn();
+      const aggregateFn = average<TestRow>('cost');
+
+      const result = aggregateFn(rows, column);
+
+      expect(result).toBe(20);
+    });
+
+    it('excludes null and undefined values from calculation', () => {
+      const rows: TestRow[] = [
+        { id: '1', cost: 10, quantity: 2, price: 5, name: 'Item 1' },
+        { id: '2', cost: null as any, quantity: 3, price: 7, name: 'Item 2' },
+        { id: '3', cost: 30, quantity: 1, price: 10, name: 'Item 3' },
+      ];
+      const column = createMockColumn();
+      const aggregateFn = average<TestRow>('cost');
+
+      const result = aggregateFn(rows, column);
+
+      expect(result).toBe(20); // (10 + 30) / 2
+    });
+
+    it('excludes empty strings from calculation', () => {
+      const rows: TestRow[] = [
+        { id: '1', cost: 10, quantity: 2, price: 5, name: 'Item 1' },
+        { id: '2', cost: '' as any, quantity: 3, price: 7, name: 'Item 2' },
+        { id: '3', cost: 30, quantity: 1, price: 10, name: 'Item 3' },
+      ];
+      const column = createMockColumn();
+      const aggregateFn = average<TestRow>('cost');
+
+      const result = aggregateFn(rows, column);
+
+      expect(result).toBe(20);
+    });
+
+    it('returns zero for empty array', () => {
+      const rows: TestRow[] = [];
+      const column = createMockColumn();
+      const aggregateFn = average<TestRow>('cost');
+
+      const result = aggregateFn(rows, column);
+
+      expect(result).toBe(0);
+    });
+
+    it('returns zero when all values are invalid', () => {
+      const rows: TestRow[] = [
+        { id: '1', cost: null as any, quantity: 2, price: 5, name: 'Item 1' },
+        { id: '2', cost: '' as any, quantity: 3, price: 7, name: 'Item 2' },
+      ];
+      const column = createMockColumn();
+      const aggregateFn = average<TestRow>('cost');
+
+      const result = aggregateFn(rows, column);
+
+      expect(result).toBe(0);
+    });
+  });
+
+  describe('count', () => {
+    it('returns number of rows', () => {
+      const rows: TestRow[] = [
+        { id: '1', cost: 10, quantity: 2, price: 5, name: 'Item 1' },
+        { id: '2', cost: 20, quantity: 3, price: 7, name: 'Item 2' },
+        { id: '3', cost: 30, quantity: 1, price: 10, name: 'Item 3' },
+      ];
+      const column = createMockColumn();
+      const aggregateFn = count<TestRow>();
+
+      const result = aggregateFn(rows, column);
+
+      expect(result).toBe(3);
+    });
+
+    it('returns zero for empty array', () => {
+      const rows: TestRow[] = [];
+      const column = createMockColumn();
+      const aggregateFn = count<TestRow>();
+
+      const result = aggregateFn(rows, column);
+
+      expect(result).toBe(0);
+    });
+  });
+
+  describe('min', () => {
+    it('finds minimum numeric value', () => {
+      const rows: TestRow[] = [
+        { id: '1', cost: 10, quantity: 2, price: 5, name: 'Item 1' },
+        { id: '2', cost: 20, quantity: 3, price: 7, name: 'Item 2' },
+        { id: '3', cost: 5, quantity: 1, price: 10, name: 'Item 3' },
+      ];
+      const column = createMockColumn();
+      const aggregateFn = min<TestRow>('cost');
+
+      const result = aggregateFn(rows, column);
+
+      expect(result).toBe(5);
+    });
+
+    it('excludes null and undefined values', () => {
+      const rows: TestRow[] = [
+        { id: '1', cost: 10, quantity: 2, price: 5, name: 'Item 1' },
+        { id: '2', cost: null as any, quantity: 3, price: 7, name: 'Item 2' },
+        { id: '3', cost: 5, quantity: 1, price: 10, name: 'Item 3' },
+      ];
+      const column = createMockColumn();
+      const aggregateFn = min<TestRow>('cost');
+
+      const result = aggregateFn(rows, column);
+
+      expect(result).toBe(5);
+    });
+
+    it('returns null for empty array', () => {
+      const rows: TestRow[] = [];
+      const column = createMockColumn();
+      const aggregateFn = min<TestRow>('cost');
+
+      const result = aggregateFn(rows, column);
+
+      expect(result).toBeNull();
+    });
+
+    it('returns null when all values are invalid', () => {
+      const rows: TestRow[] = [
+        { id: '1', cost: null as any, quantity: 2, price: 5, name: 'Item 1' },
+        { id: '2', cost: '' as any, quantity: 3, price: 7, name: 'Item 2' },
+      ];
+      const column = createMockColumn();
+      const aggregateFn = min<TestRow>('cost');
+
+      const result = aggregateFn(rows, column);
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('max', () => {
+    it('finds maximum numeric value', () => {
+      const rows: TestRow[] = [
+        { id: '1', cost: 10, quantity: 2, price: 5, name: 'Item 1' },
+        { id: '2', cost: 30, quantity: 3, price: 7, name: 'Item 2' },
+        { id: '3', cost: 5, quantity: 1, price: 10, name: 'Item 3' },
+      ];
+      const column = createMockColumn();
+      const aggregateFn = max<TestRow>('cost');
+
+      const result = aggregateFn(rows, column);
+
+      expect(result).toBe(30);
+    });
+
+    it('excludes null and undefined values', () => {
+      const rows: TestRow[] = [
+        { id: '1', cost: 10, quantity: 2, price: 5, name: 'Item 1' },
+        { id: '2', cost: null as any, quantity: 3, price: 7, name: 'Item 2' },
+        { id: '3', cost: 30, quantity: 1, price: 10, name: 'Item 3' },
+      ];
+      const column = createMockColumn();
+      const aggregateFn = max<TestRow>('cost');
+
+      const result = aggregateFn(rows, column);
+
+      expect(result).toBe(30);
+    });
+
+    it('returns null for empty array', () => {
+      const rows: TestRow[] = [];
+      const column = createMockColumn();
+      const aggregateFn = max<TestRow>('cost');
+
+      const result = aggregateFn(rows, column);
+
+      expect(result).toBeNull();
+    });
+
+    it('returns null when all values are invalid', () => {
+      const rows: TestRow[] = [
+        { id: '1', cost: null as any, quantity: 2, price: 5, name: 'Item 1' },
+        { id: '2', cost: '' as any, quantity: 3, price: 7, name: 'Item 2' },
+      ];
+      const column = createMockColumn();
+      const aggregateFn = max<TestRow>('cost');
+
+      const result = aggregateFn(rows, column);
+
+      expect(result).toBeNull();
+    });
+  });
+});

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

@@ -60,20 +60,6 @@ describe('[unit] errorHandling', () => {
       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', () => {
@@ -105,23 +91,6 @@ describe('[unit] errorHandling', () => {
       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);
@@ -161,14 +130,6 @@ describe('[unit] errorHandling', () => {
       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', () => {
@@ -202,15 +163,6 @@ describe('[unit] errorHandling', () => {
       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', () => {
@@ -228,14 +180,13 @@ describe('[unit] errorHandling', () => {
       expect(result).toBe('fallback');
     });
 
-    it('handles different return types', () => {
+    it('handles different return and fallback 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', () => {
+      
+      // Test fallbacks
       expect(safeExecute(() => {
         throw new Error('Error');
       }, 'string-fallback')).toBe('string-fallback');
@@ -243,14 +194,6 @@ describe('[unit] errorHandling', () => {
       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', () => {

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

@@ -6,7 +6,7 @@
 
 import { describe, it, expect, beforeEach } from 'vitest';
 import { flexibleImport, DATE_FORMAT_SETS, commonMappings, suggestDateFormats } from '../flexibleImport';
-import type { ImportOptions } from '../flexibleImport';
+// ImportOptions removed - not used in tests
 
 describe('[unit] flexibleImport', () => {
   const mockCSVData = [

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

@@ -36,21 +36,13 @@ describe('[unit] hierarchicalSorting', () => {
       const sorted = sortHierarchicalDataByStructure(data);
 
       // First 3 rows should be parents
-      expect(sorted[0].id).toBe('1');
-      expect(sorted[1].id).toBe('2');
-      expect(sorted[2].id).toBe('3');
       expect(sorted[0].isParent).toBe(true);
       expect(sorted[1].isParent).toBe(true);
       expect(sorted[2].isParent).toBe(true);
-    });
-
-    it('includes all children after parents', () => {
-      const data = createMockData();
-      const sorted = sortHierarchicalDataByStructure(data);
-
+      
+      // All children come after parents
       const parentCount = sorted.filter(r => r.isParent).length;
       expect(parentCount).toBe(3);
-      
       const childCount = sorted.filter(r => !r.isParent).length;
       expect(childCount).toBe(3);
     });
@@ -180,10 +172,14 @@ describe('[unit] hierarchicalSorting', () => {
       const data = createMockData();
       const sorting: SortingState = [{ id: 'nonExistent', desc: false }];
       
-      // Should not crash
+      // Should not crash and maintain all rows
       const sorted = sortHierarchicalDataWithSorting(data, sorting);
       
       expect(sorted.length).toBe(data.length);
+      // Parent-child relationships should be preserved
+      const parent1Index = sorted.findIndex(r => r.id === '1');
+      const child1Index = sorted.findIndex(r => r.id === '1-1');
+      expect(child1Index).toBeGreaterThan(parent1Index);
     });
 
     it('handles date sorting', () => {
@@ -222,26 +218,18 @@ describe('[unit] hierarchicalSorting', () => {
   });
 
   describe('getHierarchicalSortConfig', () => {
-    it('returns original sorting state', () => {
+    it('returns original sorting state unchanged', () => {
       const sorting: SortingState = [{ id: 'name', desc: false }];
       const config = getHierarchicalSortConfig(sorting, []);
       
       expect(config).toEqual(sorting);
     });
 
-    it('returns empty array when no sorting', () => {
+    it('returns empty array when no sorting provided', () => {
       const config = getHierarchicalSortConfig([], []);
       
       expect(config).toEqual([]);
     });
-
-    it('preserves sorting configuration', () => {
-      const sorting: SortingState = [{ id: 'value', desc: true }];
-      const config = getHierarchicalSortConfig(sorting, []);
-      
-      expect(config[0].id).toBe('value');
-      expect(config[0].desc).toBe(true);
-    });
   });
 });