Add comprehensive test coverage for all components

Author: thelastbackspace

.github/workflows/ci.yml

@@ -24,8 +24,7 @@ jobs:
     - run: npm ci
     - run: npm run build
     - run: npm run lint
-    # Uncomment when tests are added
-    # - run: npm test
+    - run: npm test
 
   publish-npm:
     needs: build
@@ -38,7 +37,7 @@ jobs:
           node-version: '18.x'
           registry-url: 'https://registry.npmjs.org/'
       - run: npm ci
-      - run: npm run build
+      - run: npm run build:all
       - run: npm publish
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} 

src/__tests__/browser.test.ts

@@ -0,0 +1,163 @@
+import { BrowserLogger, BrowserPerformanceMonitor, BrowserExecutionTracker } from '../browser';
+
+// Mock the performance API
+const originalPerformance = global.performance;
+beforeAll(() => {
+  // Create a custom performance object with memory property
+  const mockPerformance = {
+    now: jest.fn().mockImplementation(() => Date.now()),
+    // Add other required properties from Performance interface
+    timing: {} as any,
+    navigation: {} as any,
+    timeOrigin: 0,
+    // Custom property for Chrome's performance.memory
+    memory: {
+      usedJSHeapSize: 1000000,
+      totalJSHeapSize: 2000000,
+      jsHeapSizeLimit: 4000000
+    }
+  };
+  
+  // @ts-ignore - Ignore type checking for the test mock
+  global.performance = mockPerformance;
+});
+
+afterAll(() => {
+  global.performance = originalPerformance;
+});
+
+describe('BrowserLogger', () => {
+  let browserLogger: BrowserLogger;
+  let consoleInfoSpy: jest.SpyInstance;
+  let consoleWarnSpy: jest.SpyInstance;
+  let consoleErrorSpy: jest.SpyInstance;
+  let consoleDebugSpy: jest.SpyInstance;
+  let consoleLogSpy: jest.SpyInstance;
+  
+  beforeEach(() => {
+    browserLogger = new BrowserLogger();
+    
+    // Spy on console methods
+    consoleInfoSpy = jest.spyOn(console, 'info').mockImplementation();
+    consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
+    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+    consoleDebugSpy = jest.spyOn(console, 'debug').mockImplementation();
+    consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+  });
+  
+  afterEach(() => {
+    consoleInfoSpy.mockRestore();
+    consoleWarnSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+    consoleDebugSpy.mockRestore();
+    consoleLogSpy.mockRestore();
+  });
+  
+  test('info method should log a message', () => {
+    browserLogger.info('Test info message');
+    expect(consoleInfoSpy).toHaveBeenCalledWith('Test info message', []);
+  });
+  
+  test('warn method should log a warning message', () => {
+    browserLogger.warn('Test warning message');
+    expect(consoleWarnSpy).toHaveBeenCalledWith('Test warning message', []);
+  });
+  
+  test('error method should log an error message', () => {
+    browserLogger.error('Test error message');
+    expect(consoleErrorSpy).toHaveBeenCalledWith('Test error message', []);
+  });
+  
+  test('debug method should log a debug message', () => {
+    browserLogger.debug('Test debug message');
+    expect(consoleDebugSpy).toHaveBeenCalledWith('Test debug message', []);
+  });
+  
+  test('debug messages should be suppressed in production mode', () => {
+    browserLogger.setMode('prod');
+    browserLogger.debug('This should not be logged');
+    expect(consoleDebugSpy).not.toHaveBeenCalled();
+  });
+  
+  test('track should return the result of the tracked function', () => {
+    const result = browserLogger.track(() => 'test-result');
+    expect(result).toBe('test-result');
+    expect(consoleLogSpy).toHaveBeenCalled();
+  });
+  
+  test('setMode and getMode should work correctly', () => {
+    expect(browserLogger.getMode()).toBe('dev');
+    browserLogger.setMode('staging');
+    expect(browserLogger.getMode()).toBe('staging');
+    browserLogger.setMode('prod');
+    expect(browserLogger.getMode()).toBe('prod');
+  });
+});
+
+describe('BrowserPerformanceMonitor', () => {
+  let performanceMonitor: BrowserPerformanceMonitor;
+  
+  beforeEach(() => {
+    performanceMonitor = new BrowserPerformanceMonitor({ defaultThreshold: 100 });
+  });
+  
+  test('startTimer and endTimer should measure duration', () => {
+    const id = performanceMonitor.startTimer('test-timer');
+    const duration = performanceMonitor.endTimer(id);
+    expect(duration).toBeGreaterThanOrEqual(0);
+  });
+  
+  test('isBottleneck should return true for durations above threshold', () => {
+    expect(performanceMonitor.isBottleneck(150)).toBe(true);
+    expect(performanceMonitor.isBottleneck(50)).toBe(false);
+  });
+  
+  test('getMemoryUsage should return memory usage information', () => {
+    const memoryUsage = performanceMonitor.getMemoryUsage();
+    expect(memoryUsage).toHaveProperty('heapUsed');
+    expect(memoryUsage).toHaveProperty('heapTotal');
+    expect(memoryUsage.heapUsed).toBe(1000000);
+    expect(memoryUsage.heapTotal).toBe(2000000);
+  });
+});
+
+describe('BrowserExecutionTracker', () => {
+  let executionTracker: BrowserExecutionTracker;
+  
+  beforeEach(() => {
+    executionTracker = new BrowserExecutionTracker({ defaultThreshold: 100 });
+  });
+  
+  test('track should return the result of the tracked function', () => {
+    const result = executionTracker.track(() => 'test-result');
+    expect(result).toBe('test-result');
+  });
+  
+  test('track should record execution data', () => {
+    executionTracker.track(() => {}, { label: 'testFunction' });
+    
+    const flowChart = executionTracker.generateFlowChart();
+    expect(flowChart).toContain('testFunction');
+    expect(flowChart).toContain('Execution Flow');
+  });
+  
+  test('getCallStack should return the current call stack', () => {
+    executionTracker.track(() => {
+      const callStack = executionTracker.getCallStack();
+      expect(callStack.length).toBe(1);
+      expect(callStack[0]).toBe('testFunction');
+    }, { label: 'testFunction' });
+  });
+  
+  test('clear should reset execution data', () => {
+    executionTracker.track(() => {}, { label: 'testFunction' });
+    
+    let flowChart = executionTracker.generateFlowChart();
+    expect(flowChart).toContain('testFunction');
+    
+    executionTracker.clear();
+    
+    flowChart = executionTracker.generateFlowChart();
+    expect(flowChart).not.toContain('testFunction');
+  });
+}); 

