@jmruthers/pace-core 0.5.4 → 0.5.5

package/src/utils/__tests__/index.unit.test.ts

@@ -0,0 +1,251 @@
+import { describe, it, expect } from 'vitest';
+import * as Utils from '../index';
+
+describe('utils index exports', () => {
+  describe('Core utilities', () => {
+    it('should export cn function', () => {
+      expect(Utils).toHaveProperty('cn');
+      expect(typeof Utils.cn).toBe('function');
+    });
+  });
+
+  describe('Validation and sanitization', () => {
+    it('should export validation utilities', () => {
+      // These should be available from the validation module
+      expect(Utils).toHaveProperty('validateUserInput');
+      expect(Utils).toHaveProperty('emailSchema');
+      expect(Utils).toHaveProperty('passwordSchema');
+      expect(Utils).toHaveProperty('usernameSchema');
+      expect(Utils).toHaveProperty('nameSchema');
+      expect(Utils).toHaveProperty('phoneSchema');
+      expect(Utils).toHaveProperty('urlSchema');
+    });
+
+    it('should export sanitization utilities', () => {
+      // These should be available from the sanitization module
+      expect(Utils).toHaveProperty('sanitizeUserInput');
+      expect(Utils).toHaveProperty('sanitizeFormData');
+    });
+  });
+
+  describe('Security utilities', () => {
+    it('should export security functions', () => {
+      expect(Utils).toHaveProperty('getSecurityHeaders');
+      expect(Utils).toHaveProperty('validateSecurityHeaders');
+      expect(Utils).toHaveProperty('generateDeviceFingerprint');
+      expect(Utils).toHaveProperty('validateDeviceFingerprint');
+      expect(Utils).toHaveProperty('logSecurityEvent');
+    });
+  });
+
+  describe('Accessibility testing utilities', () => {
+    it('should not export accessibility helpers in production builds', () => {
+      // Accessibility helpers are only available in test environments
+      // They are not exported in production builds to avoid including test dependencies
+      expect(Utils).not.toHaveProperty('a11yHelpers');
+      expect(Utils).not.toHaveProperty('runAccessibilityTests');
+      expect(Utils).not.toHaveProperty('screenReaderHelpers');
+    });
+  });
+
+  describe('Performance utilities', () => {
+    it('should export performance monitoring functions', () => {
+      expect(Utils).toHaveProperty('useComponentPerformance');
+      expect(Utils).toHaveProperty('measureRenderPerformance');
+      expect(Utils).toHaveProperty('createPerformanceBenchmark');
+      expect(Utils).toHaveProperty('PERFORMANCE_THRESHOLDS');
+      // PerformanceMetrics is a type, not a runtime export
+    });
+  });
+
+  describe('Bundle analysis utilities', () => {
+    it('should export bundle analysis functions', () => {
+      expect(Utils).toHaveProperty('bundleAnalyzer');
+      expect(Utils).toHaveProperty('validateImportPattern');
+      expect(Utils).toHaveProperty('trackDynamicImport');
+    });
+  });
+
+  describe('Dynamic utility loaders', () => {
+    it('should export dynamic loading functions', () => {
+      expect(Utils).toHaveProperty('loadLodash');
+      expect(Utils).toHaveProperty('loadDateUtils');
+      expect(Utils).toHaveProperty('loadChartUtils');
+      expect(Utils).toHaveProperty('loadFormUtils');
+      expect(Utils).toHaveProperty('loadCSVUtils');
+      expect(Utils).toHaveProperty('createLazyUtility');
+      expect(Utils).toHaveProperty('lazyLodash');
+      expect(Utils).toHaveProperty('lazyDateUtils');
+      expect(Utils).toHaveProperty('lazyChartUtils');
+      expect(Utils).toHaveProperty('lazyFormUtils');
+      expect(Utils).toHaveProperty('lazyCSVUtils');
+    });
+  });
+
+  describe('Performance budget utilities', () => {
+    it('should export performance budget monitor', () => {
+      expect(Utils).toHaveProperty('performanceBudgetMonitor');
+    });
+  });
+
+  describe('Lazy loading utilities', () => {
+    it('should export lazy loading functions', () => {
+      expect(Utils).toHaveProperty('createLazyComponent');
+      expect(Utils).toHaveProperty('LazyDataTable');
+    });
+  });
+
+  describe('App configuration utilities', () => {
+    it('should export app config functions', () => {
+      expect(Utils).toHaveProperty('setAppConfig');
+      expect(Utils).toHaveProperty('getAppConfig');
+      expect(Utils).toHaveProperty('getCurrentAppName');
+      expect(Utils).toHaveProperty('getCurrentAppId');
+    });
+  });
+
+  describe('Permission utilities', () => {
+    it('should export permission functions', () => {
+      expect(Utils).toHaveProperty('transformPermissionMapToBoolean');
+      expect(Utils).toHaveProperty('hasPermission');
+      expect(Utils).toHaveProperty('hasAnyPermission');
+      expect(Utils).toHaveProperty('hasAllPermissions');
+      expect(Utils).toHaveProperty('PermissionType');
+      expect(Utils).toHaveProperty('parsePermission');
+    });
+  });
+
+  describe('Schema utilities', () => {
+    it('should export schema functions', () => {
+      expect(Utils).toHaveProperty('pickSchema');
+      expect(Utils).toHaveProperty('combineSchemas');
+    });
+  });
+
+  describe('Security monitoring utilities', () => {
+    it('should export security monitoring functions', () => {
+      expect(Utils).toHaveProperty('securityMonitor');
+      expect(Utils).toHaveProperty('logSecurityEvent');
+    });
+  });
+
+  describe('Session tracking utilities', () => {
+    it('should export session tracking functions', () => {
+      expect(Utils).toHaveProperty('useSessionTracking');
+    });
+  });
+
+  describe('Audit utilities', () => {
+    it('should export audit functions', () => {
+      expect(Utils).toHaveProperty('auditLog');
+      expect(Utils).toHaveProperty('logAuditEvent');
+    });
+  });
+
+  describe('Device fingerprinting utilities', () => {
+    it('should export device fingerprinting functions', () => {
+      expect(Utils).toHaveProperty('generateDeviceFingerprint');
+      expect(Utils).toHaveProperty('validateDeviceFingerprint');
+    });
+  });
+
+
+  describe('Formatting utilities', () => {
+    it('should export formatting functions', () => {
+      expect(Utils).toHaveProperty('formatDate');
+      expect(Utils).toHaveProperty('formatCurrency');
+      expect(Utils).toHaveProperty('formatNumber');
+    });
+  });
+
+  describe('Organisation context utilities', () => {
+    it('should export organisation context functions', () => {
+      expect(Utils).toHaveProperty('setOrganisationContext');
+      expect(Utils).toHaveProperty('clearOrganisationContext');
+      expect(Utils).toHaveProperty('getOrganisationContext');
+      expect(Utils).toHaveProperty('isOrganisationContextAvailable');
+    });
+  });
+
+  describe('Integration tests', () => {
+    it('should allow importing specific utilities', () => {
+      // Test that we can import specific utilities
+      const { cn, validateUserInput, emailSchema } = Utils;
+      
+      expect(typeof cn).toBe('function');
+      expect(typeof validateUserInput).toBe('function');
+      expect(emailSchema).toBeDefined();
+    });
+
+    it('should allow importing utility groups', () => {
+      // Test that we can import groups of related utilities
+      const {
+        // Security
+        getSecurityHeaders,
+        generateDeviceFingerprint,
+        // Validation
+        emailSchema,
+        passwordSchema,
+        // Performance
+        useComponentPerformance,
+        // Permissions
+        hasPermission,
+        hasAnyPermission,
+        // Schema
+        pickSchema,
+        combineSchemas
+      } = Utils;
+
+      expect(typeof getSecurityHeaders).toBe('function');
+      expect(typeof generateDeviceFingerprint).toBe('function');
+      expect(emailSchema).toBeDefined();
+      expect(passwordSchema).toBeDefined();
+      expect(typeof useComponentPerformance).toBe('function');
+      expect(typeof hasPermission).toBe('function');
+      expect(typeof hasAnyPermission).toBe('function');
+      expect(typeof pickSchema).toBe('function');
+      expect(typeof combineSchemas).toBe('function');
+    });
+
+    it('should maintain function signatures', () => {
+      // Test that exported functions have the expected signatures
+      const { cn, validateUserInput, hasPermission } = Utils;
+
+      // cn should accept class names
+      expect(() => cn('class1', 'class2')).not.toThrow();
+      
+      // validateUserInput should accept schema and data
+      expect(typeof validateUserInput).toBe('function');
+      
+      // hasPermission should accept permissions and permission string
+      expect(typeof hasPermission).toBe('function');
+    });
+
+    it('should export all required utilities for a complete application', () => {
+      // Test that all major utility categories are exported
+      const categories = [
+        'cn', // Core utilities
+        'validateUserInput', // Validation
+        'sanitizeUserInput', // Sanitization
+        'getSecurityHeaders', // Security
+        'useComponentPerformance', // Performance
+        'bundleAnalyzer', // Bundle analysis
+        'loadLodash', // Dynamic loading
+        'performanceBudgetMonitor', // Performance budgets
+        'setAppConfig', // App config
+        'hasPermission', // Permissions
+        'pickSchema', // Schema utilities
+        'securityMonitor', // Security monitoring
+        'useSessionTracking', // Session tracking
+        'auditLog', // Audit
+        'generateDeviceFingerprint', // Device fingerprinting
+        'formatDate', // Formatting
+        'setOrganisationContext' // Organisation context
+      ];
+
+      categories.forEach(utility => {
+        expect(Utils).toHaveProperty(utility);
+      });
+    });
+  });
+}); 

