@jmruthers/pace-core 0.2.7 → 0.4.1

package/src/components/__tests__/ErrorTesting.enhanced.test.tsx

@@ -1,455 +0,0 @@
-/**
- * @file Enhanced Error Testing Suite
- * @package @jmruthers/pace-core
- * @module Components/Tests/ErrorTesting
- * @since 0.4.0
- * 
- * Comprehensive error testing patterns and utilities for all components
- */
-
-import { errorTestingUtils, TestErrorBoundary } from '../../__tests__/ErrorTesting.enhanced.test';
-import React from 'react';
-import { render, screen, fireEvent, waitFor } from '@testing-library/react';
-import userEvent from '@testing-library/user-event';
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import '@testing-library/jest-dom';
-
-// Test error boundary component
-class TestErrorBoundary extends React.Component<
-  {
-    children: React.ReactNode;
-    onError?: (error: Error, errorInfo: React.ErrorInfo) => void;
-    fallback?: React.ReactNode;
-  },
-  { hasError: boolean; error?: Error }
-> {
-  constructor(props: any) {
-    super(props);
-    this.state = { hasError: false };
-  }
-
-  static getDerivedStateFromError(error: Error) {
-    return { hasError: true, error };
-  }
-
-  componentDidCatch(error: Error, errorInfo: React.ErrorInfo) {
-    this.props.onError?.(error, errorInfo);
-  }
-
-  componentDidUpdate(prevProps: any) {
-    // Reset error boundary when children change
-    if (prevProps.children !== this.props.children && this.state.hasError) {
-      this.setState({ hasError: false, error: undefined });
-    }
-  }
-
-  render() {
-    if (this.state.hasError) {
-      return this.props.fallback || (
-        <div data-testid="error-boundary">
-          Error: {this.state.error?.message}
-        </div>
-      );
-    }
-
-    return this.props.children;
-  }
-}
-
-// Error throwing components for testing
-const ThrowErrorComponent = ({ message = 'Test error' }: { message?: string }) => {
-  throw new Error(message);
-};
-
-const AsyncErrorComponent = ({ shouldFail = false }: { shouldFail?: boolean }) => {
-  const [error, setError] = React.useState<Error | null>(null);
-
-  React.useEffect(() => {
-    if (shouldFail) {
-      setError(new Error('Async error occurred'));
-    }
-  }, [shouldFail]);
-
-  if (error) {
-    throw error;
-  }
-
-  return <div>Async component loaded</div>;
-};
-
-const PromiseErrorComponent = ({ shouldFail = false }: { shouldFail?: boolean }) => {
-  const [error, setError] = React.useState<Error | null>(null);
-
-  React.useEffect(() => {
-    if (shouldFail) {
-      Promise.reject(new Error('Promise error')).catch(setError);
-    }
-  }, [shouldFail]);
-
-  if (error) {
-    throw error;
-  }
-
-  return <div>Promise component loaded</div>;
-};
-
-// Test utilities
-export const errorTestingUtils = {
-  // Suppress console errors during error boundary tests
-  suppressConsoleErrors: () => {
-    const originalError = console.error;
-    const originalWarn = console.warn;
-    
-    console.error = vi.fn();
-    console.warn = vi.fn();
-    
-    return () => {
-      console.error = originalError;
-      console.warn = originalWarn;
-    };
-  },
-
-  // Create a component that throws errors on specific interactions
-  createErrorThrowingComponent: (errorMessage: string, trigger: 'mount' | 'click' | 'input' = 'mount') => {
-    const ErrorThrowingComponent = () => {
-      const [shouldThrow, setShouldThrow] = React.useState(trigger === 'mount');
-      const [error, setError] = React.useState<Error | null>(null);
-
-      React.useEffect(() => {
-        if (trigger === 'mount' && shouldThrow) {
-          throw new Error(errorMessage);
-        }
-      }, [shouldThrow]);
-
-      const handleClick = () => {
-        if (trigger === 'click') {
-          try {
-            throw new Error(errorMessage);
-          } catch (err) {
-            setError(err as Error);
-          }
-        }
-      };
-
-      const handleInput = () => {
-        if (trigger === 'input') {
-          try {
-            throw new Error(errorMessage);
-          } catch (err) {
-            setError(err as Error);
-          }
-        }
-      };
-
-      if (error) {
-        return <div data-testid="error-display">Error: {error.message}</div>;
-      }
-
-      return (
-        <div>
-          <button onClick={handleClick} data-testid="error-button">
-            Click to throw error
-          </button>
-          <input 
-            onChange={handleInput} 
-            data-testid="error-input" 
-            placeholder="Type to throw error"
-          />
-        </div>
-      );
-    };
-
-    return ErrorThrowingComponent;
-  },
-
-  // Test error recovery
-  testErrorRecovery: async (Component: React.ComponentType, errorProps: any, recoveryProps: any) => {
-    const onError = vi.fn();
-    
-    const { rerender } = render(
-      <TestErrorBoundary onError={onError}>
-        <Component {...errorProps} />
-      </TestErrorBoundary>
-    );
-
-    // Wait for error to be caught
-    await waitFor(() => {
-      expect(screen.getByTestId('error-boundary')).toBeInTheDocument();
-    });
-
-    expect(onError).toHaveBeenCalled();
-
-    // Test recovery by rerendering with different props
-    rerender(
-      <TestErrorBoundary onError={onError}>
-        <Component {...recoveryProps} />
-      </TestErrorBoundary>
-    );
-
-    // Should recover and render normally
-    expect(screen.queryByTestId('error-boundary')).not.toBeInTheDocument();
-  }
-};
-
-describe('Enhanced Error Testing Patterns', () => {
-  const user = userEvent.setup();
-  let restoreConsole: (() => void) | null = null;
-
-  beforeEach(() => {
-    restoreConsole = errorTestingUtils.suppressConsoleErrors();
-  });
-
-  afterEach(() => {
-    if (restoreConsole) {
-      restoreConsole();
-    }
-    vi.clearAllMocks();
-  });
-
-  describe('Error Boundary Testing', () => {
-    it('should catch synchronous errors', () => {
-      const onError = vi.fn();
-      
-      render(
-        <TestErrorBoundary onError={onError}>
-          <ThrowErrorComponent message="Sync error" />
-        </TestErrorBoundary>
-      );
-
-      expect(screen.getByTestId('error-boundary')).toBeInTheDocument();
-      expect(screen.getByText('Error: Sync error')).toBeInTheDocument();
-      expect(onError).toHaveBeenCalledWith(
-        expect.any(Error),
-        expect.any(Object)
-      );
-    });
-
-    it('should catch async errors in useEffect', async () => {
-      const onError = vi.fn();
-      
-      render(
-        <TestErrorBoundary onError={onError}>
-          <AsyncErrorComponent shouldFail={true} />
-        </TestErrorBoundary>
-      );
-
-      await waitFor(() => {
-        expect(screen.getByTestId('error-boundary')).toBeInTheDocument();
-      });
-
-      expect(screen.getByText('Error: Async error occurred')).toBeInTheDocument();
-      expect(onError).toHaveBeenCalled();
-    });
-
-    it('should catch promise rejection errors', async () => {
-      const onError = vi.fn();
-      
-      render(
-        <TestErrorBoundary onError={onError}>
-          <PromiseErrorComponent shouldFail={true} />
-        </TestErrorBoundary>
-      );
-
-      await waitFor(() => {
-        expect(screen.getByTestId('error-boundary')).toBeInTheDocument();
-      });
-
-      expect(screen.getByText('Error: Promise error')).toBeInTheDocument();
-      expect(onError).toHaveBeenCalled();
-    });
-
-    it('should render custom fallback UI', () => {
-      const customFallback = <div data-testid="custom-error">Custom Error UI</div>;
-      
-      render(
-        <TestErrorBoundary fallback={customFallback}>
-          <ThrowErrorComponent />
-        </TestErrorBoundary>
-      );
-
-      expect(screen.getByTestId('custom-error')).toBeInTheDocument();
-      expect(screen.queryByTestId('error-boundary')).not.toBeInTheDocument();
-    });
-  });
-
-  describe('Interactive Error Testing', () => {
-    it('should catch errors on user interactions', async () => {
-      const ErrorComponent = errorTestingUtils.createErrorThrowingComponent(
-        'Click error',
-        'click'
-      );
-      const onError = vi.fn();
-
-      render(
-        <TestErrorBoundary onError={onError}>
-          <ErrorComponent />
-        </TestErrorBoundary>
-      );
-
-      // Initially no error
-      expect(screen.queryByTestId('error-boundary')).not.toBeInTheDocument();
-
-      // Trigger error by clicking
-      await user.click(screen.getByTestId('error-button'));
-
-      await waitFor(() => {
-        expect(screen.getByTestId('error-display')).toBeInTheDocument();
-      });
-
-      expect(screen.getByText('Error: Click error')).toBeInTheDocument();
-    });
-
-    it('should catch errors on input events', async () => {
-      const ErrorComponent = errorTestingUtils.createErrorThrowingComponent(
-        'Input error',
-        'input'
-      );
-      const onError = vi.fn();
-
-      render(
-        <TestErrorBoundary onError={onError}>
-          <ErrorComponent />
-        </TestErrorBoundary>
-      );
-
-      // Trigger error by typing
-      await user.type(screen.getByTestId('error-input'), 'test');
-
-      await waitFor(() => {
-        expect(screen.getByTestId('error-display')).toBeInTheDocument();
-      });
-
-      expect(screen.getByText('Error: Input error')).toBeInTheDocument();
-    });
-  });
-
-  describe('Error Recovery Testing', () => {
-    it('should recover from errors when props change', async () => {
-      const TestComponent = ({ shouldError }: { shouldError: boolean }) => {
-        if (shouldError) {
-          throw new Error('Component error');
-        }
-        return <div data-testid="normal-content">Normal content</div>;
-      };
-
-      await errorTestingUtils.testErrorRecovery(
-        TestComponent,
-        { shouldError: true },
-        { shouldError: false }
-      );
-
-      expect(screen.getByTestId('normal-content')).toBeInTheDocument();
-    });
-  });
-
-  describe('Error Types Testing', () => {
-    it('should handle TypeError', () => {
-      const TypeErrorComponent = () => {
-        throw new TypeError('Type error occurred');
-      };
-
-      render(
-        <TestErrorBoundary>
-          <TypeErrorComponent />
-        </TestErrorBoundary>
-      );
-
-      expect(screen.getByText('Error: Type error occurred')).toBeInTheDocument();
-    });
-
-    it('should handle ReferenceError', () => {
-      const ReferenceErrorComponent = () => {
-        throw new ReferenceError('Reference error occurred');
-      };
-
-      render(
-        <TestErrorBoundary>
-          <ReferenceErrorComponent />
-        </TestErrorBoundary>
-      );
-
-      expect(screen.getByText('Error: Reference error occurred')).toBeInTheDocument();
-    });
-
-    it('should handle custom error classes', () => {
-      class CustomError extends Error {
-        constructor(message: string) {
-          super(message);
-          this.name = 'CustomError';
-        }
-      }
-
-      const CustomErrorComponent = () => {
-        throw new CustomError('Custom error occurred');
-      };
-
-      render(
-        <TestErrorBoundary>
-          <CustomErrorComponent />
-        </TestErrorBoundary>
-      );
-
-      expect(screen.getByText('Error: Custom error occurred')).toBeInTheDocument();
-    });
-  });
-
-  describe('Error Boundary Edge Cases', () => {
-    it('should handle multiple error boundaries', () => {
-      const onError1 = vi.fn();
-      const onError2 = vi.fn();
-
-      render(
-        <div>
-          <TestErrorBoundary onError={onError1}>
-            <ThrowErrorComponent message="Error 1" />
-          </TestErrorBoundary>
-          <TestErrorBoundary onError={onError2}>
-            <div>Normal content</div>
-          </TestErrorBoundary>
-        </div>
-      );
-
-      expect(screen.getByText('Error: Error 1')).toBeInTheDocument();
-      expect(screen.getByText('Normal content')).toBeInTheDocument();
-      expect(onError1).toHaveBeenCalled();
-      expect(onError2).not.toHaveBeenCalled();
-    });
-
-    it('should handle nested error boundaries', () => {
-      const onOuterError = vi.fn();
-      const onInnerError = vi.fn();
-
-      render(
-        <TestErrorBoundary onError={onOuterError}>
-          <div>Outer content</div>
-          <TestErrorBoundary onError={onInnerError}>
-            <ThrowErrorComponent message="Inner error" />
-          </TestErrorBoundary>
-        </TestErrorBoundary>
-      );
-
-      expect(screen.getByText('Error: Inner error')).toBeInTheDocument();
-      expect(screen.getByText('Outer content')).toBeInTheDocument();
-      expect(onInnerError).toHaveBeenCalled();
-      expect(onOuterError).not.toHaveBeenCalled();
-    });
-
-    it('should handle errors in error boundary fallback', () => {
-      const FailingFallback = () => {
-        throw new Error('Fallback error');
-      };
-
-      // This should not cause infinite loops - expect the error to be thrown
-      expect(() => {
-        render(
-          <TestErrorBoundary fallback={<FailingFallback />}>
-            <ThrowErrorComponent message="Original error" />
-          </TestErrorBoundary>
-        );
-      }).toThrow('Fallback error');
-    });
-  });
-});
-
-// Export utilities for use in other test files
-export { TestErrorBoundary, ThrowErrorComponent, AsyncErrorComponent, PromiseErrorComponent };