src/__tests__/execution.test.ts

@@ -0,0 +1,88 @@
+import { ExecutionTracker } from '../trackers/execution';
+
+describe('ExecutionTracker', () => {
+  let executionTracker: ExecutionTracker;
+  
+  beforeEach(() => {
+    executionTracker = new ExecutionTracker({ defaultThreshold: 100 });
+  });
+  
+  test('track should return the result of the tracked function', () => {
+    const result = executionTracker.track(() => 'test-result');
+    expect(result).toBe('test-result');
+  });
+  
+  test('track should handle errors in tracked functions', () => {
+    const errorMessage = 'Test error';
+    
+    expect(() => {
+      executionTracker.track(() => {
+        throw new Error(errorMessage);
+      });
+    }).toThrow(errorMessage);
+  });
+  
+  test('track should record execution data', () => {
+    executionTracker.track(() => {
+      // Simulate some work
+      const start = Date.now();
+      while (Date.now() - start < 10) {
+        // Busy wait to ensure some time passes
+      }
+    }, { label: 'testFunction' });
+    
+    const flowChart = executionTracker.generateFlowChart();
+    expect(flowChart).toContain('testFunction');
+    expect(flowChart).toContain('Execution Flow');
+  });
+  
+  test('track should detect slow functions', () => {
+    executionTracker.track(() => {
+      // Simulate slow work
+      const start = Date.now();
+      while (Date.now() - start < 150) {
+        // Busy wait to ensure threshold is exceeded
+      }
+    }, { label: 'slowFunction', threshold: 100 });
+    
+    const flowChart = executionTracker.generateFlowChart();
+    expect(flowChart).toContain('slowFunction');
+    expect(flowChart).toContain('SLOW');
+  });
+  
+  test('track should handle nested function calls', () => {
+    executionTracker.track(() => {
+      // Outer function
+      executionTracker.track(() => {
+        // Inner function
+      }, { label: 'innerFunction' });
+    }, { label: 'outerFunction' });
+    
+    const flowChart = executionTracker.generateFlowChart();
+    expect(flowChart).toContain('outerFunction');
+    expect(flowChart).toContain('innerFunction');
+  });
+  
+  test('getCallStack should return the current call stack', () => {
+    executionTracker.track(() => {
+      executionTracker.track(() => {
+        const callStack = executionTracker.getCallStack();
+        expect(callStack.length).toBe(2);
+        expect(callStack[0]).toBe('outerFunction');
+        expect(callStack[1]).toBe('innerFunction');
+      }, { label: 'innerFunction' });
+    }, { label: 'outerFunction' });
+  });
+  
+  test('clear should reset execution data', () => {
+    executionTracker.track(() => {}, { label: 'testFunction' });
+    
+    let flowChart = executionTracker.generateFlowChart();
+    expect(flowChart).toContain('testFunction');
+    
+    executionTracker.clear();
+    
+    flowChart = executionTracker.generateFlowChart();
+    expect(flowChart).not.toContain('testFunction');
+  });
+}); 

