@explorins/pers-sdk-react-native 2.2.0-beta.1 → 2.2.0

package/src/__tests__/PersSDKProvider.test.tsx

@@ -0,0 +1,420 @@
+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'
+      );
+    });
+  });
+});

package/src/__tests__/__mocks__/pers-sdk-core.ts

@@ -0,0 +1,83 @@
+// Mock @explorins/pers-sdk/core
+
+export interface PersConfig {
+  apiProjectKey?: string;
+  environment?: 'staging' | 'production';
+  captureWalletEvents?: boolean;
+  authProvider?: any;
+  dpop?: {
+    enabled?: boolean;
+    cryptoProvider?: any;
+  };
+}
+
+// Create mock event emitter factory
+export 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 });
+      
+      // Replay immediately if requested
+      if (options?.replay) {
+        // No events to replay in mock
+      }
+      
+      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
+  };
+};
+
+// Mock PersSDK class
+export class PersSDK {
+  events: ReturnType<typeof createMockEventEmitter>;
+  auth: any;
+  users: any;
+  
+  constructor(_httpClient: any, _config: PersConfig) {
+    this.events = createMockEventEmitter();
+    this.auth = {
+      ensureValidToken: jest.fn().mockResolvedValue(true)
+    };
+    this.users = {
+      getCurrentUser: jest.fn().mockResolvedValue({ id: 'user-1', email: 'test@test.com' })
+    };
+  }
+  
+  restoreSession = jest.fn().mockResolvedValue(null);
+  
+  // Helper for tests to emit events
+  _mockEmitEvent(event: any) {
+    this.events.emit(event);
+  }
+}
+
+// Mock DefaultAuthProvider
+export class DefaultAuthProvider {
+  constructor(_projectKey?: string, _options?: any) {}
+}
+
+// Mock manager types
+export type AuthManager = any;
+export type UserManager = any;
+export type TokenManager = any;
+export type BusinessManager = any;
+export type CampaignManager = any;
+export type RedemptionManager = any;
+export type TransactionManager = any;
+export type PurchaseManager = any;
+export type TenantManager = any;
+export type AnalyticsManager = any;
+export type DonationManager = any;

package/src/__tests__/__mocks__/pers-shared.ts

@@ -0,0 +1,17 @@
+// Mock @explorins/pers-shared
+
+export interface UserDTO {
+  id: string;
+  email?: string;
+  firstName?: string;
+  lastName?: string;
+  walletAddress?: string;
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+export interface AdminDTO {
+  id: string;
+  email?: string;
+  role?: string;
+}

package/src/__tests__/setup.ts

@@ -0,0 +1,40 @@
+import '@testing-library/jest-dom';
+
+// Mock React Native modules
+jest.mock('react-native', () => ({
+  Platform: {
+    OS: 'ios',
+    select: jest.fn((obj) => obj.ios || obj.default)
+  },
+  AppState: {
+    addEventListener: jest.fn(() => ({
+      remove: jest.fn()
+    })),
+    currentState: 'active'
+  }
+}));
+
+// Mock AsyncStorage
+jest.mock('@react-native-async-storage/async-storage', () => ({
+  default: {
+    getItem: jest.fn(),
+    setItem: jest.fn(),
+    removeItem: jest.fn(),
+    clear: jest.fn(),
+    getAllKeys: jest.fn(() => Promise.resolve([]))
+  }
+}));
+
+// Silence console errors in tests unless explicitly needed
+const originalConsoleError = console.error;
+const originalConsoleWarn = console.warn;
+
+beforeAll(() => {
+  console.error = jest.fn();
+  console.warn = jest.fn();
+});
+
+afterAll(() => {
+  console.error = originalConsoleError;
+  console.warn = originalConsoleWarn;
+});

package/src/hooks/useRedemptions.ts

@@ -14,7 +14,7 @@ import type {
   DynamicContext,
   SortOrder
 } from '@explorins/pers-sdk';
-import type { RedemptionRedeemFilters, RedemptionFilterOptions } from '@explorins/pers-sdk/redemption';
+import type { RedemptionRedeemFilters } from '@explorins/pers-sdk/redemption';
 import type { PaginationOptions } from '@explorins/pers-sdk';
 
 // Re-export for consumers

package/src/providers/PersSDKProvider.tsx

@@ -168,7 +168,7 @@ export const PersSDKProvider: React.FC<{
           }
         }
 
-        if (event.type === 'logout_success' || event.type === 'session_restoration_failed' || event.code === 'AUTH_FAILED') {
+        if (event.type === 'logout_success' || event.type === 'session_restoration_failed') {
           setUser(null);
           setIsAuthenticated(false);
         }