@jmruthers/pace-core 0.5.68 → 0.5.69

package/src/__tests__/helpers/__tests__/timer-utils.test.ts

@@ -0,0 +1,371 @@
+/**
+ * @file Timer Utilities Tests
+ * @package @jmruthers/pace-core
+ * @module TestHelpers/__tests__
+ * @since 1.0.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  fastForwardTime,
+  fastForwardToNextTimer,
+  runAllTimers,
+  mockImmediateTimeout,
+  mockImmediateInterval,
+  setupFastTimers,
+  cleanupTimers
+} from '../timer-utils';
+
+describe('[helpers] fastForwardTime', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('advances timers by specified milliseconds', () => {
+    const callback = vi.fn();
+    setTimeout(callback, 1000);
+    
+    expect(callback).not.toHaveBeenCalled();
+    
+    fastForwardTime(1000);
+    
+    expect(callback).toHaveBeenCalledTimes(1);
+  });
+
+  it('advances timers by partial amount', () => {
+    const callback = vi.fn();
+    setTimeout(callback, 1000);
+    
+    fastForwardTime(500);
+    
+    expect(callback).not.toHaveBeenCalled();
+    
+    fastForwardTime(500);
+    
+    expect(callback).toHaveBeenCalledTimes(1);
+  });
+
+  it('advances multiple timers', () => {
+    const callback1 = vi.fn();
+    const callback2 = vi.fn();
+    
+    setTimeout(callback1, 500);
+    setTimeout(callback2, 1000);
+    
+    fastForwardTime(1000);
+    
+    expect(callback1).toHaveBeenCalledTimes(1);
+    expect(callback2).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('[helpers] fastForwardToNextTimer', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('runs only pending timers', () => {
+    const callback1 = vi.fn();
+    const callback2 = vi.fn();
+    
+    setTimeout(callback1, 1000);
+    setTimeout(callback2, 2000);
+    
+    fastForwardToNextTimer();
+    
+    expect(callback1).toHaveBeenCalledTimes(1);
+    expect(callback2).not.toHaveBeenCalled();
+  });
+
+  it('runs next timer when called multiple times', () => {
+    const callback1 = vi.fn();
+    const callback2 = vi.fn();
+    
+    setTimeout(callback1, 1000);
+    setTimeout(callback2, 2000);
+    
+    fastForwardToNextTimer();
+    expect(callback1).toHaveBeenCalledTimes(1);
+    expect(callback2).not.toHaveBeenCalled();
+    
+    fastForwardToNextTimer();
+    expect(callback1).toHaveBeenCalledTimes(1);
+    expect(callback2).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('[helpers] runAllTimers', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('runs all pending timers', () => {
+    const callback1 = vi.fn();
+    const callback2 = vi.fn();
+    const callback3 = vi.fn();
+    
+    setTimeout(callback1, 1000);
+    setTimeout(callback2, 2000);
+    setTimeout(callback3, 3000);
+    
+    runAllTimers();
+    
+    expect(callback1).toHaveBeenCalledTimes(1);
+    expect(callback2).toHaveBeenCalledTimes(1);
+    expect(callback3).toHaveBeenCalledTimes(1);
+  });
+
+  it('runs all timers including intervals', () => {
+    const callback1 = vi.fn();
+    const callback2 = vi.fn();
+    
+    setTimeout(callback1, 1000);
+    const intervalId = setInterval(callback2, 500);
+    
+    // Advance time to trigger both
+    vi.advanceTimersByTime(1000);
+    
+    expect(callback1).toHaveBeenCalledTimes(1);
+    expect(callback2).toHaveBeenCalledTimes(2); // Called twice: once at 0ms and once at 1000ms
+    
+    // Clear interval to prevent infinite loop
+    clearInterval(intervalId);
+  });
+});
+
+describe('[helpers] mockImmediateTimeout', () => {
+      it('mocks setTimeout to execute immediately', () => {
+    mockImmediateTimeout();
+    
+    const callback = vi.fn();
+    const result = setTimeout(callback, 1000);
+    
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(result).toBe(1);
+  });
+
+  it('mocks setTimeout to return timer ID', () => {
+    mockImmediateTimeout();
+    
+    const callback = vi.fn();
+    const timerId = setTimeout(callback, 1000);
+    
+    expect(typeof timerId).toBe('number');
+    expect(timerId).toBe(1);
+  });
+
+  it('mocks setTimeout with different callbacks', () => {
+    mockImmediateTimeout();
+    
+    const callback1 = vi.fn();
+    const callback2 = vi.fn();
+    
+    setTimeout(callback1, 1000);
+    setTimeout(callback2, 2000);
+    
+    expect(callback1).toHaveBeenCalledTimes(1);
+    expect(callback2).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('[helpers] mockImmediateInterval', () => {
+      it('mocks setInterval to execute immediately', () => {
+    mockImmediateInterval();
+    
+    const callback = vi.fn();
+    const result = setInterval(callback, 1000);
+    
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(result).toBe(1);
+  });
+
+  it('mocks setInterval to return timer ID', () => {
+    mockImmediateInterval();
+    
+    const callback = vi.fn();
+    const timerId = setInterval(callback, 1000);
+    
+    expect(typeof timerId).toBe('number');
+    expect(timerId).toBe(1);
+  });
+
+  it('mocks setInterval with different callbacks', () => {
+    mockImmediateInterval();
+    
+    const callback1 = vi.fn();
+    const callback2 = vi.fn();
+    
+    setInterval(callback1, 1000);
+    setInterval(callback2, 2000);
+    
+    expect(callback1).toHaveBeenCalledTimes(1);
+    expect(callback2).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('[helpers] setupFastTimers', () => {
+      it('sets up fake timers', () => {
+    setupFastTimers();
+    
+    expect(vi.isFakeTimers()).toBe(true);
+  });
+
+  it('mocks setTimeout to execute immediately', () => {
+    setupFastTimers();
+    
+    const callback = vi.fn();
+    setTimeout(callback, 1000);
+    
+    expect(callback).toHaveBeenCalledTimes(1);
+  });
+
+  it('mocks setInterval to execute immediately', () => {
+    setupFastTimers();
+    
+    const callback = vi.fn();
+    setInterval(callback, 1000);
+    
+    expect(callback).toHaveBeenCalledTimes(1);
+  });
+
+  it('combines fake timers with immediate execution', () => {
+    setupFastTimers();
+    
+    const timeoutCallback = vi.fn();
+    const intervalCallback = vi.fn();
+    
+    setTimeout(timeoutCallback, 1000);
+    setInterval(intervalCallback, 500);
+    
+    expect(timeoutCallback).toHaveBeenCalledTimes(1);
+    expect(intervalCallback).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('[helpers] cleanupTimers', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    mockImmediateTimeout();
+    mockImmediateInterval();
+  });
+
+    it('restores real timers', () => {
+    cleanupTimers();
+    
+    expect(vi.isFakeTimers()).toBe(false);
+  });
+
+  it('restores all mocks', () => {
+    // Verify that cleanup doesn't throw
+    expect(() => cleanupTimers()).not.toThrow();
+    expect(vi.isFakeTimers()).toBe(false);
+  });
+
+  it('restores setTimeout to original behavior', () => {
+    cleanupTimers();
+    
+    const callback = vi.fn();
+    const timerId = setTimeout(callback, 100);
+    
+    expect(callback).not.toHaveBeenCalled();
+    
+    // Clean up timer
+    clearTimeout(timerId);
+  });
+
+  it('restores setInterval to original behavior', () => {
+    cleanupTimers();
+    
+    const callback = vi.fn();
+    const timerId = setInterval(callback, 100);
+    
+    expect(callback).not.toHaveBeenCalled();
+    
+    // Clean up interval
+    clearInterval(timerId);
+  });
+});
+
+describe('[helpers] Integration Tests', () => {
+      it('works with setupFastTimers and cleanupTimers', () => {
+    // Setup fast timers
+    setupFastTimers();
+    
+    const callback = vi.fn();
+    setTimeout(callback, 1000);
+    expect(callback).toHaveBeenCalledTimes(1);
+    
+    // Cleanup timers
+    cleanupTimers();
+    
+    const callback2 = vi.fn();
+    setTimeout(callback2, 1000);
+    expect(callback2).not.toHaveBeenCalled();
+  });
+
+  it('works with fastForwardTime in fake timer environment', () => {
+    vi.useFakeTimers();
+    
+    const callback = vi.fn();
+    setTimeout(callback, 1000);
+    
+    fastForwardTime(1000);
+    
+    expect(callback).toHaveBeenCalledTimes(1);
+    
+    vi.useRealTimers();
+  });
+
+  it('works with runAllTimers in fake timer environment', () => {
+    vi.useFakeTimers();
+    
+    const callback1 = vi.fn();
+    const callback2 = vi.fn();
+    
+    setTimeout(callback1, 1000);
+    setTimeout(callback2, 2000);
+    
+    runAllTimers();
+    
+    expect(callback1).toHaveBeenCalledTimes(1);
+    expect(callback2).toHaveBeenCalledTimes(1);
+    
+    vi.useRealTimers();
+  });
+
+  it('works with immediate timeout mocking', () => {
+    mockImmediateTimeout();
+    
+    const callback = vi.fn();
+    const timerId = setTimeout(callback, 1000);
+    
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(timerId).toBe(1);
+    
+    vi.restoreAllMocks();
+  });
+
+  it('works with immediate interval mocking', () => {
+    mockImmediateInterval();
+    
+    const callback = vi.fn();
+    const timerId = setInterval(callback, 1000);
+    
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(timerId).toBe(1);
+    
+    vi.restoreAllMocks();
+  });
+});

package/src/__tests__/helpers/component-test-utils.tsx

@@ -3,7 +3,7 @@
  * @description Specialized utilities for component testing
  */
 
