@jmruthers/pace-core 0.5.68 → 0.5.69

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

@@ -0,0 +1,260 @@
+/**
+ * @file Component Test Utilities Tests
+ * @package @jmruthers/pace-core
+ * @module TestHelpers/__tests__
+ * @since 1.0.0
+ */
+
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import userEvent from '@testing-library/user-event';
+import {
+  componentTestPatterns,
+  commonScenarios,
+  createTestData
+} from '../component-test-utils';
+
+// Mock the renderWithProviders function
+vi.mock('../test-utils', () => ({
+  renderWithProviders: vi.fn((ui) => render(ui))
+}));
+
+describe('[helpers] componentTestPatterns', () => {
+    describe('testRenders', () => {
+    it('creates test that renders component without crashing', () => {
+      const TestComponent = () => <div data-testid="test-component">Test</div>;
+      const testFn = componentTestPatterns.testRenders(TestComponent);
+      
+      expect(typeof testFn).toBe('function');
+      
+      // Execute the test
+      expect(() => testFn()).not.toThrow();
+    });
+
+    it('creates test that renders component with props', () => {
+      const TestComponent = ({ name }: { name: string }) => <div data-testid="test-component">{name}</div>;
+      const testFn = componentTestPatterns.testRenders(TestComponent, { name: 'Test Name' });
+      
+      expect(typeof testFn).toBe('function');
+      
+      // Execute the test
+      expect(() => testFn()).not.toThrow();
+    });
+  });
+
+  describe('testProps', () => {
+    it('creates test cases for prop handling', () => {
+      const TestComponent = ({ disabled }: { disabled?: boolean }) => (
+        <button disabled={disabled}>Test Button</button>
+      );
+      
+      const testCases = [
+        {
+          name: 'disabled prop',
+          props: { disabled: true },
+          expectedBehavior: () => {
+            expect(screen.getByRole('button')).toBeDisabled();
+          }
+        },
+        {
+          name: 'enabled prop',
+          props: { disabled: false },
+          expectedBehavior: () => {
+            expect(screen.getByRole('button')).not.toBeDisabled();
+          }
+        }
+      ];
+      
+      const tests = componentTestPatterns.testProps(TestComponent, testCases);
+      
+      expect(tests).toHaveLength(2);
+      expect(tests[0].name).toBe('handles disabled prop');
+      expect(tests[1].name).toBe('handles enabled prop');
+      
+      // Execute the first test
+      expect(() => tests[0].test()).not.toThrow();
+    });
+  });
+
+  describe('testEvents', () => {
+    it('creates test cases for event handling', async () => {
+      const TestComponent = () => <button>Click me</button>;
+      
+      const eventTests = [
+        {
+          name: 'click event',
+          action: async (element: HTMLElement) => {
+            const user = userEvent.setup();
+            await user.click(element);
+          },
+          expectedBehavior: () => {
+            expect(screen.getByRole('button')).toBeInTheDocument();
+          }
+        }
+      ];
+      
+      const tests = componentTestPatterns.testEvents(TestComponent, eventTests);
+      
+      expect(tests).toHaveLength(1);
+      expect(tests[0].name).toBe('handles click event');
+      
+      // Execute the test
+      await expect(tests[0].test()).resolves.not.toThrow();
+    });
+  });
+
+  describe('testAccessibility', () => {
+    it('creates accessibility test', () => {
+      const TestComponent = () => <button>Test Button</button>;
+      const testFn = componentTestPatterns.testAccessibility(TestComponent);
+      
+      expect(typeof testFn).toBe('function');
+      
+      // Execute the test
+      expect(() => testFn()).not.toThrow();
+    });
+  });
+});
+
+describe('[helpers] commonScenarios', () => {
+    describe('button scenarios', () => {
+    it('creates button render test', () => {
+      const TestButton = ({ children, onClick, disabled }: any) => (
+        <button onClick={onClick} disabled={disabled}>
+          {children}
+        </button>
+      );
+      
+      const tests = commonScenarios.button.renders(TestButton);
+      
+      expect(tests).toHaveLength(3);
+      expect(tests[0].name).toBe('renders with text');
+      expect(tests[1].name).toBe('handles click events');
+      expect(tests[2].name).toBe('can be disabled');
+    });
+
+    it('executes button render test', () => {
+      const TestButton = ({ children }: any) => <button>{children}</button>;
+      const tests = commonScenarios.button.renders(TestButton);
+      
+      expect(() => tests[0].test()).not.toThrow();
+    });
+
+    it('executes button click test', async () => {
+      const TestButton = ({ children, onClick }: any) => (
+        <button onClick={onClick}>{children}</button>
+      );
+      const tests = commonScenarios.button.renders(TestButton);
+      
+      await expect(tests[1].test()).resolves.not.toThrow();
+    });
+
+    it('executes button disabled test', () => {
+      const TestButton = ({ children, disabled }: any) => (
+        <button disabled={disabled}>{children}</button>
+      );
+      const tests = commonScenarios.button.renders(TestButton);
+      
+      expect(() => tests[2].test()).not.toThrow();
+    });
+  });
+
+  describe('form scenarios', () => {
+    it('creates form render test', () => {
+      const TestForm = ({ onSubmit }: any) => (
+        <form onSubmit={onSubmit}>
+          <button type="submit">Submit</button>
+        </form>
+      );
+      
+      const tests = commonScenarios.form.renders(TestForm);
+      
+      expect(tests).toHaveLength(2);
+      expect(tests[0].name).toBe('renders form elements');
+      expect(tests[1].name).toBe('handles form submission');
+    });
+
+    it('executes form render test', () => {
+      const TestForm = () => (
+        <form>
+          <button type="submit">Submit</button>
+        </form>
+      );
+      const tests = commonScenarios.form.renders(TestForm);
+      
+      expect(() => tests[0].test()).not.toThrow();
+    });
+
+    it('executes form submission test', async () => {
+      const TestForm = ({ onSubmit }: any) => (
+        <form onSubmit={onSubmit}>
+          <button type="submit">Submit</button>
+        </form>
+      );
+      const tests = commonScenarios.form.renders(TestForm);
+      
+      await expect(tests[1].test()).resolves.not.toThrow();
+    });
+  });
+});
+
+describe('[helpers] createTestData', () => {
+    describe('button data', () => {
+    it('creates button data with defaults', () => {
+      const buttonData = createTestData.button();
+      
+      expect(buttonData).toHaveProperty('children', 'Test Button');
+      expect(buttonData).toHaveProperty('onClick');
+      expect(typeof buttonData.onClick).toBe('function');
+    });
+
+    it('creates button data with overrides', () => {
+      const customOnClick = vi.fn();
+      const buttonData = createTestData.button({ 
+        children: 'Custom Button',
+        onClick: customOnClick
+      });
+      
+      expect(buttonData.children).toBe('Custom Button');
+      expect(buttonData.onClick).toBe(customOnClick);
+    });
+  });
+
+  describe('form data', () => {
+    it('creates form data with defaults', () => {
+      const formData = createTestData.form();
+      
+      expect(formData).toHaveProperty('onSubmit');
+      expect(typeof formData.onSubmit).toBe('function');
+    });
+
+    it('creates form data with overrides', () => {
+      const customOnSubmit = vi.fn();
+      const formData = createTestData.form({ onSubmit: customOnSubmit });
+      
+      expect(formData.onSubmit).toBe(customOnSubmit);
+    });
+  });
+
+  describe('user data', () => {
+    it('creates user data with defaults', () => {
+      const userData = createTestData.user();
+      
+      expect(userData).toHaveProperty('id', '1');
+      expect(userData).toHaveProperty('name', 'Test User');
+      expect(userData).toHaveProperty('email', 'test@example.com');
+    });
+
+    it('creates user data with overrides', () => {
+      const userData = createTestData.user({ 
+        name: 'Custom User',
+        email: 'custom@example.com'
+      });
+      
+      expect(userData.name).toBe('Custom User');
+      expect(userData.email).toBe('custom@example.com');
+      expect(userData.id).toBe('1'); // Should still have default
+    });
+  });
+});

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

