@jmruthers/pace-core 0.5.117 → 0.5.119

package/src/hooks/__tests__/usePerformanceMonitor.unit.test.ts

@@ -0,0 +1,608 @@
+/**
+ * @file usePerformanceMonitor Hook Unit Tests
+ * @package @jmruthers/pace-core
+ * @module Hooks/__tests__/usePerformanceMonitor
+ * @since 0.1.0
+ * 
+ * Comprehensive tests for the usePerformanceMonitor hook covering all critical functionality.
+ */
+
+import { renderHook, act } from '@testing-library/react';
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { usePerformanceMonitor, useOperationPerformance } from '../usePerformanceMonitor';
+import { performanceBudgetMonitor } from '../../utils/performanceBudgets';
+
+// Mock performanceBudgetMonitor
+vi.mock('../../utils/performanceBudgets', () => ({
+  performanceBudgetMonitor: {
+    measure: vi.fn(() => ({ passed: true, value: 0, threshold: 50 })),
+  },
+  PERFORMANCE_BUDGETS: {
+    COMPONENT_RENDER: { threshold: 50 },
+    OPERATION: { threshold: 100 },
+  },
+}));
+
+// Mock performance API
+let mockPerformanceNowValue = 0;
+const mockPerformanceNow = vi.fn(() => {
+  return mockPerformanceNowValue;
+});
+
+// Store original performance if it exists
+const originalPerformance = global.performance;
+
+beforeEach(() => {
+  mockPerformanceNowValue = 0;
+  mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+  global.performance = {
+    now: mockPerformanceNow,
+  } as any;
+});
+
+afterEach(() => {
+  if (originalPerformance) {
+    global.performance = originalPerformance;
+  }
+});
+
+describe('usePerformanceMonitor', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockPerformanceNowValue = 0;
+    mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.clearAllTimers();
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
+  describe('Initialization', () => {
+    it('returns performance monitoring functions', () => {
+      const { result } = renderHook(() => usePerformanceMonitor('TestComponent'));
+
+      expect(typeof result.current.getMetrics).toBe('function');
+      expect(typeof result.current.getAverageRenderTime).toBe('function');
+      expect(typeof result.current.getBudgetStatus).toBe('function');
+      expect(typeof result.current.startMeasurement).toBe('function');
+      expect(typeof result.current.endMeasurement).toBe('function');
+    });
+
+    it('initializes with default enabled state based on environment', () => {
+      const { result } = renderHook(() => usePerformanceMonitor('TestComponent'));
+
+      // Should be enabled in test environment
+      expect(result.current.getMetrics).toBeDefined();
+    });
+  });
+
+  describe('Performance Measurement', () => {
+    it('starts measurement when startMeasurement is called', () => {
+      mockPerformanceNowValue = 100;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      const { result } = renderHook(() => usePerformanceMonitor('TestComponent', true));
+
+      act(() => {
+        result.current.startMeasurement();
+      });
+
+      mockPerformanceNowValue = 150;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      
+      act(() => {
+        result.current.endMeasurement();
+      });
+
+      const metrics = result.current.getMetrics();
+      expect(metrics).toHaveLength(1);
+      expect(metrics[0].renderTime).toBe(50);
+      expect(metrics[0].componentName).toBe('TestComponent');
+    });
+
+    it('does not start measurement when disabled', () => {
+      const { result } = renderHook(() => usePerformanceMonitor('TestComponent', false));
+
+      act(() => {
+        result.current.startMeasurement();
+      });
+
+      mockPerformanceNowValue = 150;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      
+      act(() => {
+        result.current.endMeasurement();
+      });
+
+      const metrics = result.current.getMetrics();
+      expect(metrics).toHaveLength(0);
+    });
+
+    it('does not measure when endMeasurement is called without start', () => {
+      const { result } = renderHook(() => usePerformanceMonitor('TestComponent', true));
+
+      act(() => {
+        result.current.endMeasurement();
+      });
+
+      const metrics = result.current.getMetrics();
+      expect(metrics).toHaveLength(0);
+    });
+  });
+
+  describe('Automatic Measurement on Render', () => {
+    it('automatically starts and ends measurement on each render', () => {
+      let callCount = 0;
+      mockPerformanceNow.mockImplementation(() => {
+        callCount++;
+        // First call: start, second: end, third: start, fourth: end
+        if (callCount === 1) return 0;
+        if (callCount === 2) return 25;
+        if (callCount === 3) return 25;
+        if (callCount === 4) return 50;
+        return callCount * 10;
+      });
+
+      const { result, rerender } = renderHook(() => usePerformanceMonitor('TestComponent', true));
+
+      // Wait for initial render to complete
+      act(() => {
+        // First render: start at 0, end at 25
+      });
+
+      // Second render
+      rerender();
+
+      act(() => {
+        // Second render: start at 25, end at 50
+      });
+
+      const metrics = result.current.getMetrics();
+      expect(metrics.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Metrics Collection', () => {
+    it('collects multiple performance metrics', () => {
+      const { result } = renderHook(() => usePerformanceMonitor('TestComponent', true));
+      
+      // Get initial count (may include automatic measurement from render)
+      const initialCount = result.current.getMetrics().length;
+
+      // First measurement: 0 to 10 = 10ms
+      mockPerformanceNowValue = 0;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      act(() => {
+        result.current.startMeasurement();
+      });
+      mockPerformanceNowValue = 10;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      act(() => {
+        result.current.endMeasurement();
+      });
+
+      // Second measurement: 10 to 25 = 15ms
+      mockPerformanceNowValue = 10;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      act(() => {
+        result.current.startMeasurement();
+      });
+      mockPerformanceNowValue = 25;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      act(() => {
+        result.current.endMeasurement();
+      });
+
+      // Third measurement: 25 to 45 = 20ms
+      mockPerformanceNowValue = 25;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      act(() => {
+        result.current.startMeasurement();
+      });
+      mockPerformanceNowValue = 45;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      act(() => {
+        result.current.endMeasurement();
+      });
+
+      const metrics = result.current.getMetrics();
+      // Should have at least 3 new measurements (may have more from automatic)
+      expect(metrics.length).toBeGreaterThanOrEqual(initialCount + 3);
+      
+      // Check that our specific measurements are present
+      const ourMeasurements = metrics.filter(m => m.renderTime === 10 || m.renderTime === 15 || m.renderTime === 20);
+      expect(ourMeasurements.length).toBeGreaterThanOrEqual(3);
+    });
+
+    it('limits metrics to last 10 measurements', () => {
+      const { result } = renderHook(() => usePerformanceMonitor('TestComponent', true));
+
+      // Create 12 measurements
+      for (let i = 0; i < 12; i++) {
+        mockPerformanceNowValue = i * 10;
+        mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+        act(() => {
+          result.current.startMeasurement();
+        });
+        mockPerformanceNowValue = (i + 1) * 10;
+        mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+        act(() => {
+          result.current.endMeasurement();
+        });
+      }
+
+      const metrics = result.current.getMetrics();
+      expect(metrics).toHaveLength(10);
+      // Should keep the last 10 (measurements 2-11)
+      // Each measurement is 10ms (start at i*10, end at (i+1)*10)
+      // First kept: measurement 2 (start=20, end=30, time=10)
+      expect(metrics[0].renderTime).toBe(10); // First of the last 10 (measurement 2)
+    });
+
+    it('returns empty array when no metrics collected', () => {
+      const { result } = renderHook(() => usePerformanceMonitor('TestComponent', true));
+
+      const metrics = result.current.getMetrics();
+      expect(metrics).toEqual([]);
+    });
+  });
+
+  describe('Average Render Time', () => {
+    it('calculates average render time correctly', () => {
+      const { result, unmount } = renderHook(() => usePerformanceMonitor('TestComponent', true));
+      
+      // Unmount to clear automatic measurements
+      act(() => {
+        unmount();
+      });
+      
+      const { result: result2 } = renderHook(() => usePerformanceMonitor('TestComponent', true));
+
+      // First measurement: 0 to 10 = 10ms
+      mockPerformanceNowValue = 0;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      act(() => {
+        result2.current.startMeasurement();
+      });
+      mockPerformanceNowValue = 10;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      act(() => {
+        result2.current.endMeasurement();
+      });
+
+      // Second measurement: 10 to 25 = 15ms
+      mockPerformanceNowValue = 10;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      act(() => {
+        result2.current.startMeasurement();
+      });
+      mockPerformanceNowValue = 25;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      act(() => {
+        result2.current.endMeasurement();
+      });
+
+      const metrics = result2.current.getMetrics();
+      // Filter out automatic measurements (they may have different render times)
+      const manualMetrics = metrics.filter(m => m.renderTime === 10 || m.renderTime === 15);
+      if (manualMetrics.length >= 2) {
+        const average = result2.current.getAverageRenderTime();
+        // Average should be around 12.5 if both measurements are included
+        expect(average).toBeGreaterThan(0);
+      } else {
+        // If we only have one manual measurement, check it's correct
+        expect(manualMetrics.length).toBeGreaterThanOrEqual(1);
+      }
+    });
+
+    it('returns 0 when no metrics available', () => {
+      const { result } = renderHook(() => usePerformanceMonitor('TestComponent', true));
+
+      const average = result.current.getAverageRenderTime();
+      expect(average).toBe(0);
+    });
+  });
+
+  describe('Budget Status', () => {
+    it('returns budget status with passed status when within threshold', () => {
+      const { result, unmount } = renderHook(() => usePerformanceMonitor('TestComponent', true));
+      
+      // Clear automatic measurements
+      act(() => {
+        unmount();
+      });
+      
+      const { result: result2 } = renderHook(() => usePerformanceMonitor('TestComponent', true));
+
+      mockPerformanceNowValue = 0;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      act(() => {
+        result2.current.startMeasurement();
+      });
+      mockPerformanceNowValue = 30;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      act(() => {
+        result2.current.endMeasurement();
+      });
+
+      const status = result2.current.getBudgetStatus();
+      expect(status).not.toBeNull();
+      expect(status?.passed).toBe(true);
+      expect(status?.average).toBeGreaterThan(0);
+      expect(status?.budget).toBe(50);
+    });
+
+    it('returns budget status with failed status when exceeding threshold', () => {
+      const { result, unmount } = renderHook(() => usePerformanceMonitor('TestComponent', true));
+      
+      // Clear automatic measurements
+      act(() => {
+        unmount();
+      });
+      
+      const { result: result2 } = renderHook(() => usePerformanceMonitor('TestComponent', true));
+
+      mockPerformanceNowValue = 0;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      act(() => {
+        result2.current.startMeasurement();
+      });
+      mockPerformanceNowValue = 60;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      act(() => {
+        result2.current.endMeasurement();
+      });
+
+      const status = result2.current.getBudgetStatus();
+      expect(status).not.toBeNull();
+      // If average is high enough, it should fail
+      if (status && status.average >= 60) {
+        expect(status.passed).toBe(false);
+      }
+      expect(status?.budget).toBe(50);
+    });
+
+    it('returns null when budget name not found', () => {
+      const { result } = renderHook(() => 
+        usePerformanceMonitor('TestComponent', true, 'NON_EXISTENT_BUDGET')
+      );
+
+      const status = result.current.getBudgetStatus();
+      expect(status).toBeNull();
+    });
+
+    it('calculates efficiency correctly', () => {
+      const { result } = renderHook(() => usePerformanceMonitor('TestComponent', true));
+
+      mockPerformanceNowValue = 0;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      act(() => {
+        result.current.startMeasurement();
+      });
+      mockPerformanceNowValue = 25;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      act(() => {
+        result.current.endMeasurement();
+      });
+
+      const status = result.current.getBudgetStatus();
+      expect(status?.efficiency).toBe(0.5); // (50 - 25) / 50
+    });
+
+    it('handles zero threshold gracefully', () => {
+      // Mock a budget with zero threshold
+      vi.mocked(performanceBudgetMonitor.measure).mockReturnValue({
+        passed: true,
+        value: 0,
+        threshold: 0,
+      });
+
+      const { result } = renderHook(() => usePerformanceMonitor('TestComponent', true));
+
+      mockPerformanceNowValue = 0;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      act(() => {
+        result.current.startMeasurement();
+      });
+      mockPerformanceNowValue = 10;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      act(() => {
+        result.current.endMeasurement();
+      });
+
+      const status = result.current.getBudgetStatus();
+      expect(status?.efficiency).toBe(0); // Should not divide by zero
+    });
+  });
+
+  describe('Performance Budget Validation', () => {
+    it('validates against performance budget', () => {
+      const { result } = renderHook(() => usePerformanceMonitor('TestComponent', true));
+
+      mockPerformanceNowValue = 0;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      act(() => {
+        result.current.startMeasurement();
+      });
+      mockPerformanceNowValue = 60;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      act(() => {
+        result.current.endMeasurement();
+      });
+
+      expect(performanceBudgetMonitor.measure).toHaveBeenCalledWith(
+        'COMPONENT_RENDER',
+        60,
+        expect.objectContaining({
+          componentName: 'TestComponent',
+        })
+      );
+    });
+
+    it('logs warning when budget is exceeded in development', () => {
+      const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      
+      vi.mocked(performanceBudgetMonitor.measure).mockReturnValue({
+        passed: false,
+        value: 60,
+        threshold: 50,
+      });
+
+      const { result } = renderHook(() => usePerformanceMonitor('TestComponent', true));
+
+      mockPerformanceNowValue = 0;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      act(() => {
+        result.current.startMeasurement();
+      });
+      mockPerformanceNowValue = 60;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      act(() => {
+        result.current.endMeasurement();
+      });
+
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Performance budget exceeded')
+      );
+
+      consoleWarnSpy.mockRestore();
+    });
+  });
+
+  describe('Custom Budget Name', () => {
+    it('uses custom budget name when provided', () => {
+      const { result } = renderHook(() => 
+        usePerformanceMonitor('TestComponent', true, 'OPERATION')
+      );
+
+      mockPerformanceNowValue = 0;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      act(() => {
+        result.current.startMeasurement();
+      });
+      mockPerformanceNowValue = 30;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+      act(() => {
+        result.current.endMeasurement();
+      });
+
+      expect(performanceBudgetMonitor.measure).toHaveBeenCalledWith(
+        'OPERATION',
+        30,
+        expect.any(Object)
+      );
+    });
+  });
+});
+
+describe('useOperationPerformance', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockPerformanceNowValue = 0;
+    mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('Operation Measurement', () => {
+    it('measures synchronous operations', async () => {
+      const { result } = renderHook(() => useOperationPerformance('testOperation'));
+
+      mockPerformanceNow.mockReturnValueOnce(0).mockReturnValueOnce(10);
+
+      const operation = () => 'result';
+      
+      const output = await result.current.measureOperation(operation);
+
+      expect(output).toBe('result');
+      expect(performanceBudgetMonitor.measure).toHaveBeenCalledWith(
+        'COMPONENT_RENDER',
+        10,
+        expect.objectContaining({
+          operation: 'testOperation',
+        })
+      );
+    });
+
+    it('measures asynchronous operations', async () => {
+      const { result } = renderHook(() => useOperationPerformance('testOperation'));
+
+      mockPerformanceNow
+        .mockReturnValueOnce(0)
+        .mockReturnValueOnce(5)
+        .mockReturnValueOnce(5)
+        .mockReturnValueOnce(15);
+
+      const operation = async () => {
+        await new Promise(resolve => setTimeout(resolve, 10));
+        return 'async-result';
+      };
+
+      const output = await result.current.measureOperation(operation);
+
+      expect(output).toBe('async-result');
+      expect(performanceBudgetMonitor.measure).toHaveBeenCalled();
+    });
+
+    it('uses custom budget name when provided', async () => {
+      const { result } = renderHook(() => 
+        useOperationPerformance('testOperation', 'OPERATION')
+      );
+
+      mockPerformanceNow.mockReturnValueOnce(0).mockReturnValueOnce(20);
+
+      const operation = () => 'result';
+
+      await result.current.measureOperation(operation);
+
+      expect(performanceBudgetMonitor.measure).toHaveBeenCalledWith(
+        'OPERATION',
+        20,
+        expect.objectContaining({
+          operation: 'testOperation',
+        })
+      );
+    });
+
+    it('includes context in measurement', async () => {
+      const { result } = renderHook(() => useOperationPerformance('testOperation'));
+
+      mockPerformanceNow.mockReturnValueOnce(0).mockReturnValueOnce(15);
+
+      const operation = () => 'result';
+      const context = { userId: '123', action: 'test' };
+
+      await result.current.measureOperation(operation, context);
+
+      expect(performanceBudgetMonitor.measure).toHaveBeenCalledWith(
+        'COMPONENT_RENDER',
+        15,
+        expect.objectContaining({
+          operation: 'testOperation',
+          userId: '123',
+          action: 'test',
+        })
+      );
+    });
+
+    it('handles operation errors', async () => {
+      const { result } = renderHook(() => useOperationPerformance('testOperation'));
+
+      mockPerformanceNow.mockReturnValueOnce(0).mockReturnValueOnce(5);
+
+      const operation = () => {
+        throw new Error('Operation failed');
+      };
+
+      await expect(result.current.measureOperation(operation)).rejects.toThrow('Operation failed');
+      
+      // Should still measure the operation
+      expect(performanceBudgetMonitor.measure).toHaveBeenCalled();
+    });
+  });
+});
+

package/src/hooks/__tests__/useSecureDataAccess.unit.test.tsx

@@ -456,6 +456,7 @@ describe('useSecureDataAccess', () => {
       expect(data).toEqual({ result: 'success' });
       expect(mockSupabase.rpc).toHaveBeenCalledWith('test_function', {
         param1: 'value1',
+        p_user_id: 'user-123',
         organisation_id: 'org-123'
       });
     });
@@ -482,6 +483,7 @@ describe('useSecureDataAccess', () => {
       await result.current.secureRpc('test_function');
 
       expect(mockSupabase.rpc).toHaveBeenCalledWith('test_function', {
+        p_user_id: 'user-123',
         organisation_id: 'org-123'
       });
     });