src/__tests__/performance.test.ts

@@ -0,0 +1,66 @@
+import { PerformanceMonitor } from '../trackers/performance';
+
+describe('PerformanceMonitor', () => {
+  let performanceMonitor: PerformanceMonitor;
+  
+  beforeEach(() => {
+    performanceMonitor = new PerformanceMonitor({ defaultThreshold: 100 });
+  });
+  
+  test('startTimer and endTimer should measure duration', () => {
+    const id = performanceMonitor.startTimer('test-timer');
+    
+    // Simulate some work
+    const start = Date.now();
+    while (Date.now() - start < 10) {
+      // Busy wait to ensure some time passes
+    }
+    
+    const duration = performanceMonitor.endTimer(id);
+    expect(duration).toBeGreaterThan(0);
+  });
+  
+  test('endTimer should throw error for non-existent timer', () => {
+    expect(() => {
+      performanceMonitor.endTimer('non-existent-timer');
+    }).toThrow();
+  });
+  
+  test('isBottleneck should return true for durations above threshold', () => {
+    expect(performanceMonitor.isBottleneck(150)).toBe(true);
+    expect(performanceMonitor.isBottleneck(50)).toBe(false);
+  });
+  
+  test('isBottleneck should use custom threshold when provided', () => {
+    expect(performanceMonitor.isBottleneck(75, 50)).toBe(true);
+    expect(performanceMonitor.isBottleneck(75, 100)).toBe(false);
+  });
+  
+  test('getMemoryUsage should return memory usage information', () => {
+    const memoryUsage = performanceMonitor.getMemoryUsage();
+    expect(memoryUsage).toHaveProperty('heapUsed');
+    expect(memoryUsage).toHaveProperty('heapTotal');
+    expect(memoryUsage).toHaveProperty('external');
+    expect(memoryUsage).toHaveProperty('rss');
+    
+    expect(typeof memoryUsage.heapUsed).toBe('number');
+    expect(typeof memoryUsage.heapTotal).toBe('number');
+    expect(typeof memoryUsage.external).toBe('number');
+    expect(typeof memoryUsage.rss).toBe('number');
+  });
+  
+  test('generateSuggestion should provide different suggestions based on duration', () => {
+    const slowSuggestion = performanceMonitor.generateSuggestion('slowFunction', 1500);
+    const mediumSuggestion = performanceMonitor.generateSuggestion('mediumFunction', 600);
+    const fastSuggestion = performanceMonitor.generateSuggestion('fastFunction', 50);
+    
+    expect(slowSuggestion).toContain('slowFunction');
+    expect(slowSuggestion).toContain('caching');
+    
+    expect(mediumSuggestion).toContain('mediumFunction');
+    expect(mediumSuggestion).toContain('blocking');
+    
+    expect(fastSuggestion).toContain('fastFunction');
+    expect(fastSuggestion).toContain('optimizations');
+  });
+});