@@ -0,0 +1,224 @@
+/**
+ * @file Optimized Test Setup Tests
+ * @package @jmruthers/pace-core
+ * @module TestHelpers/__tests__
+ * @since 1.0.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  createFastMock,
+  createFastErrorMock,
+  setupOptimizedMocks,
+  cleanupOptimizedMocks,
+  createOptimizedTest
+} from '../optimized-test-setup';
+
+describe('[helpers] createFastMock', () => {
+    it('creates mock that resolves with value', async () => {
+    const mockValue = { data: 'test' };
+    const mockFn = createFastMock(mockValue);
+    
+    const result = await mockFn();
+    
+    expect(result).toEqual(mockValue);
+    expect(mockFn).toHaveBeenCalledTimes(1);
+  });
+
+  it('creates mock that can be called multiple times', async () => {
+    const mockValue = { data: 'test' };
+    const mockFn = createFastMock(mockValue);
+    
+    const result1 = await mockFn();
+    const result2 = await mockFn();
+    
+    expect(result1).toEqual(mockValue);
+    expect(result2).toEqual(mockValue);
+    expect(mockFn).toHaveBeenCalledTimes(2);
+  });
+
+  it('creates mock with different values', async () => {
+    const mockValue1 = { data: 'test1' };
+    const mockValue2 = { data: 'test2' };
+    const mockFn1 = createFastMock(mockValue1);
+    const mockFn2 = createFastMock(mockValue2);
+    
+    const result1 = await mockFn1();
+    const result2 = await mockFn2();
+    
+    expect(result1).toEqual(mockValue1);
+    expect(result2).toEqual(mockValue2);
+  });
+});
+
+describe('[helpers] createFastErrorMock', () => {
+    it('creates mock that rejects with error', async () => {
+    const testError = new Error('Test error');
+    const mockFn = createFastErrorMock(testError);
+    
+    await expect(mockFn()).rejects.toThrow('Test error');
+    expect(mockFn).toHaveBeenCalledTimes(1);
+  });
+
+  it('creates mock that can be called multiple times', async () => {
+    const testError = new Error('Test error');
+    const mockFn = createFastErrorMock(testError);
+    
+    await expect(mockFn()).rejects.toThrow('Test error');
+    await expect(mockFn()).rejects.toThrow('Test error');
+    expect(mockFn).toHaveBeenCalledTimes(2);
+  });
+
+  it('creates mock with different errors', async () => {
+    const error1 = new Error('Error 1');
+    const error2 = new Error('Error 2');
+    const mockFn1 = createFastErrorMock(error1);
+    const mockFn2 = createFastErrorMock(error2);
+    
+    await expect(mockFn1()).rejects.toThrow('Error 1');
+    await expect(mockFn2()).rejects.toThrow('Error 2');
+  });
+});
+
+describe('[helpers] setupOptimizedMocks', () => {
+      it('sets up fetch mock', () => {
+    setupOptimizedMocks();
+    
+    expect(global.fetch).toBeDefined();
+    expect(vi.isMockFunction(global.fetch)).toBe(true);
+  });
+
+  it('sets up setTimeout mock', () => {
+    setupOptimizedMocks();
+    
+    // Test that setTimeout executes callback immediately
+    let called = false;
+    global.setTimeout(() => {
+      called = true;
+    }, 1000);
+    
+    expect(called).toBe(true);
+  });
+
+  it('sets up setInterval mock', () => {
+    setupOptimizedMocks();
+    
+    // Test that setInterval executes callback immediately
+    let called = false;
+    global.setInterval(() => {
+      called = true;
+    }, 1000);
+    
+    expect(called).toBe(true);
+  });
+
+  it('fetch mock resolves with success response', async () => {
+    setupOptimizedMocks();
+    
+    const response = await global.fetch('https://example.com');
+    
+    expect(response.ok).toBe(true);
+    expect(await response.json()).toEqual({});
+    expect(await response.text()).toBe('');
+  });
+
+  it('setTimeout executes callback immediately', () => {
+    setupOptimizedMocks();
+    
+    const callback = vi.fn();
+    const result = global.setTimeout(callback, 1000);
+    
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(result).toBe(1);
+  });
+
+  it('setInterval executes callback immediately', () => {
+    setupOptimizedMocks();
+    
+    const callback = vi.fn();
+    const result = global.setInterval(callback, 1000);
+    
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(result).toBe(1);
+  });
+});
+
+describe('[helpers] cleanupOptimizedMocks', () => {
+    it('restores all mocks', () => {
+    // Set up some mocks first
+    setupOptimizedMocks();
+    
+    // Verify mocks are set up
+    expect(vi.isMockFunction(global.fetch)).toBe(true);
+    
+    // Clean up mocks
+    cleanupOptimizedMocks();
+    
+    // Verify mocks are restored (this is hard to test directly, but we can verify the function exists)
+    expect(typeof cleanupOptimizedMocks).toBe('function');
+  });
+});
+
+describe('[helpers] createOptimizedTest', () => {
+      it('creates test with name and function', () => {
+    const testFn = vi.fn();
+    const test = createOptimizedTest('Test Name', testFn);
+    
+    expect(test).toHaveProperty('name', 'Test Name');
+    expect(test).toHaveProperty('fn');
+    expect(typeof test.fn).toBe('function');
+  });
+
+  it('executes test function with optimized setup', async () => {
+    let called = false;
+    const testFn = async () => { called = true; };
+    const test = createOptimizedTest('Test Name', testFn);
+    
+    await test.fn();
+    
+    expect(called).toBe(true);
+  });
+
+  it('sets up and cleans up mocks around test execution', async () => {
+    let called = false;
+    const testFn = async () => { 
+      called = true;
+      // Verify that fetch mock is set up
+      const fetchResult = await global.fetch('https://test.com');
+      expect(fetchResult.ok).toBe(true);
+    };
+    const test = createOptimizedTest('Test Name', testFn);
+    
+    await test.fn();
+    
+    expect(called).toBe(true);
+  });
+
+  it('handles test function errors gracefully', async () => {
+    const testError = new Error('Test error');
+    const testFn = async () => { throw testError; };
+    const test = createOptimizedTest('Test Name', testFn);
+    
+    await expect(test.fn()).rejects.toThrow('Test error');
+  });
+
+  it('handles synchronous test functions', async () => {
+    let called = false;
+    const testFn = () => { called = true; return 'sync result'; };
+    const test = createOptimizedTest('Test Name', testFn);
+    
+    await test.fn();
+    
+    expect(called).toBe(true);
+  });
+
+  it('handles asynchronous test functions', async () => {
+    let called = false;
+    const testFn = async () => { called = true; return 'async result'; };
+    const test = createOptimizedTest('Test Name', testFn);
+    
+    await test.fn();
+    
+    expect(called).toBe(true);
+  });
+});