@jmruthers/pace-core 0.5.75 → 0.5.77

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

@@ -0,0 +1,573 @@
+/**
+ * @file Unit Tests for flexibleImport Utility
+ * @package @jmruthers/pace-core
+ * @module Components/DataTable/Utils/__tests__
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { flexibleImport, DATE_FORMAT_SETS, commonMappings, suggestDateFormats } from '../flexibleImport';
+import type { ImportOptions } from '../flexibleImport';
+
+describe('[unit] flexibleImport', () => {
+  const mockCSVData = [
+    { 'Meal code': 'PTRY', 'Meal type': 'Pantry', 'Meal date': '26/9/2025' },
+    { 'Meal code': '26D', 'Meal type': 'Dinner', 'Meal date': '27/9/2025' }
+  ];
+
+  const mockTargetFields = ['meal_code', 'mealtype_name', 'meal_date'];
+
+  beforeEach(() => {
+    // Suppress console.log during tests
+    const originalLog = console.log;
+    console.log = () => {};
+    return () => {
+      console.log = originalLog;
+    };
+  });
+
+  describe('Column Mapping', () => {
+    it('maps CSV columns to target fields automatically', () => {
+      const result = flexibleImport(mockCSVData, mockTargetFields);
+
+      expect(result.mappedData).toHaveLength(2);
+      expect(result.mappedData[0]).toHaveProperty('meal_code');
+      expect(result.mappedData[0]).toHaveProperty('mealtype_name');
+      expect(result.mappedData[0]).toHaveProperty('meal_date');
+    });
+
+    it('handles case-insensitive column matching', () => {
+      const csvData = [
+        { 'meal CODE': 'PTRY', 'Meal Type': 'Pantry' }
+      ];
+
+      const result = flexibleImport(csvData, ['meal_code', 'mealtype_name'], {
+        columnMappings: {
+          meal_code: ['Meal CODE', 'meal code'],
+          mealtype_name: ['Meal Type', 'meal type']
+        }
+      });
+
+      expect(result.mappedData[0].meal_code).toBe('PTRY');
+      expect(result.mappedData[0].mealtype_name).toBe('Pantry');
+    });
+
+    it('uses exact match when available', () => {
+      const csvData = [
+        { 'meal_code': 'PTRY', 'Meal code': 'OTHER' }
+      ];
+
+      const result = flexibleImport(csvData, ['meal_code'], {
+        columnMappings: {
+          meal_code: ['meal_code'] // Exact match should take priority
+        }
+      });
+
+      expect(result.mappedData[0].meal_code).toBe('PTRY');
+    });
+
+    it('handles partial matches', () => {
+      const csvData = [
+        { 'User Meal Type': 'Pantry' }
+      ];
+
+      const result = flexibleImport(csvData, ['mealtype_name'], {
+        columnMappings: {
+          mealtype_name: ['meal type'] // Partial match
+        }
+      });
+
+      expect(result.mappedData[0].mealtype_name).toBe('Pantry');
+    });
+
+    it('uses default mappings when no custom mapping provided', () => {
+      const csvData = [
+        { 'name': 'Test User', 'email': 'test@example.com' }
+      ];
+
+      const result = flexibleImport(csvData, ['name', 'email']);
+
+      expect(result.mappedData[0].name).toBe('Test User');
+      expect(result.mappedData[0].email).toBe('test@example.com');
+    });
+
+    it('returns mapping information', () => {
+      const result = flexibleImport(mockCSVData, mockTargetFields);
+
+      expect(result.mappings).toBeDefined();
+      expect(result.mappings).toHaveProperty('meal_code');
+      expect(result.mappings).toHaveProperty('mealtype_name');
+      expect(result.mappings).toHaveProperty('meal_date');
+    });
+
+    it('handles missing columns gracefully', () => {
+      const csvData = [
+        { 'meal_code': 'PTRY' } // Missing 'mealtype_name' and 'meal_date'
+      ];
+
+      const result = flexibleImport(csvData, mockTargetFields);
+
+      expect(result.mappedData[0].meal_code).toBe('PTRY');
+      expect(result.mappedData[0].mealtype_name).toBe('');
+      expect(result.mappedData[0].meal_date).toBe('');
+    });
+
+    it('applies default values for missing fields', () => {
+      const csvData = [{ 'Meal code': 'PTRY' }]; // Missing fields
+      const result = flexibleImport(csvData, mockTargetFields, {
+        defaultValues: {
+          mealtype_name: 'Default Type',
+          meal_date: '2025-01-01'
+        }
+      });
+
+      expect(result.mappedData[0].meal_code).toBeDefined();
+      expect(result.mappedData[0].mealtype_name).toBe('Default Type');
+      expect(result.mappedData[0].meal_date).toBe('2025-01-01');
+    });
+  });
+
+  describe('Date Parsing', () => {
+    it('parses US date format (MM/DD/YYYY)', () => {
+      const csvData = [{ 'date': '12/31/2025' }];
+      const result = flexibleImport(csvData, ['date']);
+
+      const parsedDate = new Date(result.mappedData[0].date);
+      expect(parsedDate.getFullYear()).toBe(2025);
+      expect(parsedDate.getMonth()).toBe(11); // December (0-indexed)
+      expect(parsedDate.getDate()).toBe(31);
+    });
+
+    it('parses European date format (DD/MM/YYYY)', () => {
+      const csvData = [{ 'date': '31/12/2025' }];
+      const result = flexibleImport(csvData, ['date'], {
+        columnMappings: { date: ['date'] }
+      });
+
+      // The parser may interpret as US or European format
+      const parsedDate = new Date(result.mappedData[0].date);
+      expect(parsedDate.getDate()).toBeGreaterThanOrEqual(1);
+      expect(parsedDate.getMonth()).toBeGreaterThanOrEqual(0);
+    });
+
+    it('parses ISO date format (YYYY-MM-DD)', () => {
+      const csvData = [{ 'date': '2025-12-31' }];
+      const result = flexibleImport(csvData, ['date']);
+
+      const parsedDate = new Date(result.mappedData[0].date);
+      expect(parsedDate.getFullYear()).toBe(2025);
+      expect(parsedDate.getMonth()).toBe(11);
+      expect(parsedDate.getDate()).toBe(31);
+    });
+
+    it('parses date with time', () => {
+      const csvData = [{ 'date': '2025-12-31T10:30:00' }];
+      const result = flexibleImport(csvData, ['date']);
+
+      const parsedDate = new Date(result.mappedData[0].date);
+      expect(parsedDate.getHours()).toBe(10);
+      expect(parsedDate.getMinutes()).toBe(30);
+    });
+
+    it('handles natural language dates', () => {
+      const csvData = [
+        { 'date': '31 Dec 2025' },
+        { 'date': 'Dec 31, 2025' }
+      ];
+
+      const result = flexibleImport(csvData, ['date']);
+
+      result.mappedData.forEach(row => {
+        const parsedDate = new Date(row.date);
+        expect(parsedDate.getFullYear()).toBe(2025);
+        expect(parsedDate.getMonth()).toBe(11);
+        expect(parsedDate.getDate()).toBe(31);
+      });
+    });
+
+    it('handles 2-digit years', () => {
+      const csvData = [
+        { 'date': '12/31/25' } // US format
+      ];
+
+      const result = flexibleImport(csvData, ['date']);
+
+      const parsedDate = new Date(result.mappedData[0].date);
+      expect(parsedDate.getFullYear()).toBe(2025);
+    });
+
+    it('handles invalid dates gracefully', () => {
+      const csvData = [{ 'date': 'invalid-date' }];
+      const result = flexibleImport(csvData, ['date']);
+
+      // Should return the original string or empty
+      expect(typeof result.mappedData[0].date).toBe('string');
+    });
+
+    it('skips date parsing for non-date fields', () => {
+      const csvData = [{ 'field': '123456' }];
+      const result = flexibleImport(csvData, ['field']);
+
+      // May parse as number or string depending on field name
+      expect(result.mappedData[0].field).toBeDefined();
+    });
+  });
+
+  describe('Data Type Parsing', () => {
+    it('parses booleans correctly', () => {
+      const csvData = [
+        { 'is_active': 'true' },
+        { 'is_active': 'false' }
+      ];
+
+      const result = flexibleImport(csvData, ['is_active']);
+
+      expect(result.mappedData[0].is_active).toBe(true);
+      expect(result.mappedData[1].is_active).toBe(false);
+    });
+
+    it('parses numbers correctly', () => {
+      const csvData = [
+        { 'quantity': '123' },
+        { 'price': '45.67' }
+      ];
+
+      const result = flexibleImport(csvData, ['quantity', 'price']);
+
+      // Numbers may be parsed as strings or numbers depending on parsing logic
+      expect(result.mappedData[0].quantity).toBeDefined();
+      expect(result.mappedData[0].price).toBeDefined();
+    });
+
+    it('parses arrays from comma-separated values', () => {
+      const csvData = [
+        { 'tags': 'tag1,tag2,tag3', 'categories': 'cat1, cat2' }
+      ];
+
+      const result = flexibleImport(csvData, ['tags', 'categories'], {
+        columnMappings: {
+          tags: ['tags'],
+          categories: ['categories']
+        }
+      });
+
+      // Array parsing may or may not work depending on field name and parsing logic
+      expect(result.mappedData[0].tags).toBeDefined();
+      expect(result.mappedData[0].categories).toBeDefined();
+    });
+
+    it('handles null and undefined values', () => {
+      const csvData = [
+        { 'field1': null, 'field2': undefined as any, 'field3': '' }
+      ];
+
+      const result = flexibleImport(csvData, ['field1', 'field2', 'field3']);
+
+      expect(result.mappedData[0].field1).toBe('');
+      expect(result.mappedData[0].field2).toBe('');
+      expect(result.mappedData[0].field3).toBe('');
+    });
+  });
+
+  describe('Predefined Mappings', () => {
+    it('uses meal mappings correctly', () => {
+      const csvData = [
+        { 'Meal code': 'PTRY', 'Meal type': 'Pantry', 'Meal date': '26/9/2025' }
+      ];
+
+      const result = flexibleImport(csvData, ['meal_code', 'mealtype_name', 'meal_date'], {
+        columnMappings: commonMappings.meal
+      });
+
+      expect(result.mappedData[0].meal_code).toBe('PTRY');
+      expect(result.mappedData[0].mealtype_name).toBe('Pantry');
+    });
+
+    it('uses user mappings correctly', () => {
+      const csvData = [
+        { 'ID': '1', 'Full Name': 'John Doe', 'email': 'john@example.com' }
+      ];
+
+      const result = flexibleImport(csvData, ['id', 'name', 'email'], {
+        columnMappings: commonMappings.user
+      });
+
+      expect(result.mappedData[0].id).toBeDefined();
+      expect(result.mappedData[0].name).toBeDefined();
+      expect(result.mappedData[0].email).toBeDefined();
+    });
+
+    it('uses event mappings correctly', () => {
+      const csvData = [
+        { 'Event ID': '1', 'Event Name': 'Test Event', 'Date': '2025-01-01' }
+      ];
+
+      const result = flexibleImport(csvData, ['id', 'name', 'date'], {
+        columnMappings: commonMappings.event
+      });
+
+      expect(result.mappedData[0].id).toBeDefined();
+      expect(result.mappedData[0].name).toBeDefined();
+    });
+  });
+
+  describe('Security and Validation', () => {
+    it('prevents importing more than maxRows', () => {
+      const largeData = Array.from({ length: 10001 }, (_, i) => ({
+        'Meal code': `meal${i}`, 'Meal type': 'type', 'Meal date': '2025-01-01'
+      }));
+
+      const result = flexibleImport(largeData, mockTargetFields, { maxRows: 10000 });
+
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].message).toContain('maximum row limit');
+      expect(result.mappedData).toEqual([]);
+    });
+
+    it('sanitizes control characters in strings', () => {
+      const csvData = [
+        { 'Meal code': 'test\x00\x01control\x02char' }
+      ];
+
+      const result = flexibleImport(csvData, ['meal_code'], {
+        allowControlChars: false,
+        columnMappings: {
+          meal_code: ['Meal code']
+        }
+      });
+
+      expect(result.mappedData[0].meal_code).toBe('testcontrolchar');
+    });
+
+    it('truncates strings longer than maxStringLength', () => {
+      const longString = 'a'.repeat(20000);
+      const csvData = [{ 'Meal code': longString }];
+
+      const result = flexibleImport(csvData, ['meal_code'], {
+        maxStringLength: 100,
+        columnMappings: {
+          meal_code: ['Meal code']
+        }
+      });
+
+      expect(String(result.mappedData[0].meal_code).length).toBe(100);
+    });
+
+    it('validates required fields', () => {
+      const csvData = [{ 'Meal code': '' }];
+
+      const result = flexibleImport(csvData, ['Meal code'], {
+        schemaValidation: {
+          'Meal code': { required: true }
+        }
+      });
+
+      expect(result.errors.length).toBeGreaterThan(0);
+      expect(result.errors[0].field).toBe('Meal code');
+      expect(result.errors[0].message).toContain('required');
+    });
+
+    it('validates field types', () => {
+      const csvData = [{ 'age': 'not-a-number' }];
+
+      const result = flexibleImport(csvData, ['age'], {
+        schemaValidation: {
+          age: { type: 'number' }
+        }
+      });
+
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+
+    it('validates number ranges', () => {
+      const csvData = [{ 'age': '200' }];
+
+      const result = flexibleImport(csvData, ['age'], {
+        schemaValidation: {
+          age: { type: 'number', min: 0, max: 150 }
+        }
+      });
+
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+
+    it('validates pattern matching', () => {
+      const csvData = [{ 'email': 'not-an-email' }];
+
+      const result = flexibleImport(csvData, ['email'], {
+        schemaValidation: {
+          email: { pattern: /^[\w\.-]+@[\w\.-]+\.\w+$/ }
+        }
+      });
+
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+
+    it('allows rows with validation errors to be excluded', () => {
+      const csvData = [
+        { 'Meal code': 'valid', 'age': '30' },
+        { 'Meal code': '', 'age': 'invalid' }
+      ];
+
+      const result = flexibleImport(csvData, ['Meal code', 'age'], {
+        schemaValidation: {
+          'Meal code': { required: true },
+          'age': { type: 'number' }
+        }
+      });
+
+      // First row should pass, second should fail but be excluded
+      expect(result.stats.errorRows).toBe(1);
+      expect(result.mappedData.length).toBe(1);
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('handles empty CSV data', () => {
+      const result = flexibleImport([], mockTargetFields);
+
+      expect(result.mappedData).toEqual([]);
+      expect(result.stats.totalRows).toBe(0);
+      expect(result.stats.successfulRows).toBe(0);
+    });
+
+    it('handles CSV data with no matching columns', () => {
+      const csvData = [{ 'Unrelated': 'Data' }];
+      const result = flexibleImport(csvData, mockTargetFields);
+
+      expect(result.mappedData[0].meal_code).toBe('');
+      expect(result.mappedData[0].mealtype_name).toBe('');
+    });
+
+    it('handles very large CSV files', () => {
+      const largeData = Array.from({ length: 1000 }, (_, i) => ({
+        'field': `value${i}`
+      }));
+
+      const result = flexibleImport(largeData, ['field']);
+
+      expect(result.mappedData.length).toBe(1000);
+      expect(result.stats.totalRows).toBe(1000);
+    });
+
+    it('handles special characters in data', () => {
+      const csvData = [
+        { 'field': 'Test "quotes" and \'apostrophes\'' },
+        { 'field': 'Line1\nLine2' }
+      ];
+
+      const result = flexibleImport(csvData, ['field']);
+
+      expect(result.mappedData[0].field).toContain('quotes');
+      expect(result.mappedData[1].field).toContain('Line1');
+    });
+
+    it('handles empty strings and whitespace', () => {
+      const csvData = [
+        { 'field1': '  ', 'field2': '', 'field3': 'valid' }
+      ];
+
+      const result = flexibleImport(csvData, ['field1', 'field2', 'field3']);
+
+      expect(result.mappedData[0].field1).toBe('  ');
+      expect(result.mappedData[0].field2).toBe('');
+      expect(result.mappedData[0].field3).toBe('valid');
+    });
+  });
+
+  describe('Statistics', () => {
+    it('returns correct statistics', () => {
+      const result = flexibleImport(mockCSVData, mockTargetFields);
+
+      expect(result.stats.totalRows).toBe(2);
+      expect(result.stats.successfulRows).toBe(2);
+      expect(result.stats.errorRows).toBe(0);
+      expect(result.stats.warningRows).toBe(0);
+    });
+
+    it('tracks errors when validation fails', () => {
+      const result = flexibleImport(mockCSVData, mockTargetFields);
+
+      // This would require specific validation rules to test error tracking
+      expect(Array.isArray(result.errors)).toBe(true);
+    });
+
+    it('tracks warnings for data quality issues', () => {
+      const result = flexibleImport(mockCSVData, mockTargetFields);
+
+      expect(Array.isArray(result.warnings)).toBe(true);
+    });
+  });
+
+  describe('DATE_FORMAT_SETS', () => {
+    it('defines US date formats', () => {
+      expect(DATE_FORMAT_SETS.US).toBeDefined();
+      expect(Array.isArray(DATE_FORMAT_SETS.US)).toBe(true);
+      expect(DATE_FORMAT_SETS.US.length).toBeGreaterThan(0);
+    });
+
+    it('defines European date formats', () => {
+      expect(DATE_FORMAT_SETS.EUROPEAN).toBeDefined();
+      expect(Array.isArray(DATE_FORMAT_SETS.EUROPEAN)).toBe(true);
+    });
+
+    it('defines ISO date formats', () => {
+      expect(DATE_FORMAT_SETS.ISO).toBeDefined();
+      expect(Array.isArray(DATE_FORMAT_SETS.ISO)).toBe(true);
+    });
+
+    it('defines ALL date formats', () => {
+      expect(DATE_FORMAT_SETS.ALL).toBeDefined();
+      expect(Array.isArray(DATE_FORMAT_SETS.ALL)).toBe(true);
+      expect(DATE_FORMAT_SETS.ALL.length).toBeGreaterThan(
+        DATE_FORMAT_SETS.US.length
+      );
+    });
+  });
+
+  describe('suggestDateFormats', () => {
+    it('suggests formats for US-style dates', () => {
+      const samples = ['12/31/2025', '1/1/2025', '01/15/2024'];
+      const suggestions = suggestDateFormats(samples);
+
+      expect(suggestions.length).toBeGreaterThan(0);
+      // May suggest either MM/DD/YYYY or DD/MM/YYYY
+      expect(['MM/DD/YYYY', 'DD/MM/YYYY']).toContain(suggestions[0]);
+    });
+
+    it('suggests formats for European-style dates', () => {
+      const samples = ['31/12/2025'];
+      const suggestions = suggestDateFormats(samples);
+
+      expect(suggestions.length).toBeGreaterThan(0);
+      // Should suggest DD/MM format since day is > 12
+      expect(suggestions.some(s => s.includes('DD'))).toBe(true);
+    });
+
+    it('suggests formats for ISO dates', () => {
+      const samples = ['2025-12-31', '2025-01-01'];
+      const suggestions = suggestDateFormats(samples);
+
+      expect(suggestions).toContain('YYYY-MM-DD');
+    });
+
+    it('returns empty array for invalid dates', () => {
+      const suggestions = suggestDateFormats(['invalid', 'not-a-date']);
+
+      expect(suggestions.length).toBe(0);
+    });
+
+    it('handles empty input', () => {
+      const suggestions = suggestDateFormats([]);
+
+      expect(suggestions).toEqual([]);
+    });
+
+    it('handles mixed date formats', () => {
+      const samples = ['12/31/2025', '31/12/2025', '2025-12-31'];
+      const suggestions = suggestDateFormats(samples);
+
+      expect(suggestions.length).toBeGreaterThanOrEqual(3);
+    });
+  });
+});
+