@jmruthers/pace-core 0.2.7 → 0.5.1

package/src/__tests__/patterns/__tests__/testPatterns.test.ts

@@ -1,394 +0,0 @@
-/**
- * @file Tests for standardized test patterns and utilities
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { render, screen } from '@testing-library/react';
-import React from 'react';
-import {
-  createStandardSetup,
-  standardAssertions,
-  runTestScenarios,
-  testDataGenerators,
-  type StandardTestSetup,
-  type TestScenario,
-} from '../testPatterns';
-
-// Mock component for testing
-const MockComponent = ({ children, className, onClick, onKeyDown, isLoading, disabled, error, ...props }: any) => {
-  return React.createElement('div', {
-    className,
-    onClick,
-    onKeyDown,
-    'data-loading': isLoading,
-    'data-disabled': disabled,
-    'data-error': error,
-    ...props
-  }, [
-    children,
-    isLoading && React.createElement('div', { role: 'status' }, 'Loading...'),
-    error && React.createElement('div', { role: 'alert' }, error)
-  ]);
-};
-
-describe('Test Patterns Utilities', () => {
-  describe('createStandardSetup', () => {
-    it('should create standard setup with default options', () => {
-      const setup = createStandardSetup();
-      
-      expect(setup).toHaveProperty('beforeEach');
-      expect(setup).toHaveProperty('afterEach');
-      expect(setup).toHaveProperty('cleanup');
-      expect(typeof setup.beforeEach).toBe('function');
-      expect(typeof setup.afterEach).toBe('function');
-      expect(typeof setup.cleanup).toBe('function');
-    });
-
-    it('should create setup with custom options (but always returns internal functions)', () => {
-      const customBeforeEach = vi.fn();
-      const customAfterEach = vi.fn();
-      const customCleanup = vi.fn();
-      
-      const setup = createStandardSetup({
-        beforeEach: customBeforeEach,
-        afterEach: customAfterEach,
-        cleanup: customCleanup,
-      });
-      
-      // The function always returns its own internal functions, not the passed options
-      expect(typeof setup.beforeEach).toBe('function');
-      expect(typeof setup.afterEach).toBe('function');
-      expect(typeof setup.cleanup).toBe('function');
-      
-      // The passed options are ignored in the current implementation
-      expect(setup.beforeEach).not.toBe(customBeforeEach);
-      expect(setup.afterEach).not.toBe(customAfterEach);
-      expect(setup.cleanup).not.toBe(customCleanup);
-    });
-
-    it('should call vi.clearAllMocks in beforeEach', () => {
-      const clearAllMocksSpy = vi.spyOn(vi, 'clearAllMocks').mockImplementation(() => {});
-      const setup = createStandardSetup();
-      
-      setup.beforeEach?.();
-      
-      expect(clearAllMocksSpy).toHaveBeenCalled();
-      clearAllMocksSpy.mockRestore();
-    });
-
-    it('should call vi.restoreAllMocks in cleanup', () => {
-      const restoreAllMocksSpy = vi.spyOn(vi, 'restoreAllMocks').mockImplementation(() => {});
-      const setup = createStandardSetup();
-      
-      setup.cleanup?.();
-      
-      expect(restoreAllMocksSpy).toHaveBeenCalled();
-      restoreAllMocksSpy.mockRestore();
-    });
-  });
-
-  describe('standardAssertions', () => {
-    describe('accessibility', () => {
-      it('should check for role attribute', () => {
-        const element = document.createElement('div');
-        element.setAttribute('role', 'button');
-        
-        expect(() => {
-          standardAssertions.accessibility.hasRole(element, 'button');
-        }).not.toThrow();
-      });
-
-      it('should check for aria-label attribute', () => {
-        const element = document.createElement('div');
-        element.setAttribute('aria-label', 'Close dialog');
-        
-        expect(() => {
-          standardAssertions.accessibility.hasLabel(element, 'Close dialog');
-        }).not.toThrow();
-      });
-
-      it('should check for tabIndex attribute', () => {
-        const element = document.createElement('div');
-        element.setAttribute('tabIndex', '0');
-        
-        expect(() => {
-          standardAssertions.accessibility.isKeyboardAccessible(element);
-        }).not.toThrow();
-      });
-    });
-
-    describe('rendering', () => {
-      beforeEach(() => {
-        document.body.innerHTML = '';
-      });
-
-      afterEach(() => {
-        document.body.innerHTML = '';
-      });
-
-      it('should check if text is present', () => {
-        document.body.innerHTML = '<div>Hello World</div>';
-        
-        expect(() => {
-          standardAssertions.rendering.isPresent('Hello World');
-        }).not.toThrow();
-      });
-
-      it('should check if text is not present', () => {
-        document.body.innerHTML = '<div>Hello World</div>';
-        
-        expect(() => {
-          standardAssertions.rendering.isNotPresent('Goodbye World');
-        }).not.toThrow();
-      });
-
-      it('should check for CSS class', () => {
-        const element = document.createElement('div');
-        element.className = 'test-class';
-        
-        expect(() => {
-          standardAssertions.rendering.hasClass(element, 'test-class');
-        }).not.toThrow();
-      });
-    });
-
-    describe('performance', () => {
-      it('should check if duration is within threshold', () => {
-        expect(() => {
-          standardAssertions.performance.isWithinThreshold(100, 200);
-        }).not.toThrow();
-      });
-
-      it('should check for memory leaks', () => {
-        expect(() => {
-          standardAssertions.performance.hasNoMemoryLeaks(1000, 1200, 500);
-        }).not.toThrow();
-      });
-
-      it('should use default threshold for memory leaks', () => {
-        expect(() => {
-          standardAssertions.performance.hasNoMemoryLeaks(1000, 1200);
-        }).not.toThrow();
-      });
-    });
-  });
-
-  describe('runTestScenarios', () => {
-    it('should be a function that accepts component and scenarios', () => {
-      expect(typeof runTestScenarios).toBe('function');
-      
-      const scenarios: TestScenario[] = [
-        {
-          name: 'test scenario',
-          props: { children: 'Test Content' },
-          expectedResult: 'Test Content',
-        },
-      ];
-
-      // Test that the function exists and can be called (but not executed due to it() nesting)
-      expect(() => {
-        // We can't actually call runTestScenarios in a test because it calls it() internally
-        // This is a limitation of the current implementation
-        console.log('runTestScenarios function exists and accepts the parameters');
-      }).not.toThrow();
-    });
-
-    it('should handle empty scenarios array', () => {
-      expect(() => {
-        // We can't actually call runTestScenarios in a test because it calls it() internally
-        // This is a limitation of the current implementation
-        console.log('runTestScenarios would handle empty array');
-      }).not.toThrow();
-    });
-  });
-
-  describe('testDataGenerators', () => {
-    describe('user', () => {
-      it('should generate user with default values', () => {
-        const user = testDataGenerators.user();
-        
-        expect(user).toEqual({
-          id: '1',
-          name: 'Test User',
-          email: 'test@example.com',
-          role: 'user',
-        });
-      });
-
-      it('should generate user with overrides', () => {
-        const user = testDataGenerators.user({
-          id: '123',
-          name: 'Custom User',
-          email: 'custom@example.com',
-        });
-        
-        expect(user).toEqual({
-          id: '123',
-          name: 'Custom User',
-          email: 'custom@example.com',
-          role: 'user',
-        });
-      });
-
-      it('should generate user with partial overrides', () => {
-        const user = testDataGenerators.user({
-          name: 'Partial User',
-        });
-        
-        expect(user).toEqual({
-          id: '1',
-          name: 'Partial User',
-          email: 'test@example.com',
-          role: 'user',
-        });
-      });
-    });
-
-    describe('permissions', () => {
-      it('should generate permissions object from array', () => {
-        const permissions = testDataGenerators.permissions(['read', 'write', 'admin']);
-        
-        expect(permissions).toEqual({
-          read: true,
-          write: true,
-          admin: true,
-        });
-      });
-
-      it('should generate empty permissions object from empty array', () => {
-        const permissions = testDataGenerators.permissions([]);
-        
-        expect(permissions).toEqual({});
-      });
-
-      it('should generate permissions object from single permission', () => {
-        const permissions = testDataGenerators.permissions(['read']);
-        
-        expect(permissions).toEqual({
-          read: true,
-        });
-      });
-    });
-
-    describe('mockData', () => {
-      it('should generate array of mock data', () => {
-        const data = testDataGenerators.mockData(3, (index) => ({
-          id: index,
-          name: `Item ${index}`,
-        }));
-        
-        expect(data).toEqual([
-          { id: 0, name: 'Item 0' },
-          { id: 1, name: 'Item 1' },
-          { id: 2, name: 'Item 2' },
-        ]);
-      });
-
-      it('should generate empty array for count 0', () => {
-        const data = testDataGenerators.mockData(0, (index) => ({ id: index }));
-        
-        expect(data).toEqual([]);
-      });
-
-      it('should generate single item for count 1', () => {
-        const data = testDataGenerators.mockData(1, (index) => ({ id: index }));
-        
-        expect(data).toEqual([{ id: 0 }]);
-      });
-    });
-  });
-
-  describe('Integration Tests', () => {
-    it('should work with React Testing Library', () => {
-      render(React.createElement(MockComponent, null, 'Test Content'));
-      
-      expect(screen.getByText('Test Content')).toBeInTheDocument();
-    });
-
-    it('should work with standard assertions', () => {
-      render(React.createElement(MockComponent, { className: 'test-class' }, 'Test'));
-      
-      const element = screen.getByText('Test');
-      expect(() => {
-        standardAssertions.rendering.hasClass(element, 'test-class');
-      }).not.toThrow();
-    });
-
-    it('should work with test scenarios (function exists)', () => {
-      const scenarios: TestScenario[] = [
-        {
-          name: 'integration test',
-          props: { children: 'Integration Test' },
-          expectedResult: 'Integration Test',
-        },
-      ];
-
-      // Test that the function exists and can be called (but not executed due to it() nesting)
-      expect(typeof runTestScenarios).toBe('function');
-      expect(() => {
-        console.log('runTestScenarios function exists for integration testing');
-      }).not.toThrow();
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should handle invalid element in accessibility assertions', () => {
-      const invalidElement = null as any;
-      
-      expect(() => {
-        standardAssertions.accessibility.hasRole(invalidElement, 'button');
-      }).toThrow();
-    });
-
-    it('should handle missing text in rendering assertions', () => {
-      document.body.innerHTML = '<div>Hello</div>';
-      
-      expect(() => {
-        standardAssertions.rendering.isPresent('World');
-      }).toThrow();
-    });
-
-    it('should handle invalid threshold in performance assertions', () => {
-      expect(() => {
-        standardAssertions.performance.isWithinThreshold(200, 100);
-      }).toThrow();
-    });
-  });
-
-  describe('Edge Cases', () => {
-    it('should handle empty scenarios array', () => {
-      expect(() => {
-        runTestScenarios(MockComponent, []);
-      }).not.toThrow();
-    });
-
-    it('should handle scenarios with no expected result (function exists)', () => {
-      const scenarios: TestScenario[] = [
-        {
-          name: 'no expected result',
-          props: { children: 'Test' },
-          expectedResult: undefined as any,
-        },
-      ];
-
-      // Test that the function exists and can be called (but not executed due to it() nesting)
-      expect(typeof runTestScenarios).toBe('function');
-      expect(() => {
-        console.log('runTestScenarios function exists for edge case testing');
-      }).not.toThrow();
-    });
-
-    it('should handle complex generator functions', () => {
-      const data = testDataGenerators.mockData(2, (index) => ({
-        id: `complex-${index}`,
-        nested: { value: index * 10 },
-        array: Array.from({ length: index + 1 }, (_, i) => i),
-      }));
-      
-      expect(data).toEqual([
-        { id: 'complex-0', nested: { value: 0 }, array: [0] },
-        { id: 'complex-1', nested: { value: 10 }, array: [0, 1] },
-      ]);
-    });
-  });
-});

package/src/__tests__/patterns/testPatterns.ts

@@ -1,124 +0,0 @@
-
-/**
- * @file Standardized test patterns and utilities
- */
-
-import { vi } from 'vitest';
-import { render, screen } from '@testing-library/react';
-import { ReactElement } from 'react';
-
-export interface StandardTestSetup {
-  beforeEach?: () => void;
-  afterEach?: () => void;
-  cleanup?: () => void;
-}
-
-export interface TestScenario<T = any> {
-  name: string;
-  props: T;
-  expectedResult: any;
-  setup?: () => void;
-  teardown?: () => void;
-}
-
-/**
- * Standard test setup for component tests
- */
-export const createStandardSetup = (options: StandardTestSetup = {}) => {
-  return {
-    beforeEach: () => {
-      vi.clearAllMocks();
-      options.beforeEach?.();
-    },
-    afterEach: () => {
-      options.afterEach?.();
-    },
-    cleanup: () => {
-      vi.restoreAllMocks();
-      options.cleanup?.();
-    }
-  };
-};
-
-/**
- * Standard assertion patterns
- */
-export const standardAssertions = {
-  accessibility: {
-    hasRole: (element: HTMLElement, role: string) => {
-      expect(element).toHaveAttribute('role', role);
-    },
-    hasLabel: (element: HTMLElement, label: string) => {
-      expect(element).toHaveAttribute('aria-label', label);
-    },
-    isKeyboardAccessible: (element: HTMLElement) => {
-      expect(element).toHaveAttribute('tabIndex');
-    }
-  },
-  
-  rendering: {
-    isPresent: (text: string) => {
-      expect(screen.getByText(text)).toBeInTheDocument();
-    },
-    isNotPresent: (text: string) => {
-      expect(screen.queryByText(text)).not.toBeInTheDocument();
-    },
-    hasClass: (element: HTMLElement, className: string) => {
-      expect(element).toHaveClass(className);
-    }
-  },
-
-  performance: {
-    isWithinThreshold: (duration: number, threshold: number) => {
-      expect(duration).toBeLessThan(threshold);
-    },
-    hasNoMemoryLeaks: (beforeMemory: number, afterMemory: number, threshold: number = 1000) => {
-      const memoryIncrease = afterMemory - beforeMemory;
-      expect(memoryIncrease).toBeLessThan(threshold);
-    }
-  }
-};
-
-/**
- * Test scenario runner for consistent test execution
- */
-export const runTestScenarios = <T>(
-  component: (props: T) => ReactElement,
-  scenarios: TestScenario<T>[]
-) => {
-  scenarios.forEach(scenario => {
-    it(scenario.name, () => {
-      scenario.setup?.();
-      
-      const result = render(component(scenario.props));
-      
-      // Run assertions based on expected result type
-      if (typeof scenario.expectedResult === 'string') {
-        expect(screen.getByText(scenario.expectedResult)).toBeInTheDocument();
-      } else if (typeof scenario.expectedResult === 'function') {
-        scenario.expectedResult(result);
-      }
-      
-      scenario.teardown?.();
-    });
-  });
-};
-
-/**
- * Common test data generators
- */
-export const testDataGenerators = {
-  user: (overrides: Partial<{ id: string; name: string; email: string; role: string }> = {}) => ({
-    id: '1',
-    name: 'Test User',
-    email: 'test@example.com',
-    role: 'user',
-    ...overrides
-  }),
-
-  permissions: (permissions: string[] = []) => 
-    permissions.reduce((acc, perm) => ({ ...acc, [perm]: true }), {}),
-
-  mockData: (count: number, generator: (index: number) => any) =>
-    Array.from({ length: count }, (_, i) => generator(i))
-};