-import { render, screen, RenderResult } from '@testing-library/react';
+import { render, screen, RenderResult, cleanup } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { vi } from 'vitest';
 import { renderWithProviders } from './test-utils';
@@ -13,8 +13,9 @@ export const componentTestPatterns = {
   // Test component renders without crashing
   testRenders: (Component: React.ComponentType<any>, props = {}) => {
     return () => {
-      renderWithProviders(<Component {...props} />);
-      expect(screen.getByRole('generic')).toBeInTheDocument();
+      cleanup(); // Clean up previous renders
+      const { container } = renderWithProviders(<Component {...props} />);
+      expect(container.firstChild).toBeInTheDocument();
     };
   },
   
@@ -27,6 +28,7 @@ export const componentTestPatterns = {
     return testCases.map(({ name, props, expectedBehavior }) => ({
       name: `handles ${name}`,
       test: () => {
+        cleanup(); // Clean up previous renders
         renderWithProviders(<Component {...props} />);
         expectedBehavior();
       },
@@ -42,6 +44,7 @@ export const componentTestPatterns = {
     return eventTests.map(({ name, action, expectedBehavior }) => ({
       name: `handles ${name}`,
       test: async () => {
+        cleanup(); // Clean up previous renders
         const user = userEvent.setup();
         renderWithProviders(<Component />);
         
@@ -55,6 +58,7 @@ export const componentTestPatterns = {
   // Test accessibility
   testAccessibility: (Component: React.ComponentType<any>, props = {}) => {
     return () => {
+      cleanup(); // Clean up previous renders
       renderWithProviders(<Component {...props} />);
       
       // Basic accessibility checks
@@ -73,6 +77,7 @@ export const commonScenarios = {
       {
         name: 'renders with text',
         test: () => {
+          cleanup(); // Clean up previous renders
           renderWithProviders(<Component>Click me</Component>);
           expect(screen.getByRole('button', { name: 'Click me' })).toBeInTheDocument();
         },
@@ -80,6 +85,7 @@ export const commonScenarios = {
       {
         name: 'handles click events',
         test: async () => {
+          cleanup(); // Clean up previous renders
           const handleClick = vi.fn();
           const user = userEvent.setup();
           renderWithProviders(<Component onClick={handleClick}>Click me</Component>);
@@ -91,6 +97,7 @@ export const commonScenarios = {
       {
         name: 'can be disabled',
         test: () => {
+          cleanup(); // Clean up previous renders
           renderWithProviders(<Component disabled>Disabled</Component>);
           expect(screen.getByRole('button')).toBeDisabled();
         },
@@ -104,13 +111,16 @@ export const commonScenarios = {
       {
         name: 'renders form elements',
         test: () => {
+          cleanup(); // Clean up previous renders
           renderWithProviders(<Component />);
-          expect(screen.getByRole('form')).toBeInTheDocument();
+          const submitButton = screen.queryByRole('button', { name: /submit/i });
+          expect(submitButton).toBeInTheDocument();
         },
       },
       {
         name: 'handles form submission',
         test: async () => {
+          cleanup(); // Clean up previous renders
           const handleSubmit = vi.fn();
           const user = userEvent.setup();
           renderWithProviders(<Component onSubmit={handleSubmit} />);

package/src/__tests__/helpers/optimized-test-setup.ts

@@ -0,0 +1,68 @@
+/**
+ * @file Optimized Test Setup
+ * @description Performance-optimized test setup utilities
+ */
+
+import { vi } from 'vitest';
+
+/**
+ * Create a fast mock that resolves immediately
+ */
+export const createFastMock = <T>(value: T) => {
+  return vi.fn().mockResolvedValue(value);
+};
+
+/**
+ * Create a fast mock that rejects immediately
+ */
+export const createFastErrorMock = (error: Error) => {
+  return vi.fn().mockRejectedValue(error);
+};
+
+/**
+ * Setup optimized mocks for common patterns
+ */
+export const setupOptimizedMocks = () => {
+  // Mock fetch to resolve immediately
+  global.fetch = vi.fn().mockResolvedValue({
+    ok: true,
+    json: () => Promise.resolve({}),
+    text: () => Promise.resolve(''),
+  });
+
+  // Mock setTimeout to execute immediately
+  vi.spyOn(global, 'setTimeout').mockImplementation((callback: Function) => {
+    callback();
+    return 1 as any;
+  });
+
+  // Mock setInterval to execute immediately
+  vi.spyOn(global, 'setInterval').mockImplementation((callback: Function) => {
+    callback();
+    return 1 as any;
+  });
+};
+
+/**
+ * Cleanup optimized mocks
+ */
+export const cleanupOptimizedMocks = () => {
+  vi.restoreAllMocks();
+};
+
+/**
+ * Create a test that runs with optimized setup
+ */
+export const createOptimizedTest = (name: string, fn: () => void | Promise<void>) => {
+  return {
+    name,
+    fn: async () => {
+      try {
+        setupOptimizedMocks();
+        await fn();
+      } finally {
+        cleanupOptimizedMocks();
+      }
+    }
+  };
+};