@jmruthers/pace-core 0.5.118 → 0.5.120

package/src/hooks/__tests__/useSessionRestoration.unit.test.tsx

@@ -0,0 +1,371 @@
+/**
+ * @file useSessionRestoration Hook Unit Tests
+ * @package @jmruthers/pace-core
+ * @module Hooks/__tests__/useSessionRestoration
+ * @since 0.1.0
+ * 
+ * Comprehensive tests for the useSessionRestoration hook covering all critical functionality.
+ */
+
+import { renderHook, act, waitFor } from '@testing-library/react';
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import React from 'react';
+import { useSessionRestoration } from '../useSessionRestoration';
+import { AuthServiceContext } from '../../providers/services/AuthServiceProvider';
+import type { SessionRestorationState } from '../../types/auth';
+
+const SESSION_RESTORATION_TIMEOUT_MS = 5000;
+
+describe('useSessionRestoration', () => {
+  let mockContext: { sessionRestoration: SessionRestorationState };
+
+  const createWrapper = (contextValue: typeof mockContext) => {
+    return ({ children }: { children: React.ReactNode }) => (
+      <AuthServiceContext.Provider value={contextValue as any}>
+        {children}
+      </AuthServiceContext.Provider>
+    );
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.useFakeTimers();
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+    
+    mockContext = {
+      sessionRestoration: {
+        isRestoring: false,
+        restorationComplete: false,
+        restorationError: null,
+      },
+    };
+  });
+
+  afterEach(() => {
+    vi.clearAllTimers();
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
+  describe('Provider Context', () => {
+    it('throws error when used outside AuthServiceProvider', () => {
+      // Suppress React error boundary warnings
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      expect(() => {
+        renderHook(() => useSessionRestoration());
+      }).toThrow('useSessionRestoration must be used within AuthServiceProvider');
+
+      // Restore console.error after assertion
+      consoleErrorSpy.mockRestore();
+    });
+
+    it('returns session restoration state from context', () => {
+      const wrapper = createWrapper(mockContext);
+      const { result } = renderHook(() => useSessionRestoration(), { wrapper });
+
+      expect(result.current.isRestoring).toBe(false);
+      expect(result.current.restorationComplete).toBe(false);
+      expect(result.current.restorationError).toBeNull();
+      expect(result.current.hasTimedOut).toBe(false);
+      expect(result.current.timeoutMs).toBe(SESSION_RESTORATION_TIMEOUT_MS);
+    });
+  });
+
+  describe('Initial State', () => {
+    it('returns false for hasTimedOut when not restoring', () => {
+      mockContext.sessionRestoration = {
+        isRestoring: false,
+        restorationComplete: false,
+        restorationError: null,
+      };
+
+      const wrapper = createWrapper(mockContext);
+      const { result } = renderHook(() => useSessionRestoration(), { wrapper });
+
+      expect(result.current.hasTimedOut).toBe(false);
+    });
+
+    it('returns timeout duration', () => {
+      const wrapper = createWrapper(mockContext);
+      const { result } = renderHook(() => useSessionRestoration(), { wrapper });
+
+      expect(result.current.timeoutMs).toBe(SESSION_RESTORATION_TIMEOUT_MS);
+    });
+  });
+
+  describe('Session Restoration Active', () => {
+    it('sets hasTimedOut to false when restoration starts', () => {
+      mockContext.sessionRestoration = {
+        isRestoring: true,
+        restorationComplete: false,
+        restorationError: null,
+      };
+
+      const wrapper = createWrapper(mockContext);
+      const { result } = renderHook(() => useSessionRestoration(), { wrapper });
+
+      expect(result.current.hasTimedOut).toBe(false);
+    });
+
+    it('sets timeout when restoration is active', async () => {
+      mockContext.sessionRestoration = {
+        isRestoring: true,
+        restorationComplete: false,
+        restorationError: null,
+      };
+
+      const wrapper = createWrapper(mockContext);
+      const { result } = renderHook(() => useSessionRestoration(), { wrapper });
+
+      expect(result.current.hasTimedOut).toBe(false);
+
+      // Advance time past timeout
+      await act(async () => {
+        vi.advanceTimersByTime(SESSION_RESTORATION_TIMEOUT_MS + 100);
+      });
+
+      // With fake timers, the timeout should fire immediately
+      expect(result.current.hasTimedOut).toBe(true);
+
+      expect(console.warn).toHaveBeenCalledWith(
+        '[useSessionRestoration] Session restoration timed out'
+      );
+    });
+
+    it('does not set timeout when restoration is complete', () => {
+      mockContext.sessionRestoration = {
+        isRestoring: true,
+        restorationComplete: true,
+        restorationError: null,
+      };
+
+      const wrapper = createWrapper(mockContext);
+      const { result } = renderHook(() => useSessionRestoration(), { wrapper });
+
+      expect(result.current.hasTimedOut).toBe(false);
+
+      // Advance time past timeout
+      act(() => {
+        vi.advanceTimersByTime(SESSION_RESTORATION_TIMEOUT_MS);
+      });
+
+      // Should still be false because restoration is complete
+      expect(result.current.hasTimedOut).toBe(false);
+      expect(console.warn).not.toHaveBeenCalled();
+    });
+
+    it('does not set timeout when restoration has error', () => {
+      mockContext.sessionRestoration = {
+        isRestoring: true,
+        restorationComplete: false,
+        restorationError: new Error('Restoration failed'),
+      };
+
+      const wrapper = createWrapper(mockContext);
+      const { result } = renderHook(() => useSessionRestoration(), { wrapper });
+
+      expect(result.current.hasTimedOut).toBe(false);
+
+      // Advance time past timeout
+      act(() => {
+        vi.advanceTimersByTime(SESSION_RESTORATION_TIMEOUT_MS);
+      });
+
+      // Should still be false because there's an error
+      expect(result.current.hasTimedOut).toBe(false);
+      expect(console.warn).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Timeout Cleanup', () => {
+    it('clears timeout when restoration completes before timeout', () => {
+      mockContext.sessionRestoration = {
+        isRestoring: true,
+        restorationComplete: false,
+        restorationError: null,
+      };
+
+      const wrapper = createWrapper(mockContext);
+      const { result, rerender } = renderHook(() => useSessionRestoration(), { wrapper });
+
+      // Start restoration
+      expect(result.current.hasTimedOut).toBe(false);
+
+      // Complete restoration before timeout
+      act(() => {
+        mockContext.sessionRestoration = {
+          isRestoring: false,
+          restorationComplete: true,
+          restorationError: null,
+        };
+        rerender();
+      });
+
+      // Advance time past timeout
+      act(() => {
+        vi.advanceTimersByTime(SESSION_RESTORATION_TIMEOUT_MS);
+      });
+
+      // Should not have timed out
+      expect(result.current.hasTimedOut).toBe(false);
+      expect(console.warn).not.toHaveBeenCalled();
+    });
+
+    it('clears timeout when restoration error occurs before timeout', () => {
+      mockContext.sessionRestoration = {
+        isRestoring: true,
+        restorationComplete: false,
+        restorationError: null,
+      };
+
+      const wrapper = createWrapper(mockContext);
+      const { result, rerender } = renderHook(() => useSessionRestoration(), { wrapper });
+
+      // Start restoration
+      expect(result.current.hasTimedOut).toBe(false);
+
+      // Error occurs before timeout
+      act(() => {
+        mockContext.sessionRestoration = {
+          isRestoring: false,
+          restorationComplete: false,
+          restorationError: new Error('Restoration error'),
+        };
+        rerender();
+      });
+
+      // Advance time past timeout
+      act(() => {
+        vi.advanceTimersByTime(SESSION_RESTORATION_TIMEOUT_MS);
+      });
+
+      // Should not have timed out
+      expect(result.current.hasTimedOut).toBe(false);
+      expect(console.warn).not.toHaveBeenCalled();
+    });
+
+    it('clears timeout on unmount', () => {
+      mockContext.sessionRestoration = {
+        isRestoring: true,
+        restorationComplete: false,
+        restorationError: null,
+      };
+
+      const wrapper = createWrapper(mockContext);
+      const { unmount } = renderHook(() => useSessionRestoration(), { wrapper });
+
+      // Unmount before timeout
+      act(() => {
+        unmount();
+      });
+
+      // Advance time past timeout
+      act(() => {
+        vi.advanceTimersByTime(SESSION_RESTORATION_TIMEOUT_MS);
+      });
+
+      // Should not log warning after unmount
+      expect(console.warn).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('State Updates', () => {
+    it('updates when restoration state changes', () => {
+      mockContext.sessionRestoration = {
+        isRestoring: false,
+        restorationComplete: false,
+        restorationError: null,
+      };
+
+      const wrapper = createWrapper(mockContext);
+      const { result, rerender } = renderHook(() => useSessionRestoration(), { wrapper });
+
+      expect(result.current.isRestoring).toBe(false);
+
+      // Update restoration state
+      act(() => {
+        mockContext.sessionRestoration = {
+          isRestoring: true,
+          restorationComplete: false,
+          restorationError: null,
+        };
+        rerender();
+      });
+
+      expect(result.current.isRestoring).toBe(true);
+    });
+
+    it('resets hasTimedOut when restoration state changes', () => {
+      mockContext.sessionRestoration = {
+        isRestoring: true,
+        restorationComplete: false,
+        restorationError: null,
+      };
+
+      const wrapper = createWrapper(mockContext);
+      const { result, rerender } = renderHook(() => useSessionRestoration(), { wrapper });
+
+      // Trigger timeout - advance timers
+      act(() => {
+        vi.advanceTimersByTime(SESSION_RESTORATION_TIMEOUT_MS + 100);
+      });
+
+      // Verify timeout occurred (with fake timers, setTimeout fires immediately)
+      expect(result.current.hasTimedOut).toBe(true);
+
+      // Reset restoration state
+      act(() => {
+        mockContext.sessionRestoration = {
+          isRestoring: false,
+          restorationComplete: false,
+          restorationError: null,
+        };
+        rerender();
+      });
+
+      // Should reset hasTimedOut immediately when state changes
+      // The useEffect will detect the change and clear the timeout, resetting hasTimedOut
+      expect(result.current.hasTimedOut).toBe(false);
+    });
+  });
+
+  describe('Memoization', () => {
+    it('memoizes return value based on sessionRestoration and hasTimedOut', () => {
+      mockContext.sessionRestoration = {
+        isRestoring: false,
+        restorationComplete: false,
+        restorationError: null,
+      };
+
+      const wrapper = createWrapper(mockContext);
+      const { result, rerender } = renderHook(() => useSessionRestoration(), { wrapper });
+
+      const firstResult = result.current;
+
+      // Rerender without state change
+      rerender();
+
+      // Should be same object reference (memoized)
+      expect(result.current).toBe(firstResult);
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('returns restoration error from context', () => {
+      const mockError = new Error('Session restoration failed');
+      mockContext.sessionRestoration = {
+        isRestoring: false,
+        restorationComplete: false,
+        restorationError: mockError,
+      };
+
+      const wrapper = createWrapper(mockContext);
+      const { result } = renderHook(() => useSessionRestoration(), { wrapper });
+
+      expect(result.current.restorationError).toEqual(mockError);
+      expect(result.current.hasTimedOut).toBe(false);
+    });
+  });
+});
+