package/src/utils/__tests__/lazyLoad.unit.test.tsx

@@ -0,0 +1,309 @@
+/**
+ * @file LazyLoad Utility Unit Tests
+ * @package @jmruthers/pace-core
+ * @module Utils/LazyLoad
+ * @since 0.4.0
+ */
+
+import React from 'react';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { screen, waitFor } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import { createLazyComponent, LazyDataTable } from '../lazyLoad';
+import { LoadingSpinner } from '../../components/LoadingSpinner/LoadingSpinner';
+import { renderWithProviders } from '../../__tests__/helpers/test-utils';
+
+// Mock the DataTable component
+vi.mock('../../components/DataTable', () => ({
+  DataTable: vi.fn(() => <div data-testid="data-table">DataTable Component</div>)
+}));
+
+// Mock the LoadingSpinner component
+vi.mock('../../components/LoadingSpinner/LoadingSpinner', () => ({
+  LoadingSpinner: vi.fn(() => <div data-testid="loading-spinner">Loading...</div>)
+}));
+
+describe('LazyLoad Utility', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('createLazyComponent', () => {
+    it('should create a lazy component with default fallback', async () => {
+      const mockImportFn = vi.fn().mockResolvedValue({
+        default: () => <div data-testid="lazy-component">Lazy Component</div>
+      });
+
+      const LazyTestComponent = createLazyComponent(
+        mockImportFn,
+        'TestComponent'
+      );
+
+      renderWithProviders(<LazyTestComponent />);
+
+      // Should show loading spinner initially
+      expect(screen.getByTestId('loading-spinner')).toBeInTheDocument();
+
+      // Wait for the component to load
+      await waitFor(() => {
+        expect(screen.getByTestId('lazy-component')).toBeInTheDocument();
+      });
+
+      expect(mockImportFn).toHaveBeenCalledTimes(1);
+    });
+
+    it('should create a lazy component with custom fallback', async () => {
+      const mockImportFn = vi.fn().mockResolvedValue({
+        default: () => <div data-testid="lazy-component">Lazy Component</div>
+      });
+
+      const customFallback = <div data-testid="custom-fallback">Custom Loading...</div>;
+
+      const LazyTestComponent = createLazyComponent(
+        mockImportFn,
+        'TestComponent',
+        { fallback: customFallback }
+      );
+
+      renderWithProviders(<LazyTestComponent />);
+
+      // Should show custom fallback initially
+      expect(screen.getByTestId('custom-fallback')).toBeInTheDocument();
+
+      // Wait for the component to load
+      await waitFor(() => {
+        expect(screen.getByTestId('lazy-component')).toBeInTheDocument();
+      });
+    });
+
+    it('should create a lazy component with error boundary', async () => {
+      const mockImportFn = vi.fn().mockResolvedValue({
+        default: () => <div data-testid="lazy-component">Lazy Component</div>
+      });
+
+      const ErrorBoundary = ({ children }: { children: React.ReactNode }) => (
+        <div data-testid="error-boundary">{children}</div>
+      );
+
+      const LazyTestComponent = createLazyComponent(
+        mockImportFn,
+        'TestComponent',
+        { errorBoundary: ErrorBoundary }
+      );
+
+      renderWithProviders(<LazyTestComponent />);
+
+      // Should show loading spinner initially
+      expect(screen.getByTestId('loading-spinner')).toBeInTheDocument();
+
+      // Wait for the component to load
+      await waitFor(() => {
+        expect(screen.getByTestId('lazy-component')).toBeInTheDocument();
+      });
+
+      // Error boundary should wrap the component
+      expect(screen.getByTestId('error-boundary')).toBeInTheDocument();
+    });
+
+    it.skip('should handle import errors gracefully', async () => {
+      const mockImportFn = vi.fn().mockRejectedValue(new Error('Import failed'));
+
+      const LazyTestComponent = createLazyComponent(
+        mockImportFn,
+        'TestComponent'
+      );
+
+      // Suppress console.error and unhandledRejection for this test
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      const originalUnhandledRejection = process.listeners('unhandledRejection');
+      
+      // Add a handler to catch the unhandled rejection
+      const unhandledRejectionHandler = (reason: any) => {
+        if (reason?.message === 'Import failed') {
+          // Expected error, ignore it
+          return;
+        }
+        // Re-throw other errors
+        throw reason;
+      };
+      process.on('unhandledRejection', unhandledRejectionHandler);
+
+      renderWithProviders(<LazyTestComponent />);
+
+      // Should show loading spinner initially
+      expect(screen.getByTestId('loading-spinner')).toBeInTheDocument();
+
+      // Wait for the error to be handled
+      await waitFor(() => {
+        expect(screen.getByTestId('loading-spinner')).toBeInTheDocument();
+      }, { timeout: 1000 });
+
+      // Clean up
+      process.removeListener('unhandledRejection', unhandledRejectionHandler);
+      consoleSpy.mockRestore();
+    });
+
+    it('should set display name correctly', async () => {
+      const mockImportFn = vi.fn().mockResolvedValue({
+        default: () => <div data-testid="lazy-component">Lazy Component</div>
+      });
+
+      const LazyTestComponent = createLazyComponent(
+        mockImportFn,
+        'TestComponent'
+      );
+
+      expect(LazyTestComponent.displayName).toBe('LazyTestComponent');
+    });
+
+    it('should pass props to the lazy component', async () => {
+      const mockImportFn = vi.fn().mockResolvedValue({
+        default: ({ title, count }: { title: string; count: number }) => (
+          <div data-testid="lazy-component">
+            {title}: {count}
+          </div>
+        )
+      });
+
+      const LazyTestComponent = createLazyComponent(
+        mockImportFn,
+        'TestComponent'
+      );
+
+      renderWithProviders(<LazyTestComponent title="Test" count={42} />);
+
+      await waitFor(() => {
+        expect(screen.getByTestId('lazy-component')).toHaveTextContent('Test: 42');
+      });
+    });
+
+    it('should handle multiple instances of the same lazy component', async () => {
+      const mockImportFn = vi.fn().mockResolvedValue({
+        default: ({ id }: { id: string }) => (
+          <div data-testid={`lazy-component-${id}`}>Component {id}</div>
+        )
+      });
+
+      const LazyTestComponent = createLazyComponent(
+        mockImportFn,
+        'TestComponent'
+      );
+
+      renderWithProviders(
+        <div>
+          <LazyTestComponent id="1" />
+          <LazyTestComponent id="2" />
+        </div>
+      );
+
+      await waitFor(() => {
+        expect(screen.getByTestId('lazy-component-1')).toBeInTheDocument();
+        expect(screen.getByTestId('lazy-component-2')).toBeInTheDocument();
+      });
+
+      // Import function should only be called once due to React.lazy caching
+      expect(mockImportFn).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('LazyDataTable', () => {
+    it('should render the DataTable component when loaded', async () => {
+      const mockProps = {
+        data: [{ id: 1, name: 'Test' }],
+        columns: [{ id: 'name', accessorKey: 'name', header: 'Name' }]
+      };
+
+      renderWithProviders(<LazyDataTable {...mockProps} />);
+
+      // Should show loading spinner initially
+      expect(screen.getByTestId('loading-spinner')).toBeInTheDocument();
+
+      // Wait for the DataTable to load
+      await waitFor(() => {
+        expect(screen.getByTestId('data-table')).toBeInTheDocument();
+      });
+    });
+
+    it('should pass props to the DataTable component', async () => {
+      const mockProps = {
+        data: [{ id: 1, name: 'Test' }],
+        columns: [{ id: 'name', accessorKey: 'name', header: 'Name' }]
+      };
+
+      renderWithProviders(<LazyDataTable {...mockProps} />);
+
+      await waitFor(() => {
+        expect(screen.getByTestId('data-table')).toBeInTheDocument();
+      });
+    });
+
+    it('should render without errors', () => {
+      const mockProps = {
+        data: [{ id: 1, name: 'Test' }],
+        columns: [{ id: 'name', accessorKey: 'name', header: 'Name' }]
+      };
+
+      expect(() => renderWithProviders(<LazyDataTable {...mockProps} />)).not.toThrow();
+    });
+  });
+
+  describe('Component Integration', () => {
+    it('should work with React Suspense boundaries', async () => {
+      const mockImportFn = vi.fn().mockResolvedValue({
+        default: () => <div data-testid="lazy-component">Lazy Component</div>
+      });
+
+      const LazyTestComponent = createLazyComponent(
+        mockImportFn,
+        'TestComponent'
+      );
+
+      const TestWrapper = () => (
+        <div data-testid="wrapper">
+          <LazyTestComponent />
+        </div>
+      );
+
+      renderWithProviders(<TestWrapper />);
+
+      // Should show loading spinner initially
+      expect(screen.getByTestId('loading-spinner')).toBeInTheDocument();
+
+      // Wait for the component to load
+      await waitFor(() => {
+        expect(screen.getByTestId('lazy-component')).toBeInTheDocument();
+      });
+
+      // Wrapper should still be present
+      expect(screen.getByTestId('wrapper')).toBeInTheDocument();
+    });
+
+    it('should handle unmounting before load completes', async () => {
+      const mockImportFn = vi.fn().mockImplementation(() => 
+        new Promise(resolve => {
+          setTimeout(() => {
+            resolve({
+              default: () => <div data-testid="lazy-component">Lazy Component</div>
+            });
+          }, 100);
+        })
+      );
+
+      const LazyTestComponent = createLazyComponent(
+        mockImportFn,
+        'TestComponent'
+      );
+
+      const { unmount } = renderWithProviders(<LazyTestComponent />);
+
+      // Should show loading spinner initially
+      expect(screen.getByTestId('loading-spinner')).toBeInTheDocument();
+
+      // Unmount before load completes
+      unmount();
+
+      // Should not throw any errors
+      expect(mockImportFn).toHaveBeenCalledTimes(1);
+    });
+  });
+});