@jmruthers/pace-core 0.5.68 → 0.5.69

package/src/utils/__tests__/debugLogger.test.ts

@@ -0,0 +1,417 @@
+/**
+ * @file Debug Logger Tests
+ * @package @jmruthers/pace-core
+ * @module Utils/DebugLogger/Tests
+ * @since 0.4.76
+ * 
+ * Comprehensive test suite for the DebugLogger utility covering:
+ * - Environment-based logging behavior
+ * - Console method calls
+ * - Message formatting
+ * - Error handling
+ * - Performance considerations
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { DebugLogger } from '../debugLogger';
+
+describe('[unit] DebugLogger Tests', () => {
+  let originalConsoleLog: typeof console.log;
+  let originalConsoleError: typeof console.error;
+  let originalConsoleWarn: typeof console.warn;
+  let originalConsoleInfo: typeof console.info;
+  let originalEnvMode: string;
+
+  beforeEach(() => {
+    // Store original console methods
+    originalConsoleLog = console.log;
+    originalConsoleError = console.error;
+    originalConsoleWarn = console.warn;
+    originalConsoleInfo = console.info;
+
+    // Store original environment mode
+    originalEnvMode = import.meta.env.MODE;
+
+    // Mock console methods
+    console.log = vi.fn();
+    console.error = vi.fn();
+    console.warn = vi.fn();
+    console.info = vi.fn();
+  });
+
+  afterEach(() => {
+    // Restore original console methods
+    console.log = originalConsoleLog;
+    console.error = originalConsoleError;
+    console.warn = originalConsoleWarn;
+    console.info = originalConsoleInfo;
+
+    // Restore original environment mode
+    import.meta.env.MODE = originalEnvMode;
+
+    vi.clearAllMocks();
+  });
+
+  describe('Development Mode Logging', () => {
+    beforeEach(() => {
+      import.meta.env.MODE = 'development';
+    });
+
+    it('should log debug messages in development mode', () => {
+      const component = 'TestComponent';
+      const message = 'Test debug message';
+      const args = ['arg1', 'arg2'];
+
+      DebugLogger.log(component, message, ...args);
+
+      expect(console.log).toHaveBeenCalledWith(
+        `[${component}] ${message}`,
+        ...args
+      );
+    });
+
+    it('should log info messages in development mode', () => {
+      const component = 'TestComponent';
+      const message = 'Test info message';
+      const args = ['arg1', 'arg2'];
+
+      DebugLogger.info(component, message, ...args);
+
+      expect(console.info).toHaveBeenCalledWith(
+        `[${component}] ${message}`,
+        ...args
+      );
+    });
+
+    it('should always log error messages regardless of environment', () => {
+      const component = 'TestComponent';
+      const message = 'Test error message';
+      const args = ['arg1', 'arg2'];
+
+      DebugLogger.error(component, message, ...args);
+
+      expect(console.error).toHaveBeenCalledWith(
+        `[${component}] ${message}`,
+        ...args
+      );
+    });
+
+    it('should always log warning messages regardless of environment', () => {
+      const component = 'TestComponent';
+      const message = 'Test warning message';
+      const args = ['arg1', 'arg2'];
+
+      DebugLogger.warn(component, message, ...args);
+
+      expect(console.warn).toHaveBeenCalledWith(
+        `[${component}] ${message}`,
+        ...args
+      );
+    });
+  });
+
+  describe('Production Mode Logging', () => {
+    beforeEach(() => {
+      import.meta.env.MODE = 'production';
+    });
+
+    it('should not log debug messages in production mode', () => {
+      const component = 'TestComponent';
+      const message = 'Test debug message';
+      const args = ['arg1', 'arg2'];
+
+      DebugLogger.log(component, message, ...args);
+
+      expect(console.log).not.toHaveBeenCalled();
+    });
+
+    it('should not log info messages in production mode', () => {
+      const component = 'TestComponent';
+      const message = 'Test info message';
+      const args = ['arg1', 'arg2'];
+
+      DebugLogger.info(component, message, ...args);
+
+      expect(console.info).not.toHaveBeenCalled();
+    });
+
+    it('should still log error messages in production mode', () => {
+      const component = 'TestComponent';
+      const message = 'Test error message';
+      const args = ['arg1', 'arg2'];
+
+      DebugLogger.error(component, message, ...args);
+
+      expect(console.error).toHaveBeenCalledWith(
+        `[${component}] ${message}`,
+        ...args
+      );
+    });
+
+    it('should still log warning messages in production mode', () => {
+      const component = 'TestComponent';
+      const message = 'Test warning message';
+      const args = ['arg1', 'arg2'];
+
+      DebugLogger.warn(component, message, ...args);
+
+      expect(console.warn).toHaveBeenCalledWith(
+        `[${component}] ${message}`,
+        ...args
+      );
+    });
+  });
+
+  describe('Message Formatting', () => {
+    beforeEach(() => {
+      import.meta.env.MODE = 'development';
+    });
+
+    it('should format messages with component prefix', () => {
+      const component = 'AuthService';
+      const message = 'User authenticated successfully';
+
+      DebugLogger.log(component, message);
+
+      expect(console.log).toHaveBeenCalledWith(
+        `[${component}] ${message}`
+      );
+    });
+
+    it('should handle empty messages', () => {
+      const component = 'TestComponent';
+      const message = '';
+
+      DebugLogger.log(component, message);
+
+      expect(console.log).toHaveBeenCalledWith(
+        `[${component}] `
+      );
+    });
+
+    it('should handle special characters in messages', () => {
+      const component = 'TestComponent';
+      const message = 'Special chars: !@#$%^&*()_+-=[]{}|;:,.<>?';
+
+      DebugLogger.log(component, message);
+
+      expect(console.log).toHaveBeenCalledWith(
+        `[${component}] ${message}`
+      );
+    });
+
+    it('should handle Unicode characters in messages', () => {
+      const component = 'TestComponent';
+      const message = 'Unicode: 🚀 测试 日本語';
+
+      DebugLogger.log(component, message);
+
+      expect(console.log).toHaveBeenCalledWith(
+        `[${component}] ${message}`
+      );
+    });
+  });
+
+  describe('Argument Handling', () => {
+    beforeEach(() => {
+      import.meta.env.MODE = 'development';
+    });
+
+    it('should pass through additional arguments', () => {
+      const component = 'TestComponent';
+      const message = 'Test message';
+      const args = ['string', 123, true, { key: 'value' }, [1, 2, 3]];
+
+      DebugLogger.log(component, message, ...args);
+
+      expect(console.log).toHaveBeenCalledWith(
+        `[${component}] ${message}`,
+        ...args
+      );
+    });
+
+    it('should handle no additional arguments', () => {
+      const component = 'TestComponent';
+      const message = 'Test message';
+
+      DebugLogger.log(component, message);
+
+      expect(console.log).toHaveBeenCalledWith(
+        `[${component}] ${message}`
+      );
+    });
+
+    it('should handle undefined and null arguments', () => {
+      const component = 'TestComponent';
+      const message = 'Test message';
+      const args = [undefined, null];
+
+      DebugLogger.log(component, message, ...args);
+
+      expect(console.log).toHaveBeenCalledWith(
+        `[${component}] ${message}`,
+        ...args
+      );
+    });
+
+    it('should handle circular reference objects', () => {
+      const component = 'TestComponent';
+      const message = 'Test message';
+      const circularObj: any = { name: 'test' };
+      circularObj.self = circularObj;
+
+      DebugLogger.log(component, message, circularObj);
+
+      expect(console.log).toHaveBeenCalledWith(
+        `[${component}] ${message}`,
+        circularObj
+      );
+    });
+  });
+
+  describe('Performance Considerations', () => {
+    beforeEach(() => {
+      import.meta.env.MODE = 'production';
+    });
+
+    it('should not create unnecessary string concatenations in production', () => {
+      const component = 'TestComponent';
+      const message = 'Test message';
+      const args = ['arg1', 'arg2'];
+
+      // Mock console.log to track calls
+      const logSpy = vi.spyOn(console, 'log');
+
+      DebugLogger.log(component, message, ...args);
+
+      // In production, console.log should not be called
+      expect(logSpy).not.toHaveBeenCalled();
+    });
+
+    it('should handle high-frequency logging without performance issues', () => {
+      const component = 'TestComponent';
+      const message = 'High frequency message';
+      const iterations = 1000;
+
+      const startTime = Date.now();
+
+      for (let i = 0; i < iterations; i++) {
+        DebugLogger.log(component, `${message} ${i}`);
+      }
+
+      const endTime = Date.now();
+      const duration = endTime - startTime;
+
+      // Should complete quickly even with many calls
+      expect(duration).toBeLessThan(100); // Less than 100ms for 1000 calls
+    });
+  });
+
+  describe('Error Handling', () => {
+    beforeEach(() => {
+      import.meta.env.MODE = 'development';
+    });
+
+    it('should handle console method errors gracefully', () => {
+      const component = 'TestComponent';
+      const message = 'Test message';
+
+      // Mock console.log to throw an error
+      console.log = vi.fn().mockImplementation(() => {
+        throw new Error('Console error');
+      });
+
+      // Should not throw an error
+      expect(() => {
+        DebugLogger.log(component, message);
+      }).not.toThrow();
+    });
+
+    it('should handle malformed component names', () => {
+      const component = null as any;
+      const message = 'Test message';
+
+      expect(() => {
+        DebugLogger.log(component, message);
+      }).not.toThrow();
+    });
+
+    it('should handle malformed messages', () => {
+      const component = 'TestComponent';
+      const message = null as any;
+
+      expect(() => {
+        DebugLogger.log(component, message);
+      }).not.toThrow();
+    });
+  });
+
+  describe('Environment Detection', () => {
+    it('should detect test environment correctly', () => {
+      import.meta.env.MODE = 'test';
+
+      const component = 'TestComponent';
+      const message = 'Test message';
+
+      DebugLogger.log(component, message);
+
+      // In test mode, should not log (treated as production)
+      expect(console.log).not.toHaveBeenCalled();
+    });
+
+    it('should handle undefined environment mode', () => {
+      import.meta.env.MODE = undefined as any;
+
+      const component = 'TestComponent';
+      const message = 'Test message';
+
+      DebugLogger.log(component, message);
+
+      // Should not log when mode is undefined
+      expect(console.log).not.toHaveBeenCalled();
+    });
+
+    it('should handle empty environment mode', () => {
+      import.meta.env.MODE = '';
+
+      const component = 'TestComponent';
+      const message = 'Test message';
+
+      DebugLogger.log(component, message);
+
+      // Should not log when mode is empty
+      expect(console.log).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Static Method Behavior', () => {
+    beforeEach(() => {
+      import.meta.env.MODE = 'development';
+    });
+
+    it('should work as static methods without instantiation', () => {
+      const component = 'TestComponent';
+      const message = 'Test message';
+
+      // Should work without creating an instance
+      DebugLogger.log(component, message);
+
+      expect(console.log).toHaveBeenCalledWith(
+        `[${component}] ${message}`
+      );
+    });
+
+    it('should maintain consistent behavior across multiple calls', () => {
+      const component = 'TestComponent';
+      const message1 = 'First message';
+      const message2 = 'Second message';
+
+      DebugLogger.log(component, message1);
+      DebugLogger.log(component, message2);
+
+      expect(console.log).toHaveBeenCalledTimes(2);
+      expect(console.log).toHaveBeenNthCalledWith(1, `[${component}] ${message1}`);
+      expect(console.log).toHaveBeenNthCalledWith(2, `[${component}] ${message2}`);
+    });
+  });
+});

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

@@ -96,12 +96,7 @@ describe('Device Fingerprint', () => {
     vi.setSystemTime(new Date('2023-01-01T00:00:00.000Z'));
   });
 
-  afterEach(() => {
-    vi.useRealTimers();
-    vi.restoreAllMocks();
-  });
-
-  describe('generateDeviceFingerprint', () => {
+    describe('generateDeviceFingerprint', () => {
     it('should generate a device fingerprint', () => {
       const fingerprint = generateDeviceFingerprint();
 

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

@@ -62,11 +62,7 @@ describe('dynamicUtils', () => {
     vi.clearAllMocks();
   });
 
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('loadLodash', () => {
+    describe('loadLodash', () => {
     it('should load lodash utilities', async () => {
       const result = await loadLodash();
 

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

@@ -7,7 +7,7 @@
 
 import React from 'react';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { screen, waitFor } from '@testing-library/react';
+import { screen, waitFor, act } from '@testing-library/react';
 import '@testing-library/jest-dom';
 import { createLazyComponent, LazyDataTable } from '../lazyLoad';
 import { LoadingSpinner } from '../../components/LoadingSpinner/LoadingSpinner';
@@ -24,11 +24,7 @@ vi.mock('../../components/LoadingSpinner/LoadingSpinner', () => ({
 }));
 
 describe('LazyLoad Utility', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('createLazyComponent', () => {
+    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>
@@ -105,50 +101,54 @@ describe('LazyLoad Utility', () => {
       expect(screen.getByTestId('error-boundary')).toBeInTheDocument();
     });
 
-    it.skip('should handle import errors gracefully', async () => {
+    it('should handle import errors gracefully', async () => {
+      // Test that React.lazy with error boundary properly handles failed imports
       const mockImportFn = vi.fn().mockRejectedValue(new Error('Import failed'));
 
+      // Create a simple Error Boundary wrapper
+      class TestErrorBoundary extends React.Component<
+        { children: React.ReactNode },
+        { hasError: boolean }
+      > {
+        constructor(props: { children: React.ReactNode }) {
+          super(props);
+          this.state = { hasError: false };
+        }
+
+        static getDerivedStateFromError() {
+          return { hasError: true };
+        }
+
+        render() {
+          if (this.state.hasError) {
+            return <div data-testid="error-display">Error occurred</div>;
+          }
+          return this.props.children;
+        }
+      }
+
       const LazyTestComponent = createLazyComponent(
         mockImportFn,
-        'TestComponent'
+        'TestComponent',
+        { errorBoundary: TestErrorBoundary }
       );
 
-      // Suppress console.error and unhandledRejection for this test
+      // Suppress console.error for this test
       const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-      
-      // Only set up process listeners if process is available (Node.js environment)
-      let originalUnhandledRejection: any[] = [];
-      let unhandledRejectionHandler: ((reason: any) => void) | null = null;
-      
-      if (typeof process !== 'undefined' && process.listeners) {
-        originalUnhandledRejection = process.listeners('unhandledRejection');
-        
-        // Add a handler to catch the unhandled rejection
-        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
+      // Wait for error to be caught and displayed
       await waitFor(() => {
-        expect(screen.getByTestId('loading-spinner')).toBeInTheDocument();
-      }, { timeout: 1000 });
+        expect(screen.getByTestId('error-display')).toBeInTheDocument();
+      }, { timeout: 2000 });
+
+      // The import function should have been called
+      expect(mockImportFn).toHaveBeenCalled();
 
-      // Clean up
-      if (typeof process !== 'undefined' && process.removeListener && unhandledRejectionHandler) {
-        process.removeListener('unhandledRejection', unhandledRejectionHandler);
-      }
       consoleSpy.mockRestore();
     });
 

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

@@ -23,11 +23,7 @@ describe('organisationContext', () => {
     } as unknown as SupabaseClient;
   });
 
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('setOrganisationContext', () => {
+    describe('setOrganisationContext', () => {
     it('should set organisation context successfully', async () => {
       const organisationId = 'org-123';
       const mockRpc = vi.fn().mockResolvedValue({ error: null });

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

@@ -24,11 +24,7 @@ describe('performanceBudgets', () => {
     performanceBudgetMonitor.reset();
   });
 
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('PERFORMANCE_BUDGETS', () => {
+    describe('PERFORMANCE_BUDGETS', () => {
     it('should have all required performance budget thresholds', () => {
       expect(PERFORMANCE_BUDGETS).toHaveProperty('COMPONENT_RENDER');
       expect(PERFORMANCE_BUDGETS).toHaveProperty('BUNDLE_SIZE');
@@ -76,22 +72,20 @@ describe('performanceBudgets', () => {
     });
 
     it('should log metrics in development mode', () => {
-      const originalEnv = process.env.NODE_ENV;
-      process.env.NODE_ENV = 'development';
-
+      // The performance budget monitor checks for 'development' or 'test' mode
+      // In the test environment, import.meta.env.MODE should be 'test'
       performanceBudgetMonitor.measure('TEST_METRIC', 25, { component: 'Button' });
 
       expect(consoleSpy.log).toHaveBeenCalledWith(
         '📊 Performance Metric: TEST_METRIC = 25',
         { component: 'Button' }
       );
-
-      process.env.NODE_ENV = originalEnv;
     });
 
     it('should not log metrics in production mode', () => {
-      // Mock import.meta.env.MODE for production using vi.stubEnv
+      // Mock both MODE and NODE_ENV for production
       vi.stubEnv('MODE', 'production');
+      vi.stubEnv('NODE_ENV', 'production');
 
       performanceBudgetMonitor.measure('TEST_METRIC', 25);
 

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

@@ -18,12 +18,7 @@ import {
 import { AuthErrorCode } from '../../types/unified';
 
 describe('Secure Errors', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.spyOn(console, 'warn').mockImplementation(() => {});
-  });
-
-  describe('SecureError', () => {
+    describe('SecureError', () => {
     it('should create a SecureError with all properties', () => {
       const error = new SecureError(
         'Test error message',

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

@@ -55,11 +55,7 @@ describe('Secure Storage', () => {
     mockCrypto.getRandomValues.mockReturnValue(new Uint8Array(12));
   });
 
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('initialization', () => {
+    describe('initialization', () => {
     it('should initialize without existing key', async () => {
       mockLocalStorage.getItem.mockReturnValue(null);
       mockCrypto.subtle.generateKey.mockResolvedValue({} as CryptoKey);

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

@@ -7,11 +7,7 @@ describe('securityMonitor', () => {
     securityMonitor.clearEvents();
   });
 
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('logEvent', () => {
+    describe('logEvent', () => {
     it('should log a security event with generated ID and timestamp', () => {
       const event = {
         action: 'login_attempt',

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

@@ -27,11 +27,7 @@ describe('sessionTracking', () => {
     } as unknown as SupabaseClient;
   });
 
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('trackLogin', () => {
+    describe('trackLogin', () => {
     it('should track login successfully', async () => {
       const mockUser = { id: 'user-123', email: 'test@example.com' };
       const mockGetUser = vi.fn().mockResolvedValue({ data: { user: mockUser } });