@explorins/pers-sdk-react-native 2.3.6 → 2.3.8

package/src/__tests__/PersSDKProvider.test.tsx

@@ -1,420 +1,484 @@
-import React from 'react';
-import { render, act, waitFor } from '@testing-library/react';
-import '@testing-library/jest-dom';
-import { PersSDKProvider, usePersSDK, PersSDKContext } from '../providers/PersSDKProvider';
-
-// Store SDK instances for event emission
-let mockSdkInstance: any = null;
-
-// Mock the SDK core module BEFORE any imports use it
-jest.mock('@explorins/pers-sdk/core', () => {
-  const createMockEventEmitter = () => {
-    const subscribers: Array<{ callback: (event: any) => void; options?: any }> = [];
-    
-    return {
-      subscribe: jest.fn((callback: (event: any) => void, options?: any) => {
-        subscribers.push({ callback, options });
-        return () => {
-          const index = subscribers.findIndex(s => s.callback === callback);
-          if (index > -1) subscribers.splice(index, 1);
-        };
-      }),
-      emit: (event: any) => {
-        subscribers.forEach(({ callback, options }) => {
-          if (!options?.domains || options.domains.includes(event.domain)) {
-            callback(event);
-          }
-        });
-      },
-      _subscribers: subscribers
-    };
-  };
-
-  const MockPersSDK = jest.fn().mockImplementation(() => {
-    const events = createMockEventEmitter();
-    mockSdkInstance = {
-      events,
-      auth: {
-        ensureValidToken: jest.fn().mockResolvedValue(true)
-      },
-      users: {
-        getCurrentUser: jest.fn().mockResolvedValue({ id: 'refreshed-user', email: 'refreshed@test.com' })
-      },
-      restoreSession: jest.fn().mockResolvedValue(null)
-    };
-    return mockSdkInstance;
-  });
-
-  return {
-    PersSDK: MockPersSDK,
-    DefaultAuthProvider: jest.fn().mockImplementation(() => ({
-      getToken: jest.fn().mockResolvedValue('mock-token')
-    }))
-  };
-});
-
-// Mock platform-specific providers
-jest.mock('../providers/react-native-http-client', () => ({
-  ReactNativeHttpClient: jest.fn().mockImplementation(() => ({}))
-}));
-
-jest.mock('../providers/react-native-auth-provider', () => ({
-  createReactNativeAuthProvider: jest.fn().mockReturnValue({
-    getToken: jest.fn().mockResolvedValue('mock-token')
-  })
-}));
-
-jest.mock('../providers/rn-dpop-provider', () => ({
-  ReactNativeDPoPProvider: jest.fn().mockImplementation(() => ({}))
-}));
-
-// Helper component to access context
-const TestConsumer: React.FC<{ onContext: (ctx: PersSDKContext) => void }> = ({ onContext }) => {
-  const context = usePersSDK();
-  React.useEffect(() => {
-    onContext(context);
-  }, [context, onContext]);
-  return <div data-testid="consumer">Consumer</div>;
-};
-
-// Helper to emit events on the mock SDK
-const emitAuthEvent = (type: string, details: any = {}) => {
-  if (mockSdkInstance?.events) {
-    mockSdkInstance.events.emit({
-      type,
-      domain: 'authentication',
-      details
-    });
-  }
-};
-
-describe('PersSDKProvider', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    mockSdkInstance = null;
-  });
-
-  describe('initialization', () => {
-    it('should initialize with null SDK when no config provided', async () => {
-      let capturedContext: PersSDKContext | null = null;
-      
-      render(
-        <PersSDKProvider>
-          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
-        </PersSDKProvider>
-      );
-
-      await waitFor(() => {
-        expect(capturedContext).not.toBeNull();
-      });
-
-      expect(capturedContext!.sdk).toBeNull();
-      expect(capturedContext!.isInitialized).toBe(false);
-      expect(capturedContext!.isAuthenticated).toBe(false);
-      expect(capturedContext!.user).toBeNull();
-    });
-
-    it('should auto-initialize when config is provided', async () => {
-      let capturedContext: PersSDKContext | null = null;
-      
-      render(
-        <PersSDKProvider config={{ apiProjectKey: 'test-project' }}>
-          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
-        </PersSDKProvider>
-      );
-
-      await waitFor(() => {
-        expect(capturedContext?.isInitialized).toBe(true);
-      });
-
-      expect(capturedContext!.sdk).not.toBeNull();
-    });
-
-    it('should prevent multiple initializations', async () => {
-      const { PersSDK } = require('@explorins/pers-sdk/core');
-      
-      let capturedContext: PersSDKContext | null = null;
-      
-      render(
-        <PersSDKProvider config={{ apiProjectKey: 'test-project' }}>
-          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
-        </PersSDKProvider>
-      );
-
-      await waitFor(() => {
-        expect(capturedContext?.isInitialized).toBe(true);
-      });
-
-      // Try to initialize again - should be ignored
-      await act(async () => {
-        await capturedContext!.initialize({ apiProjectKey: 'different-project' });
-      });
-
-      // Should only have been called once
-      expect(PersSDK).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe('event handling', () => {
-    it('should set user on session_restored event', async () => {
-      let capturedContext: PersSDKContext | null = null;
-      const mockUser = { id: 'user-123', email: 'test@example.com' };
-      
-      render(
-        <PersSDKProvider config={{ apiProjectKey: 'test-project' }}>
-          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
-        </PersSDKProvider>
-      );
-
-      await waitFor(() => {
-        expect(capturedContext?.sdk).not.toBeNull();
-      });
-
-      // Emit session_restored event
-      await act(async () => {
-        emitAuthEvent('session_restored', { user: mockUser });
-      });
-
-      await waitFor(() => {
-        expect(capturedContext?.isAuthenticated).toBe(true);
-        expect(capturedContext?.user).toEqual(mockUser);
-      });
-    });
-
-    it('should set user on login_success event', async () => {
-      let capturedContext: PersSDKContext | null = null;
-      const mockUser = { id: 'user-456', email: 'login@example.com' };
-      
-      render(
-        <PersSDKProvider config={{ apiProjectKey: 'test-project' }}>
-          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
-        </PersSDKProvider>
-      );
-
-      await waitFor(() => {
-        expect(capturedContext?.sdk).not.toBeNull();
-      });
-
-      await act(async () => {
-        emitAuthEvent('login_success', { user: mockUser });
-      });
-
-      await waitFor(() => {
-        expect(capturedContext?.isAuthenticated).toBe(true);
-        expect(capturedContext?.user).toEqual(mockUser);
-      });
-    });
-
-    it('should clear user on logout_success event', async () => {
-      let capturedContext: PersSDKContext | null = null;
-      const mockUser = { id: 'user-789', email: 'logout@example.com' };
-      
-      render(
-        <PersSDKProvider config={{ apiProjectKey: 'test-project' }}>
-          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
-        </PersSDKProvider>
-      );
-
-      await waitFor(() => {
-        expect(capturedContext?.sdk).not.toBeNull();
-      });
-
-      // First, log in
-      await act(async () => {
-        emitAuthEvent('login_success', { user: mockUser });
-      });
-
-      await waitFor(() => {
-        expect(capturedContext?.isAuthenticated).toBe(true);
-      });
-
-      // Then logout
-      await act(async () => {
-        emitAuthEvent('logout_success', {});
-      });
-
-      await waitFor(() => {
-        expect(capturedContext?.isAuthenticated).toBe(false);
-        expect(capturedContext?.user).toBeNull();
-      });
-    });
-
-    it('should clear user on session_restoration_failed event', async () => {
-      let capturedContext: PersSDKContext | null = null;
-      
-      render(
-        <PersSDKProvider config={{ apiProjectKey: 'test-project' }}>
-          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
-        </PersSDKProvider>
-      );
-
-      await waitFor(() => {
-        expect(capturedContext?.sdk).not.toBeNull();
-      });
-
-      // Set initial authenticated state
-      await act(async () => {
-        capturedContext!.setAuthenticationState({ id: 'temp-user' } as any, true);
-      });
-
-      await waitFor(() => {
-        expect(capturedContext?.isAuthenticated).toBe(true);
-      });
-
-      // Emit session_restoration_failed
-      await act(async () => {
-        emitAuthEvent('session_restoration_failed', { error: 'Token expired' });
-      });
-
-      await waitFor(() => {
-        expect(capturedContext?.isAuthenticated).toBe(false);
-        expect(capturedContext?.user).toBeNull();
-      });
-    });
-
-    it('should NOT respond to AUTH_FAILED code (dead code was removed)', async () => {
-      // This test verifies that we no longer check for event.code === 'AUTH_FAILED'
-      // which was dead code that never triggered
-      let capturedContext: PersSDKContext | null = null;
-      const mockUser = { id: 'user-stay', email: 'stay@example.com' };
-      
-      render(
-        <PersSDKProvider config={{ apiProjectKey: 'test-project' }}>
-          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
-        </PersSDKProvider>
-      );
-
-      await waitFor(() => {
-        expect(capturedContext?.sdk).not.toBeNull();
-      });
-
-      // Log in first
-      await act(async () => {
-        emitAuthEvent('login_success', { user: mockUser });
-      });
-
-      await waitFor(() => {
-        expect(capturedContext?.isAuthenticated).toBe(true);
-      });
-
-      // Emit an event with code: 'AUTH_FAILED' - this should NOT clear user
-      // because we removed the dead code that checked for this
-      await act(async () => {
-        if (mockSdkInstance?.events) {
-          mockSdkInstance.events.emit({
-            type: 'some_other_event',
-            code: 'AUTH_FAILED', // This was the dead code path we removed
-            domain: 'authentication',
-            details: {}
-          });
-        }
-      });
-
-      // User should STILL be authenticated - the code: 'AUTH_FAILED' check is gone
-      expect(capturedContext!.isAuthenticated).toBe(true);
-      expect(capturedContext!.user).toEqual(mockUser);
-    });
-  });
-
-  describe('usePersSDK hook', () => {
-    it('should throw error when used outside provider', () => {
-      // Suppress the expected error
-      const spy = jest.spyOn(console, 'error').mockImplementation(() => {});
-      
-      const TestComponent = () => {
-        usePersSDK();
-        return null;
-      };
-
-      expect(() => render(<TestComponent />)).toThrow(
-        'usePersSDK must be used within a PersSDKProvider'
-      );
-
-      spy.mockRestore();
-    });
-  });
-
-  describe('context methods', () => {
-    it('should allow manual authentication state updates', async () => {
-      let capturedContext: PersSDKContext | null = null;
-      const mockUser = { id: 'manual-user', email: 'manual@example.com' };
-      
-      render(
-        <PersSDKProvider config={{ apiProjectKey: 'test-project' }}>
-          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
-        </PersSDKProvider>
-      );
-
-      await waitFor(() => {
-        expect(capturedContext?.isInitialized).toBe(true);
-      });
-
-      await act(async () => {
-        capturedContext!.setAuthenticationState(mockUser as any, true);
-      });
-
-      await waitFor(() => {
-        expect(capturedContext?.isAuthenticated).toBe(true);
-        expect(capturedContext?.user).toEqual(mockUser);
-      });
-    });
-
-    it('should refresh user data from SDK', async () => {
-      let capturedContext: PersSDKContext | null = null;
-      
-      render(
-        <PersSDKProvider config={{ apiProjectKey: 'test-project' }}>
-          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
-        </PersSDKProvider>
-      );
-
-      await waitFor(() => {
-        expect(capturedContext?.isInitialized).toBe(true);
-      });
-
-      await act(async () => {
-        await capturedContext!.refreshUserData();
-      });
-
-      await waitFor(() => {
-        expect(capturedContext?.user).toEqual({ id: 'refreshed-user', email: 'refreshed@test.com' });
-      });
-    });
-
-    it('should throw error when refreshUserData called before init', async () => {
-      let capturedContext: PersSDKContext | null = null;
-      
-      render(
-        <PersSDKProvider>
-          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
-        </PersSDKProvider>
-      );
-
-      await waitFor(() => {
-        expect(capturedContext).not.toBeNull();
-      });
-
-      await expect(capturedContext!.refreshUserData()).rejects.toThrow(
-        'SDK not initialized'
-      );
-    });
-
-    it('should throw error when restoreSession called before init', async () => {
-      let capturedContext: PersSDKContext | null = null;
-      
-      render(
-        <PersSDKProvider>
-          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
-        </PersSDKProvider>
-      );
-
-      await waitFor(() => {
-        expect(capturedContext).not.toBeNull();
-      });
-
-      await expect(capturedContext!.restoreSession()).rejects.toThrow(
-        'SDK not initialized'
-      );
-    });
-  });
-});
+import React from 'react';
+import { render, act, waitFor } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import { PersSDKProvider, usePersSDK, PersSDKContext } from '../providers/PersSDKProvider';
+
+// Store SDK instances for event emission
+let mockSdkInstance: any = null;
+
+// Mock the SDK core module BEFORE any imports use it
+jest.mock('@explorins/pers-sdk/core', () => {
+  const createMockEventEmitter = () => {
+    const subscribers: Array<{ callback: (event: any) => void; options?: any }> = [];
+    
+    return {
+      subscribe: jest.fn((callback: (event: any) => void, options?: any) => {
+        subscribers.push({ callback, options });
+        return () => {
+          const index = subscribers.findIndex(s => s.callback === callback);
+          if (index > -1) subscribers.splice(index, 1);
+        };
+      }),
+      emit: (event: any) => {
+        subscribers.forEach(({ callback, options }) => {
+          if (!options?.domains || options.domains.includes(event.domain)) {
+            callback(event);
+          }
+        });
+      },
+      _subscribers: subscribers
+    };
+  };
+
+  const MockPersSDK = jest.fn().mockImplementation(() => {
+    const events = createMockEventEmitter();
+    let currentLocale: string | null = null;
+    mockSdkInstance = {
+      events,
+      getLocale: jest.fn(() => currentLocale),
+      setLocale: jest.fn((next: string | null) => { currentLocale = next ? next.toLowerCase() : null; }),
+      auth: {
+        ensureValidToken: jest.fn().mockResolvedValue(true)
+      },
+      users: {
+        getCurrentUser: jest.fn().mockResolvedValue({ id: 'refreshed-user', email: 'refreshed@test.com' })
+      },
+      restoreSession: jest.fn().mockResolvedValue(null)
+    };
+    return mockSdkInstance;
+  });
+
+  return {
+    PersSDK: MockPersSDK,
+    DefaultAuthProvider: jest.fn().mockImplementation(() => ({
+      getToken: jest.fn().mockResolvedValue('mock-token')
+    }))
+  };
+});
+
+// Mock platform-specific providers
+jest.mock('../providers/react-native-http-client', () => ({
+  ReactNativeHttpClient: jest.fn().mockImplementation(() => ({}))
+}));
+
+jest.mock('../providers/react-native-auth-provider', () => ({
+  createReactNativeAuthProvider: jest.fn().mockReturnValue({
+    getToken: jest.fn().mockResolvedValue('mock-token')
+  })
+}));
+
+jest.mock('../providers/rn-dpop-provider', () => ({
+  ReactNativeDPoPProvider: jest.fn().mockImplementation(() => ({}))
+}));
+
+// Helper component to access context
+const TestConsumer: React.FC<{ onContext: (ctx: PersSDKContext) => void }> = ({ onContext }) => {
+  const context = usePersSDK();
+  React.useEffect(() => {
+    onContext(context);
+  }, [context, onContext]);
+  return <div data-testid="consumer">Consumer</div>;
+};
+
+// Helper to emit events on the mock SDK
+const emitAuthEvent = (type: string, details: any = {}) => {
+  if (mockSdkInstance?.events) {
+    mockSdkInstance.events.emit({
+      type,
+      domain: 'authentication',
+      details
+    });
+  }
+};
+
+describe('PersSDKProvider', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockSdkInstance = null;
+  });
+
+  describe('initialization', () => {
+    it('should initialize with null SDK when no config provided', async () => {
+      let capturedContext: PersSDKContext | null = null;
+      
+      render(
+        <PersSDKProvider>
+          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
+        </PersSDKProvider>
+      );
+
+      await waitFor(() => {
+        expect(capturedContext).not.toBeNull();
+      });
+
+      expect(capturedContext!.sdk).toBeNull();
+      expect(capturedContext!.isInitialized).toBe(false);
+      expect(capturedContext!.isAuthenticated).toBe(false);
+      expect(capturedContext!.user).toBeNull();
+    });
+
+    it('should auto-initialize when config is provided', async () => {
+      let capturedContext: PersSDKContext | null = null;
+      
+      render(
+        <PersSDKProvider config={{ apiProjectKey: 'test-project' }}>
+          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
+        </PersSDKProvider>
+      );
+
+      await waitFor(() => {
+        expect(capturedContext?.isInitialized).toBe(true);
+      });
+
+      expect(capturedContext!.sdk).not.toBeNull();
+    });
+
+    it('should prevent multiple initializations', async () => {
+      const { PersSDK } = require('@explorins/pers-sdk/core');
+      
+      let capturedContext: PersSDKContext | null = null;
+      
+      render(
+        <PersSDKProvider config={{ apiProjectKey: 'test-project' }}>
+          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
+        </PersSDKProvider>
+      );
+
+      await waitFor(() => {
+        expect(capturedContext?.isInitialized).toBe(true);
+      });
+
+      // Try to initialize again - should be ignored
+      await act(async () => {
+        await capturedContext!.initialize({ apiProjectKey: 'different-project' });
+      });
+
+      // Should only have been called once
+      expect(PersSDK).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('locale', () => {
+    it('exposes a null locale until one is set', async () => {
+      let capturedContext: PersSDKContext | null = null;
+
+      render(
+        <PersSDKProvider config={{ apiProjectKey: 'test-project' }}>
+          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
+        </PersSDKProvider>
+      );
+
+      await waitFor(() => expect(capturedContext?.isInitialized).toBe(true));
+      expect(capturedContext!.locale).toBeNull();
+    });
+
+    it('passes the configured locale through to the SDK config', async () => {
+      const { PersSDK } = require('@explorins/pers-sdk/core');
+
+      render(
+        <PersSDKProvider config={{ apiProjectKey: 'test-project', locale: 'auto' }}>
+          <div />
+        </PersSDKProvider>
+      );
+
+      await waitFor(() => expect(PersSDK).toHaveBeenCalledTimes(1));
+      expect(PersSDK.mock.calls[0][1]).toMatchObject({ locale: 'auto' });
+    });
+
+    it('setLocale updates the SDK and the context so consumers re-render', async () => {
+      let capturedContext: PersSDKContext | null = null;
+
+      render(
+        <PersSDKProvider config={{ apiProjectKey: 'test-project' }}>
+          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
+        </PersSDKProvider>
+      );
+
+      await waitFor(() => expect(capturedContext?.isInitialized).toBe(true));
+
+      act(() => { capturedContext!.setLocale('ar-SA'); });
+
+      await waitFor(() => expect(capturedContext?.locale).toBe('ar-sa'));
+      expect(mockSdkInstance.setLocale).toHaveBeenCalledWith('ar-SA');
+
+      act(() => { capturedContext!.setLocale(null); });
+      await waitFor(() => expect(capturedContext?.locale).toBeNull());
+    });
+
+    it('setLocale throws before the SDK is initialized', async () => {
+      let capturedContext: PersSDKContext | null = null;
+
+      render(
+        <PersSDKProvider>
+          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
+        </PersSDKProvider>
+      );
+
+      await waitFor(() => expect(capturedContext).not.toBeNull());
+      expect(() => capturedContext!.setLocale('de')).toThrow('SDK not initialized');
+    });
+  });
+
+  describe('event handling', () => {
+    it('should set user on session_restored event', async () => {
+      let capturedContext: PersSDKContext | null = null;
+      const mockUser = { id: 'user-123', email: 'test@example.com' };
+      
+      render(
+        <PersSDKProvider config={{ apiProjectKey: 'test-project' }}>
+          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
+        </PersSDKProvider>
+      );
+
+      await waitFor(() => {
+        expect(capturedContext?.sdk).not.toBeNull();
+      });
+
+      // Emit session_restored event
+      await act(async () => {
+        emitAuthEvent('session_restored', { user: mockUser });
+      });
+
+      await waitFor(() => {
+        expect(capturedContext?.isAuthenticated).toBe(true);
+        expect(capturedContext?.user).toEqual(mockUser);
+      });
+    });
+
+    it('should set user on login_success event', async () => {
+      let capturedContext: PersSDKContext | null = null;
+      const mockUser = { id: 'user-456', email: 'login@example.com' };
+      
+      render(
+        <PersSDKProvider config={{ apiProjectKey: 'test-project' }}>
+          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
+        </PersSDKProvider>
+      );
+
+      await waitFor(() => {
+        expect(capturedContext?.sdk).not.toBeNull();
+      });
+
+      await act(async () => {
+        emitAuthEvent('login_success', { user: mockUser });
+      });
+
+      await waitFor(() => {
+        expect(capturedContext?.isAuthenticated).toBe(true);
+        expect(capturedContext?.user).toEqual(mockUser);
+      });
+    });
+
+    it('should clear user on logout_success event', async () => {
+      let capturedContext: PersSDKContext | null = null;
+      const mockUser = { id: 'user-789', email: 'logout@example.com' };
+      
+      render(
+        <PersSDKProvider config={{ apiProjectKey: 'test-project' }}>
+          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
+        </PersSDKProvider>
+      );
+
+      await waitFor(() => {
+        expect(capturedContext?.sdk).not.toBeNull();
+      });
+
+      // First, log in
+      await act(async () => {
+        emitAuthEvent('login_success', { user: mockUser });
+      });
+
+      await waitFor(() => {
+        expect(capturedContext?.isAuthenticated).toBe(true);
+      });
+
+      // Then logout
+      await act(async () => {
+        emitAuthEvent('logout_success', {});
+      });
+
+      await waitFor(() => {
+        expect(capturedContext?.isAuthenticated).toBe(false);
+        expect(capturedContext?.user).toBeNull();
+      });
+    });
+
+    it('should clear user on session_restoration_failed event', async () => {
+      let capturedContext: PersSDKContext | null = null;
+      
+      render(
+        <PersSDKProvider config={{ apiProjectKey: 'test-project' }}>
+          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
+        </PersSDKProvider>
+      );
+
+      await waitFor(() => {
+        expect(capturedContext?.sdk).not.toBeNull();
+      });
+
+      // Set initial authenticated state
+      await act(async () => {
+        capturedContext!.setAuthenticationState({ id: 'temp-user' } as any, true);
+      });
+
+      await waitFor(() => {
+        expect(capturedContext?.isAuthenticated).toBe(true);
+      });
+
+      // Emit session_restoration_failed
+      await act(async () => {
+        emitAuthEvent('session_restoration_failed', { error: 'Token expired' });
+      });
+
+      await waitFor(() => {
+        expect(capturedContext?.isAuthenticated).toBe(false);
+        expect(capturedContext?.user).toBeNull();
+      });
+    });
+
+    it('should NOT respond to AUTH_FAILED code (dead code was removed)', async () => {
+      // This test verifies that we no longer check for event.code === 'AUTH_FAILED'
+      // which was dead code that never triggered
+      let capturedContext: PersSDKContext | null = null;
+      const mockUser = { id: 'user-stay', email: 'stay@example.com' };
+      
+      render(
+        <PersSDKProvider config={{ apiProjectKey: 'test-project' }}>
+          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
+        </PersSDKProvider>
+      );
+
+      await waitFor(() => {
+        expect(capturedContext?.sdk).not.toBeNull();
+      });
+
+      // Log in first
+      await act(async () => {
+        emitAuthEvent('login_success', { user: mockUser });
+      });
+
+      await waitFor(() => {
+        expect(capturedContext?.isAuthenticated).toBe(true);
+      });
+
+      // Emit an event with code: 'AUTH_FAILED' - this should NOT clear user
+      // because we removed the dead code that checked for this
+      await act(async () => {
+        if (mockSdkInstance?.events) {
+          mockSdkInstance.events.emit({
+            type: 'some_other_event',
+            code: 'AUTH_FAILED', // This was the dead code path we removed
+            domain: 'authentication',
+            details: {}
+          });
+        }
+      });
+
+      // User should STILL be authenticated - the code: 'AUTH_FAILED' check is gone
+      expect(capturedContext!.isAuthenticated).toBe(true);
+      expect(capturedContext!.user).toEqual(mockUser);
+    });
+  });
+
+  describe('usePersSDK hook', () => {
+    it('should throw error when used outside provider', () => {
+      // Suppress the expected error
+      const spy = jest.spyOn(console, 'error').mockImplementation(() => {});
+      
+      const TestComponent = () => {
+        usePersSDK();
+        return null;
+      };
+
+      expect(() => render(<TestComponent />)).toThrow(
+        'usePersSDK must be used within a PersSDKProvider'
+      );
+
+      spy.mockRestore();
+    });
+  });
+
+  describe('context methods', () => {
+    it('should allow manual authentication state updates', async () => {
+      let capturedContext: PersSDKContext | null = null;
+      const mockUser = { id: 'manual-user', email: 'manual@example.com' };
+      
+      render(
+        <PersSDKProvider config={{ apiProjectKey: 'test-project' }}>
+          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
+        </PersSDKProvider>
+      );
+
+      await waitFor(() => {
+        expect(capturedContext?.isInitialized).toBe(true);
+      });
+
+      await act(async () => {
+        capturedContext!.setAuthenticationState(mockUser as any, true);
+      });
+
+      await waitFor(() => {
+        expect(capturedContext?.isAuthenticated).toBe(true);
+        expect(capturedContext?.user).toEqual(mockUser);
+      });
+    });
+
+    it('should refresh user data from SDK', async () => {
+      let capturedContext: PersSDKContext | null = null;
+      
+      render(
+        <PersSDKProvider config={{ apiProjectKey: 'test-project' }}>
+          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
+        </PersSDKProvider>
+      );
+
+      await waitFor(() => {
+        expect(capturedContext?.isInitialized).toBe(true);
+      });
+
+      await act(async () => {
+        await capturedContext!.refreshUserData();
+      });
+
+      await waitFor(() => {
+        expect(capturedContext?.user).toEqual({ id: 'refreshed-user', email: 'refreshed@test.com' });
+      });
+    });
+
+    it('should throw error when refreshUserData called before init', async () => {
+      let capturedContext: PersSDKContext | null = null;
+      
+      render(
+        <PersSDKProvider>
+          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
+        </PersSDKProvider>
+      );
+
+      await waitFor(() => {
+        expect(capturedContext).not.toBeNull();
+      });
+
+      await expect(capturedContext!.refreshUserData()).rejects.toThrow(
+        'SDK not initialized'
+      );
+    });
+
+    it('should throw error when restoreSession called before init', async () => {
+      let capturedContext: PersSDKContext | null = null;
+      
+      render(
+        <PersSDKProvider>
+          <TestConsumer onContext={(ctx) => { capturedContext = ctx; }} />
+        </PersSDKProvider>
+      );
+
+      await waitFor(() => {
+        expect(capturedContext).not.toBeNull();
+      });
+
+      await expect(capturedContext!.restoreSession()).rejects.toThrow(
+        'SDK not initialized'
+      );
+    });
+  });
+});