@umituz/react-native-splash 1.6.3 → 1.7.1

package/src/__tests__/edge-cases/EdgeCases.test.tsx

@@ -0,0 +1,446 @@
+/**
+ * Edge Case Tests - Error Scenarios and Edge Cases
+ */
+
+import React from 'react';
+import { render, fireEvent, act, createErrorComponent } from '../utils/testUtils';
+import { SplashScreen } from '../../presentation/components/SplashScreen';
+import { useSplash } from '../../presentation/hooks/useSplash';
+
+describe('Edge Case Tests', () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  describe('Empty and Null Props', () => {
+    it('handles empty string props', () => {
+      const props = {
+        appName: '',
+        tagline: '',
+        loadingText: '',
+        visible: true,
+      };
+      
+      const { container } = render(<SplashScreen {...props} />);
+      
+      // Should render without crashing
+      expect(container).toBeTruthy();
+    });
+
+    it('handles null props', () => {
+      const props = {
+        appName: null,
+        tagline: null,
+        loadingText: null,
+        visible: true,
+      };
+      
+      const { container } = render(<SplashScreen {...props} />);
+      
+      // Should render without crashing
+      expect(container).toBeTruthy();
+    });
+
+    it('handles undefined props', () => {
+      const props = {
+        appName: undefined,
+        tagline: undefined,
+        loadingText: undefined,
+        visible: true,
+      };
+      
+      const { container } = render(<SplashScreen {...props} />);
+      
+      // Should render without crashing
+      expect(container).toBeTruthy();
+    });
+
+    it('handles missing props object', () => {
+      const { container } = render(<SplashScreen />);
+      
+      // Should render with defaults
+      expect(container).toBeTruthy();
+    });
+  });
+
+  describe('Invalid Props', () => {
+    it('handles invalid gradient colors', () => {
+      const props = {
+        appName: 'Test App',
+        gradientColors: ['invalid-color', 'another-invalid'],
+        visible: true,
+      };
+      
+      const { container } = render(<SplashScreen {...props} />);
+      
+      // Should render without crashing
+      expect(container).toBeTruthy();
+    });
+
+    it('handles empty gradient colors array', () => {
+      const props = {
+        appName: 'Test App',
+        gradientColors: [],
+        visible: true,
+      };
+      
+      const { container } = render(<SplashScreen {...props} />);
+      
+      // Should render without crashing
+      expect(container).toBeTruthy();
+    });
+
+    it('handles single color in gradient', () => {
+      const props = {
+        appName: 'Test App',
+        gradientColors: ['#FF0000'],
+        visible: true,
+      };
+      
+      const { container } = render(<SplashScreen {...props} />);
+      
+      // Should render without crashing
+      expect(container).toBeTruthy();
+    });
+
+    it('handles negative minimum display time', () => {
+      const props = {
+        appName: 'Test App',
+        minimumDisplayTime: -1000,
+        visible: true,
+      };
+      
+      const { container } = render(<SplashScreen {...props} />);
+      
+      // Should render without crashing
+      expect(container).toBeTruthy();
+    });
+
+    it('handles very large minimum display time', () => {
+      const props = {
+        appName: 'Test App',
+        minimumDisplayTime: Number.MAX_SAFE_INTEGER,
+        visible: true,
+      };
+      
+      const { container } = render(<SplashScreen {...props} />);
+      
+      // Should render without crashing
+      expect(container).toBeTruthy();
+    });
+  });
+
+  describe('Error Scenarios', () => {
+    it('handles renderLogo function throwing error', () => {
+      const props = {
+        appName: 'Test App',
+        renderLogo: createErrorComponent('Logo error'),
+        visible: true,
+      };
+      
+      const { getByText } = render(<SplashScreen {...props} />);
+      
+      // Should show error boundary fallback
+      expect(getByText('Something went wrong')).toBeTruthy();
+    });
+
+    it('handles renderContent function throwing error', () => {
+      const props = {
+        appName: 'Test App',
+        renderContent: createErrorComponent('Content error'),
+        visible: true,
+      };
+      
+      const { getByText } = render(<SplashScreen {...props} />);
+      
+      // Should show error boundary fallback
+      expect(getByText('Something went wrong')).toBeTruthy();
+    });
+
+    it('handles renderFooter function throwing error', () => {
+      const props = {
+        appName: 'Test App',
+        renderFooter: createErrorComponent('Footer error'),
+        visible: true,
+      };
+      
+      const { getByText } = render(<SplashScreen {...props} />);
+      
+      // Should show error boundary fallback
+      expect(getByText('Something went wrong')).toBeTruthy();
+    });
+
+    it('handles onReady callback throwing error', () => {
+      const props = {
+        appName: 'Test App',
+        onReady: () => {
+          throw new Error('Callback error');
+        },
+        visible: true,
+      };
+      
+      const { getByText } = render(<SplashScreen {...props} />);
+      
+      act(() => {
+        jest.advanceTimersByTime(1500);
+      });
+      
+      // Should still render without crashing
+      expect(getByText('Test App')).toBeTruthy();
+    });
+
+    it('handles async onReady callback rejection', async () => {
+      const props = {
+        appName: 'Test App',
+        onReady: async () => {
+          throw new Error('Async callback error');
+        },
+        visible: true,
+      };
+      
+      const { getByText } = render(<SplashScreen {...props} />);
+      
+      await act(async () => {
+        jest.advanceTimersByTime(1500);
+      });
+      
+      // Should still render without crashing
+      expect(getByText('Test App')).toBeTruthy();
+    });
+  });
+
+  describe('useSplash Hook Edge Cases', () => {
+    it('handles multiple markReady calls', () => {
+      const onReady = jest.fn();
+      const TestComponent = () => {
+        const { markReady } = useSplash({ onReady });
+        
+        React.useEffect(() => {
+          markReady();
+          markReady();
+          markReady();
+        }, []);
+        
+        return <div>Test</div>;
+      };
+      
+      render(<TestComponent />);
+      
+      // Should only call onReady once
+      expect(onReady).toHaveBeenCalledTimes(1);
+    });
+
+    it('handles markReady after unmount', () => {
+      const onReady = jest.fn();
+      const TestComponent = () => {
+        const { markReady } = useSplash({ onReady });
+        
+        React.useEffect(() => {
+          const timer = setTimeout(markReady, 1000);
+          return () => clearTimeout(timer);
+        }, []);
+        
+        return <div>Test</div>;
+      };
+      
+      const { unmount } = render(<TestComponent />);
+      
+      // Unmount before timer completes
+      unmount();
+      
+      act(() => {
+        jest.advanceTimersByTime(1000);
+      });
+      
+      // Should not call onReady after unmount
+      expect(onReady).not.toHaveBeenCalled();
+    });
+
+    it('handles zero minimum display time', () => {
+      const TestComponent = () => {
+        const { isVisible, markReady } = useSplash({
+          minimumDisplayTime: 0,
+          autoHide: true,
+        });
+        
+        React.useEffect(() => {
+          markReady();
+        }, []);
+        
+        return isVisible ? <div>Visible</div> : <div>Hidden</div>;
+      };
+      
+      const { getByText } = render(<TestComponent />);
+      
+      // Should hide immediately
+      expect(getByText('Hidden')).toBeTruthy();
+    });
+  });
+
+  describe('Memory and Performance Edge Cases', () => {
+    it('handles very long app names', () => {
+      const longName = 'A'.repeat(1000);
+      const props = {
+        appName: longName,
+        visible: true,
+      };
+      
+      const { getByText } = render(<SplashScreen {...props} />);
+      
+      expect(getByText(longName)).toBeTruthy();
+    });
+
+    it('handles very long taglines', () => {
+      const longTagline = 'B'.repeat(2000);
+      const props = {
+        appName: 'Test App',
+        tagline: longTagline,
+        visible: true,
+      };
+      
+      const { getByText } = render(<SplashScreen {...props} />);
+      
+      expect(getByText(longTagline)).toBeTruthy();
+    });
+
+    it('handles many gradient colors', () => {
+      const manyColors = Array.from({ length: 100 }, (_, i) => 
+        `#${i.toString(16).padStart(6, '0')}`
+      );
+      
+      const props = {
+        appName: 'Test App',
+        gradientColors: manyColors,
+        visible: true,
+      };
+      
+      const { container } = render(<SplashScreen {...props} />);
+      
+      expect(container).toBeTruthy();
+    });
+  });
+
+  describe('Component Lifecycle Edge Cases', () => {
+    it('handles rapid prop changes', () => {
+      const { rerender } = render(
+        <SplashScreen appName="App 1" visible={true} />
+      );
+      
+      // Rapidly change props
+      for (let i = 2; i <= 100; i++) {
+        rerender(<SplashScreen appName={`App ${i}`} visible={i % 2 === 0} />);
+      }
+      
+      // Should not crash
+      expect(true).toBe(true);
+    });
+
+    it('handles visibility toggle during timer', () => {
+      const onReady = jest.fn();
+      const { rerender } = render(
+        <SplashScreen
+          appName="Test App"
+          visible={true}
+          minimumDisplayTime={2000}
+          onReady={onReady}
+        />
+      );
+      
+      // Hide before timer completes
+      rerender(<SplashScreen appName="Test App" visible={false} />);
+      
+      act(() => {
+        jest.advanceTimersByTime(2000);
+      });
+      
+      // Should not call onReady when hidden
+      expect(onReady).not.toHaveBeenCalled();
+    });
+
+    it('handles component unmount during timer', () => {
+      const onReady = jest.fn();
+      const { unmount } = render(
+        <SplashScreen
+          appName="Test App"
+          visible={true}
+          minimumDisplayTime={2000}
+          onReady={onReady}
+        />
+      );
+      
+      // Unmount before timer completes
+      unmount();
+      
+      act(() => {
+        jest.advanceTimersByTime(2000);
+      });
+      
+      // Should not call onReady after unmount
+      expect(onReady).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Localization Edge Cases', () => {
+    it('handles missing localization keys', () => {
+      const props = {
+        appName: undefined,
+        tagline: undefined,
+        loadingText: undefined,
+        visible: true,
+      };
+      
+      const { container } = render(<SplashScreen {...props} />);
+      
+      // Should render with empty fallbacks
+      expect(container).toBeTruthy();
+    });
+
+    it('handles special characters in text', () => {
+      const props = {
+        appName: 'App with émojis 🎉 and spéci@l ch@rs!',
+        tagline: 'Tàglîne wïth äccénts & spëcial chars',
+        visible: true,
+      };
+      
+      const { getByText } = render(<SplashScreen {...props} />);
+      
+      expect(getByText('App with émojis 🎉 and spéci@l ch@rs!')).toBeTruthy();
+      expect(getByText('Tàglîne wïth äccénts & spëcial chars')).toBeTruthy();
+    });
+  });
+
+  describe('Theme Edge Cases', () => {
+    it('handles invalid color values', () => {
+      const props = {
+        appName: 'Test App',
+        textColor: 'not-a-color',
+        iconColor: 'also-not-a-color',
+        decorationColor: 'definitely-not-a-color',
+        visible: true,
+      };
+      
+      const { container } = render(<SplashScreen {...props} />);
+      
+      // Should render without crashing
+      expect(container).toBeTruthy();
+    });
+
+    it('handles transparent colors', () => {
+      const props = {
+        appName: 'Test App',
+        textColor: 'transparent',
+        backgroundColor: 'transparent',
+        visible: true,
+      };
+      
+      const { container } = render(<SplashScreen {...props} />);
+      
+      // Should render without crashing
+      expect(container).toBeTruthy();
+    });
+  });
+});

package/src/__tests__/integration/SplashScreen.integration.test.tsx

@@ -0,0 +1,200 @@
+/**
+ * Integration Tests - Complete Splash Screen Flow
+ */
+
+import React from 'react';
+import { render, fireEvent, act } from '../utils/testUtils';
+import { SplashScreen } from '../../presentation/components/SplashScreen';
+import { useSplash } from '../../presentation/hooks/useSplash';
+
+describe('SplashScreen Integration Tests', () => {
+  const defaultProps = {
+    appName: 'Integration Test App',
+    tagline: 'Testing complete flow',
+    visible: true,
+  };
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it('completes full splash screen lifecycle', async () => {
+    const onReady = jest.fn();
+    const props = { ...defaultProps, onReady };
+    
+    const { getByText, queryByText, rerender } = render(<SplashScreen {...props} />);
+    
+    // Initial render
+    expect(getByText('Integration Test App')).toBeTruthy();
+    expect(getByText('Testing complete flow')).toBeTruthy();
+    expect(getByText('Loading...')).toBeTruthy();
+    
+    // Wait for minimum display time
+    act(() => {
+      jest.advanceTimersByTime(1500);
+    });
+    
+    expect(onReady).toHaveBeenCalledTimes(1);
+    
+    // Hide splash screen
+    rerender(<SplashScreen {...props} visible={false} />);
+    
+    expect(queryByText('Integration Test App')).toBeFalsy();
+  });
+
+  it('handles custom render functions throughout lifecycle', () => {
+    const CustomLogo = () => <div testID="custom-logo">Custom Logo</div>;
+    const CustomContent = () => <div testID="custom-content">Custom Content</div>;
+    const CustomFooter = () => <div testID="custom-footer">Custom Footer</div>;
+    
+    const props = {
+      ...defaultProps,
+      renderLogo: () => <CustomLogo />,
+      renderContent: () => <CustomContent />,
+      renderFooter: () => <CustomFooter />,
+    };
+    
+    const { getByTestId } = render(<SplashScreen {...props} />);
+    
+    expect(getByTestId('custom-logo')).toBeTruthy();
+    expect(getByTestId('custom-content')).toBeTruthy();
+    expect(getByTestId('custom-footer')).toBeTruthy();
+  });
+
+  it('integrates with useSplash hook properly', () => {
+    const TestComponent = () => {
+      const { isVisible, markReady } = useSplash({
+        minimumDisplayTime: 1000,
+      });
+      
+      return (
+        <SplashScreen
+          {...defaultProps}
+          visible={isVisible}
+          onReady={markReady}
+        />
+      );
+    };
+    
+    const { getByText, queryByText } = render(<TestComponent />);
+    
+    expect(getByText('Integration Test App')).toBeTruthy();
+    
+    act(() => {
+      jest.advanceTimersByTime(1000);
+    });
+    
+    // Should auto-hide after markReady is called
+    act(() => {
+      jest.advanceTimersByTime(1000);
+    });
+    
+    expect(queryByText('Integration Test App')).toBeFalsy();
+  });
+
+  it('handles gradient and color theming integration', () => {
+    const props = {
+      ...defaultProps,
+      gradientColors: ['#FF0000', '#00FF00', '#0000FF'],
+      textColor: '#FFFFFF',
+      iconColor: '#FFFF00',
+      decorationColor: 'rgba(255, 255, 255, 0.1)',
+    };
+    
+    const { getByTestId } = render(<SplashScreen {...props} />);
+    
+    expect(getByTestId('linear-gradient')).toBeTruthy();
+  });
+
+  it('manages error states across components', () => {
+    const ErrorComponent = () => {
+      throw new Error('Test error');
+    };
+    
+    const props = {
+      ...defaultProps,
+      renderLogo: () => <ErrorComponent />,
+    };
+    
+    const { getByText } = render(<SplashScreen {...props} />);
+    
+    // Should show error boundary fallback
+    expect(getByText('Something went wrong')).toBeTruthy();
+  });
+
+  it('handles responsive design with safe areas', () => {
+    const props = {
+      ...defaultProps,
+      showLoading: true,
+    };
+    
+    const { getByText } = render(<SplashScreen {...props} />);
+    
+    // Should render with proper spacing for safe areas
+    expect(getByText('Integration Test App')).toBeTruthy();
+    expect(getByText('Loading...')).toBeTruthy();
+  });
+
+  it('maintains performance during complex scenarios', async () => {
+    const ComplexComponent = () => {
+      const [count, setCount] = React.useState(0);
+      
+      React.useEffect(() => {
+        const interval = setInterval(() => {
+          setCount(c => c + 1);
+        }, 100);
+        
+        return () => clearInterval(interval);
+      }, []);
+      
+      return (
+        <SplashScreen
+          {...defaultProps}
+          renderContent={() => <div>Count: {count}</div>}
+        />
+      );
+    };
+    
+    const { measureRenderTime } = require('../utils/testUtils');
+    const renderTime = await measureRenderTime(<ComplexComponent />);
+    
+    // Should render within reasonable time
+    expect(renderTime).toBeLessThan(100); // 100ms
+  });
+
+  it('handles localization integration', () => {
+    const props = {
+      appName: undefined, // Will use localization
+      tagline: undefined, // Will use localization
+      loadingText: undefined, // Will use localization
+    };
+    
+    const { getByText } = render(<SplashScreen {...props} />);
+    
+    // Should show fallback text from localization mock
+    expect(getByText('')).toBeTruthy(); // Empty fallback
+  });
+
+  it('manages memory correctly during mount/unmount cycles', () => {
+    const { trackMemoryUsage } = require('../utils/testUtils');
+    const memoryTracker = trackMemoryUsage();
+    
+    const { unmount } = render(<SplashScreen {...defaultProps} />);
+    
+    // Force garbage collection if available
+    if (global.gc) {
+      global.gc();
+    }
+    
+    const memoryIncrease = memoryTracker.getMemoryIncrease();
+    
+    // Memory increase should be minimal
+    expect(memoryIncrease).toBeLessThan(1024 * 1024); // 1MB
+    
+    unmount();
+  });
+});

package/src/__tests__/mocks/expoLinearGradient.js

@@ -0,0 +1,7 @@
+/**
+ * Expo Linear Gradient Mock
+ */
+
+module.exports = {
+  LinearGradient: ({ children, testID }) => ({ type: 'LinearGradient', props: { testID }, children }),
+};

package/src/__tests__/mocks/reactNative.js

@@ -0,0 +1,16 @@
+/**
+ * React Native Mocks
+ */
+
+const React = require('react');
+
+module.exports = {
+  View: ({ children, testID, style }) => React.createElement('View', { testID, style }, children),
+  Text: ({ children, testID, style }) => React.createElement('Text', { testID, style }, children),
+  StyleSheet: { 
+    create: jest.fn((styles) => styles),
+    flatten: jest.fn((style) => style)
+  },
+  Dimensions: { get: jest.fn(() => ({ width: 375, height: 667 })) },
+  LinearGradient: ({ children, testID, style }) => React.createElement('LinearGradient', { testID, style }, children),
+};