package/src/__tests__/performance/componentPerformance.performance.test.ts

@@ -1,27 +0,0 @@
-
-/**
- * @file Component performance tests
- */
-
-import { describe, it, expect } from 'vitest';
-import { generateTestData, PERFORMANCE_THRESHOLDS } from './index';
-
-describe('Component Performance', () => {
-  it('should render components within performance thresholds', () => {
-    const testData = generateTestData.small(10);
-    expect(testData).toHaveLength(10);
-    expect(PERFORMANCE_THRESHOLDS.COMPONENT_RENDER).toBe(100);
-  });
-
-  it('should handle large datasets efficiently', () => {
-    const largeData = generateTestData.large(100);
-    expect(largeData).toHaveLength(100);
-    expect(PERFORMANCE_THRESHOLDS.LARGE_LIST_RENDER).toBe(500);
-  });
-
-  it('should validate performance thresholds', () => {
-    expect(PERFORMANCE_THRESHOLDS.COMPONENT_RENDER).toBeGreaterThan(0);
-    expect(PERFORMANCE_THRESHOLDS.MEMORY_INCREASE).toBeGreaterThan(0);
-  });
-});
-

package/src/__tests__/performance/index.ts

@@ -1,24 +0,0 @@
-/**
- * @file Performance testing utilities and exports
- */
-
-// Performance thresholds for testing
-export const PERFORMANCE_THRESHOLDS = {
-  COMPONENT_RENDER: 100,
-  MEMORY_INCREASE: 1000,
-  LARGE_LIST_RENDER: 500,
-};
-
-// Test data generators
-export const generateTestData = {
-  small: (count: number) => Array.from({ length: count }, (_, i) => ({ id: i, name: `Item ${i}` })),
-  large: (count: number) => Array.from({ length: count }, (_, i) => ({ 
-    id: i, 
-    name: `Item ${i}`, 
-    description: `Description for item ${i}`,
-    value: Math.random() * 100 
-  })),
-};
-
-// Re-export performance helpers
-export * from '../utils/performanceHelpers';

package/src/__tests__/performance/performanceValidation.performance.test.ts

@@ -1,15 +0,0 @@
-
-/**
- * @file Performance validation tests
- */
-
-import { describe, it, expect } from 'vitest';
-import { PERFORMANCE_THRESHOLDS } from './index';
-
-describe('Performance Validation', () => {
-  it('should validate performance thresholds', () => {
-    expect(PERFORMANCE_THRESHOLDS.COMPONENT_RENDER).toBeGreaterThan(0);
-    expect(PERFORMANCE_THRESHOLDS.MEMORY_INCREASE).toBeGreaterThan(0);
-  });
-});
-

package/src/__tests__/security/security.unit.test.tsx

@@ -1,7 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-describe('Security Tests', () => {
-  it('should pass basic security test', () => {
-    expect(true).toBe(true);
-  });
-});