@squad-sports/react-native 1.3.1

package/src/__tests__/EventProcessor.test.ts

@@ -0,0 +1,241 @@
+import { EventProcessor } from '../realtime/EventProcessor';
+
+// Mock the dynamic import for react-native-sse
+jest.mock('react-native-sse', () => {
+  throw new Error('not available');
+});
+
+describe('EventProcessor', () => {
+  beforeEach(() => {
+    EventProcessor.reset();
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    EventProcessor.reset();
+    jest.useRealTimers();
+  });
+
+  // --- Singleton ---
+
+  describe('singleton pattern', () => {
+    test('shared returns the same instance', () => {
+      const a = EventProcessor.shared;
+      const b = EventProcessor.shared;
+      expect(a).toBe(b);
+    });
+
+    test('reset clears the instance, next shared creates new one', () => {
+      const a = EventProcessor.shared;
+      EventProcessor.reset();
+      const b = EventProcessor.shared;
+      expect(a).not.toBe(b);
+    });
+  });
+
+  // --- Connect / disconnect lifecycle ---
+
+  describe('connect/disconnect lifecycle', () => {
+    test('connect does nothing without apiClient', async () => {
+      const ep = EventProcessor.shared;
+      ep.setShouldAllowEvents(true);
+      // No apiClient set, should not throw
+      await ep.connect();
+      expect(ep.getConnectionQuality()).toBe('disconnected');
+    });
+
+    test('connect does nothing when events not allowed', async () => {
+      const ep = EventProcessor.shared;
+      ep.setApiClient({ currentToken: 'tok', baseUrl: 'http://x' } as any);
+      // allowEvents defaults to false
+      await ep.connect();
+      expect(ep.getConnectionQuality()).toBe('disconnected');
+    });
+
+    test('disconnect sets quality to disconnected', () => {
+      const ep = EventProcessor.shared;
+      ep.disconnect();
+      expect(ep.getConnectionQuality()).toBe('disconnected');
+    });
+
+    test('setShouldAllowEvents(false) calls disconnect', () => {
+      const ep = EventProcessor.shared;
+      const spy = jest.spyOn(ep, 'disconnect');
+      ep.setShouldAllowEvents(false);
+      expect(spy).toHaveBeenCalled();
+    });
+  });
+
+  // --- Event deduplication ---
+
+  describe('event deduplication', () => {
+    test('same event key is ignored on second emit', () => {
+      const ep = EventProcessor.shared;
+      const handler = jest.fn();
+      ep.emitter.on('test-event', handler);
+
+      // Access private processEvent via bracket notation
+      (ep as any).connectionQuality = 'good';
+      (ep as any).processEvent('test-event', { id: 1 });
+      (ep as any).processEvent('test-event', { id: 1 });
+
+      expect(handler).toHaveBeenCalledTimes(1);
+    });
+
+    test('different data for same type emits twice', () => {
+      const ep = EventProcessor.shared;
+      const handler = jest.fn();
+      ep.emitter.on('test-event', handler);
+
+      (ep as any).connectionQuality = 'good';
+      (ep as any).processEvent('test-event', { id: 1 });
+      (ep as any).processEvent('test-event', { id: 2 });
+
+      expect(handler).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  // --- Dedupe TTL pruning ---
+
+  describe('dedupe TTL pruning', () => {
+    test('entries older than 1 hour are pruned on 100th insertion', () => {
+      const ep = EventProcessor.shared;
+      (ep as any).connectionQuality = 'good';
+
+      const realNow = Date.now;
+
+      // Insert 99 events at "old" time (2 hours ago)
+      const twoHoursAgo = Date.now() - 2 * 60 * 60 * 1000;
+      Date.now = jest.fn(() => twoHoursAgo);
+
+      for (let i = 0; i < 99; i++) {
+        (ep as any).processEvent('prune-test', { i });
+      }
+      expect((ep as any).processedEventIds.size).toBe(99);
+
+      // 100th insertion at current time triggers pruning
+      Date.now = jest.fn(() => realNow());
+      (ep as any).processEvent('prune-test', { i: 99 });
+
+      // All old entries should have been pruned, only the 100th remains
+      expect((ep as any).processedEventIds.size).toBe(1);
+
+      Date.now = realNow;
+    });
+  });
+
+  // --- Dedupe hard cap ---
+
+  describe('dedupe hard cap at 5000', () => {
+    test('trims to 3000 entries when exceeding 5000', () => {
+      const ep = EventProcessor.shared;
+      (ep as any).connectionQuality = 'good';
+
+      // Pre-fill the map with 5001 entries
+      const map = (ep as any).processedEventIds as Map<string, number>;
+      for (let i = 0; i < 5001; i++) {
+        map.set(`key-${i}`, Date.now() + i);
+      }
+      // Set insertionCount to something that won't trigger the 100-modulo prune
+      (ep as any).insertionCount = 50;
+
+      // processEvent will check hard cap after inserting
+      (ep as any).processEvent('cap-trigger', { cap: true });
+
+      // Should have been trimmed: 5001 + 1 = 5002 > 5000, trim to 3000
+      expect(map.size).toBeLessThanOrEqual(3001); // 3000 kept + 1 new
+    });
+  });
+
+  // --- Event buffering when connection quality is 'poor' ---
+
+  describe('event buffering', () => {
+    test('buffers events when connection quality is poor', () => {
+      const ep = EventProcessor.shared;
+      const handler = jest.fn();
+      ep.emitter.on('buffered-event', handler);
+
+      (ep as any).connectionQuality = 'poor';
+      (ep as any).processEvent('buffered-event', { msg: 'hello' });
+
+      // Should NOT have been emitted directly
+      expect(handler).not.toHaveBeenCalled();
+      // Should be in the buffer
+      expect((ep as any).eventBuffer.length).toBe(1);
+      expect((ep as any).eventBuffer[0].type).toBe('buffered-event');
+    });
+
+    test('buffer flush emits all buffered events', () => {
+      const ep = EventProcessor.shared;
+      const handler = jest.fn();
+      ep.emitter.on('buffered-event', handler);
+
+      (ep as any).connectionQuality = 'poor';
+      (ep as any).processEvent('buffered-event', { msg: 'a' });
+      (ep as any).processEvent('buffered-event', { msg: 'b' });
+
+      // Now flush
+      (ep as any).flushEventBuffer();
+
+      // Both should be emitted
+      // Note: second event was deduplicated since data differs, so both are buffered
+      expect(handler).toHaveBeenCalledTimes(2);
+      expect((ep as any).eventBuffer.length).toBe(0);
+    });
+  });
+
+  // --- Reconnect with exponential backoff ---
+
+  describe('reconnection', () => {
+    test('scheduleReconnect uses exponential backoff', () => {
+      const ep = EventProcessor.shared;
+      const connectSpy = jest.spyOn(ep, 'connect').mockResolvedValue();
+
+      // First reconnect: ~1000ms (INITIAL_BACKOFF * 2^0)
+      (ep as any).scheduleReconnect();
+      expect((ep as any).reconnectAttempts).toBe(1);
+
+      // Advance past the max possible delay (1000 + 10% jitter = 1100)
+      jest.advanceTimersByTime(1200);
+      expect(connectSpy).toHaveBeenCalledTimes(1);
+
+      // Second reconnect: ~2000ms
+      (ep as any).scheduleReconnect();
+      expect((ep as any).reconnectAttempts).toBe(2);
+
+      jest.advanceTimersByTime(2500);
+      expect(connectSpy).toHaveBeenCalledTimes(2);
+
+      connectSpy.mockRestore();
+    });
+
+    test('max reconnect attempts emits connection:maxRetriesReached', () => {
+      const ep = EventProcessor.shared;
+      const maxRetriesHandler = jest.fn();
+      ep.emitter.on('connection:maxRetriesReached', maxRetriesHandler);
+
+      // Set attempts to max
+      (ep as any).reconnectAttempts = 10; // MAX_RECONNECT_ATTEMPTS
+
+      (ep as any).scheduleReconnect();
+
+      expect(maxRetriesHandler).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  // --- Connection-specific message forwarding ---
+
+  describe('connection message forwarding', () => {
+    test('connection:ID:message:create also emits message:create', () => {
+      const ep = EventProcessor.shared;
+      (ep as any).connectionQuality = 'good';
+
+      const globalHandler = jest.fn();
+      ep.emitter.on('message:create', globalHandler);
+
+      (ep as any).processEvent('connection:abc:message:create', { text: 'hi' });
+
+      expect(globalHandler).toHaveBeenCalledWith({ text: 'hi' });
+    });
+  });
+});

package/src/__tests__/PushNotificationHandler.test.ts

@@ -0,0 +1,91 @@
+import { PushNotificationHandler } from '../realtime/PushNotificationHandler';
+
+describe('PushNotificationHandler', () => {
+  describe('handleNotification', () => {
+    test('routes message notification to Messaging screen', () => {
+      const action = PushNotificationHandler.handleNotification({
+        type: 'message',
+        connectionId: 'conn-123',
+      } as any);
+      expect(action).toEqual({
+        screen: 'Messaging',
+        params: { connectionId: 'conn-123' },
+      });
+    });
+
+    test('routes message with snake_case key', () => {
+      const action = PushNotificationHandler.handleNotification({
+        type: 'message',
+        connection_id: 'conn-456',
+      } as any);
+      expect(action).toEqual({
+        screen: 'Messaging',
+        params: { connectionId: 'conn-456' },
+      });
+    });
+
+    test('routes squad_invite to Home', () => {
+      const action = PushNotificationHandler.handleNotification({
+        type: 'squad_invite',
+      } as any);
+      expect(action).toEqual({ screen: 'Home' });
+    });
+
+    test('routes poll notification to PollResponse', () => {
+      const action = PushNotificationHandler.handleNotification({
+        type: 'poll',
+        pollId: 'poll-789',
+      } as any);
+      expect(action).toEqual({
+        screen: 'PollResponse',
+        params: { pollId: 'poll-789' },
+      });
+    });
+
+    test('routes freestyle to Home', () => {
+      const action = PushNotificationHandler.handleNotification({
+        type: 'freestyle',
+      } as any);
+      expect(action).toEqual({ screen: 'Home' });
+    });
+
+    test('routes reaction with connectionId to Messaging', () => {
+      const action = PushNotificationHandler.handleNotification({
+        type: 'reaction',
+        connectionId: 'conn-abc',
+      } as any);
+      expect(action).toEqual({
+        screen: 'Messaging',
+        params: { connectionId: 'conn-abc' },
+      });
+    });
+
+    test('routes reaction without connectionId to Home', () => {
+      const action = PushNotificationHandler.handleNotification({
+        type: 'reaction',
+      } as any);
+      expect(action).toEqual({ screen: 'Home' });
+    });
+
+    test('incoming_call returns null (handled by overlay)', () => {
+      const action = PushNotificationHandler.handleNotification({
+        type: 'incoming_call',
+        callerId: 'caller-1',
+        title: 'Hey!',
+      } as any);
+      expect(action).toBeNull();
+    });
+
+    test('unknown type returns null', () => {
+      const action = PushNotificationHandler.handleNotification({
+        type: 'unknown_type',
+      } as any);
+      expect(action).toBeNull();
+    });
+
+    test('missing type returns null', () => {
+      const action = PushNotificationHandler.handleNotification({} as any);
+      expect(action).toBeNull();
+    });
+  });
+});

package/src/__tests__/SecureStorage.test.ts

@@ -0,0 +1,62 @@
+/**
+ * SecureStorageAdapter tests
+ *
+ * Verifies that sensitive auth keys are routed through expo-secure-store
+ * and non-sensitive keys fall through to AsyncStorage.
+ *
+ * Since SecureStorageAdapter uses dynamic import(), we test by verifying
+ * the SECURE_KEYS set directly and testing the routing logic.
+ */
+import { SecureStorageAdapter } from '../storage/SecureStorage';
+
+// Access the private static SECURE_KEYS for verification
+const EXPECTED_SECURE_KEYS = [
+  'SQUAD_SDK_AUTH_TOKEN',
+  'SQUAD_SDK_AUTH_USER_ID',
+  'SQUAD_SDK_AUTH_EMAIL',
+  'SQUAD_SDK_AUTH_PHONE',
+  'SQUAD_SDK_AUTH_COMMUNITY_ID',
+  'SQUAD_SDK_AUTH_PARTNER_ID',
+];
+
+describe('SecureStorageAdapter', () => {
+  test('SECURE_KEYS includes all auth-sensitive keys', () => {
+    // Access the private static set via a test instance
+    // We verify the set contents by checking isSecureKey behavior
+    const adapter = new SecureStorageAdapter();
+
+    // Use the private isSecureKey method via the routing behavior
+    // If a key is in SECURE_KEYS, setItem will try secureStore first.
+    // We can verify by checking the static set directly.
+    const secureKeys = (SecureStorageAdapter as any).SECURE_KEYS as Set<string>;
+
+    for (const key of EXPECTED_SECURE_KEYS) {
+      expect(secureKeys.has(key)).toBe(true);
+    }
+  });
+
+  test('SQUAD_SDK_AUTH_COMMUNITY_ID is a secure key (regression)', () => {
+    const secureKeys = (SecureStorageAdapter as any).SECURE_KEYS as Set<string>;
+    expect(secureKeys.has('SQUAD_SDK_AUTH_COMMUNITY_ID')).toBe(true);
+  });
+
+  test('non-auth keys are NOT in SECURE_KEYS', () => {
+    const secureKeys = (SecureStorageAdapter as any).SECURE_KEYS as Set<string>;
+
+    expect(secureKeys.has('SQUAD_SDK_PENDING_NAVIGATION')).toBe(false);
+    expect(secureKeys.has('SQUAD_SDK_ATTEMPTED_VERIFICATIONS')).toBe(false);
+    expect(secureKeys.has('SOME_RANDOM_KEY')).toBe(false);
+  });
+
+  test('SECURE_KEYS has exactly 6 entries', () => {
+    const secureKeys = (SecureStorageAdapter as any).SECURE_KEYS as Set<string>;
+    expect(secureKeys.size).toBe(6);
+  });
+
+  test('adapter implements StorageAdapter interface', () => {
+    const adapter = new SecureStorageAdapter();
+    expect(typeof adapter.getItem).toBe('function');
+    expect(typeof adapter.setItem).toBe('function');
+    expect(typeof adapter.removeItem).toBe('function');
+  });
+});

package/src/__tests__/SquadSportsSDK.test.ts

@@ -0,0 +1,278 @@
+import { SquadSportsSDK } from '../SquadSportsSDK';
+import {
+  SquadApiClient,
+  SessionManager,
+  SSOManager,
+  PartnerAuthManager,
+  TokenStorage,
+  InMemoryStorage,
+  AnalyticsTracker,
+  Logger,
+  NexusPartnerRegistry,
+} from '@squad-sports/core';
+
+// --- Mock all @squad-sports/core classes ---
+
+jest.mock('@squad-sports/core', () => {
+  const mockApiClient = {
+    currentToken: null as string | null,
+    baseUrl: 'https://api.test.com',
+    updateAccessToken: jest.fn(),
+    clearAuthState: jest.fn(),
+    cancelAllRequests: jest.fn(),
+    clearAllCaches: jest.fn(),
+    setSilentReAuth: jest.fn(),
+  };
+
+  const mockSessionManager = {
+    validateSession: jest.fn().mockResolvedValue(true),
+  };
+
+  const mockSSOManager = {
+    authenticate: jest.fn().mockResolvedValue({ success: true }),
+    authenticateWithToken: jest.fn().mockResolvedValue({ success: true }),
+  };
+
+  const mockPartnerAuthManager = {
+    syncUser: jest.fn().mockResolvedValue({ success: true, userId: 'user-123' }),
+  };
+
+  const mockTokenStorage = {
+    getAccessToken: jest.fn().mockResolvedValue(null),
+    getUserId: jest.fn().mockResolvedValue(null),
+    getCommunityId: jest.fn().mockResolvedValue(null),
+    setCommunityId: jest.fn().mockResolvedValue(undefined),
+    setPartnerId: jest.fn().mockResolvedValue(undefined),
+    clearAll: jest.fn().mockResolvedValue(undefined),
+  };
+
+  const mockAnalytics = {
+    configure: jest.fn(),
+    track: jest.fn(),
+    setUserId: jest.fn(),
+    destroy: jest.fn(),
+  };
+
+  const mockLogger = {
+    configure: jest.fn(),
+    setUserId: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+  };
+
+  return {
+    SquadApiClient: jest.fn(() => mockApiClient),
+    SessionManager: jest.fn(() => mockSessionManager),
+    SSOManager: jest.fn(() => mockSSOManager),
+    PartnerAuthManager: jest.fn(() => mockPartnerAuthManager),
+    TokenStorage: jest.fn(() => mockTokenStorage),
+    InMemoryStorage: jest.fn(),
+    NexusPartnerRegistry: {
+      resolve: jest.fn().mockResolvedValue({
+        apiKey: 'resolved-key',
+        environment: 'staging',
+        partnerAuth: {
+          partnerId: 'test-partner',
+          communityId: 'test-community',
+        },
+      }),
+    },
+    AnalyticsTracker: {
+      shared: mockAnalytics,
+    },
+    Logger: {
+      shared: mockLogger,
+    },
+    isPartnerConfig: jest.fn((c: any) => !!c.partnerId && !c.apiKey),
+    getApiBaseUrl: jest.fn(() => 'https://api.test.com'),
+  };
+});
+
+// Helper to get mock instances from the module mock
+function getMockApiClient() {
+  return (SquadApiClient as unknown as jest.Mock).mock.results[0]?.value ?? (SquadApiClient as any)();
+}
+
+function getMockTokenStorage() {
+  return (TokenStorage as unknown as jest.Mock).mock.results[0]?.value ?? (TokenStorage as any)();
+}
+
+function getMockPartnerAuth() {
+  return (PartnerAuthManager as unknown as jest.Mock).mock.results[0]?.value ?? (PartnerAuthManager as any)();
+}
+
+describe('SquadSportsSDK', () => {
+  beforeEach(() => {
+    // Reset the singleton
+    if (SquadSportsSDK.isInitialized) {
+      SquadSportsSDK.reset();
+    }
+
+    // Clear all mock call data
+    jest.clearAllMocks();
+
+    // Reset mock defaults
+    const tokenStorage = (TokenStorage as any)();
+    tokenStorage.getAccessToken.mockResolvedValue(null);
+    tokenStorage.getUserId.mockResolvedValue(null);
+    tokenStorage.getCommunityId.mockResolvedValue(null);
+
+    const apiClient = (SquadApiClient as any)();
+    apiClient.currentToken = null;
+
+    const partnerAuth = (PartnerAuthManager as any)();
+    partnerAuth.syncUser.mockResolvedValue({ success: true, userId: 'user-123' });
+  });
+
+  // --- setup() ---
+
+  describe('setup()', () => {
+    const fullConfig = {
+      apiKey: 'test-key',
+      environment: 'staging' as const,
+      partnerAuth: {
+        partnerId: 'test-partner',
+        communityId: 'test-community',
+        userData: { externalId: 'ext-1', email: 'test@example.com' },
+      },
+    };
+
+    test('configures analytics and logger', async () => {
+      await SquadSportsSDK.setup(fullConfig);
+
+      expect(AnalyticsTracker.shared.configure).toHaveBeenCalledWith(
+        expect.objectContaining({
+          partnerId: 'test-partner',
+          enabled: true,
+        }),
+      );
+      expect(Logger.shared.configure).toHaveBeenCalledWith(
+        expect.objectContaining({
+          partnerId: 'test-partner',
+          environment: 'staging',
+        }),
+      );
+    });
+
+    test('restores session and tracks session_restored', async () => {
+      const tokenStorage = (TokenStorage as any)();
+      tokenStorage.getAccessToken.mockResolvedValue('saved-token');
+      tokenStorage.getUserId.mockResolvedValue('user-42');
+
+      const apiClient = (SquadApiClient as any)();
+      // After restoreSession sets the token, currentToken should return it
+      apiClient.updateAccessToken.mockImplementation((t: string) => {
+        apiClient.currentToken = t;
+      });
+
+      await SquadSportsSDK.setup(fullConfig);
+
+      expect(AnalyticsTracker.shared.track).toHaveBeenCalledWith('session_restored');
+      expect(AnalyticsTracker.shared.setUserId).toHaveBeenCalledWith('user-42');
+      expect(Logger.shared.setUserId).toHaveBeenCalledWith('user-42');
+    });
+
+    test('partner sync success tracks partner_sync_success', async () => {
+      await SquadSportsSDK.setup(fullConfig);
+
+      expect(AnalyticsTracker.shared.track).toHaveBeenCalledWith(
+        'partner_sync_success',
+        expect.objectContaining({ partnerId: 'test-partner' }),
+      );
+    });
+
+    test('partner sync failure tracks partner_sync_failed', async () => {
+      const partnerAuth = (PartnerAuthManager as any)();
+      partnerAuth.syncUser.mockResolvedValue({ success: false });
+
+      await SquadSportsSDK.setup(fullConfig);
+
+      expect(AnalyticsTracker.shared.track).toHaveBeenCalledWith(
+        'partner_sync_failed',
+        expect.objectContaining({ partnerId: 'test-partner' }),
+      );
+    });
+
+    test('wires silent re-auth on apiClient when userData provided', async () => {
+      await SquadSportsSDK.setup(fullConfig);
+
+      const apiClient = (SquadApiClient as any)();
+      expect(apiClient.setSilentReAuth).toHaveBeenCalledWith(expect.any(Function));
+    });
+
+    test('does not wire silent re-auth when no userData', async () => {
+      const configNoUserData = {
+        apiKey: 'test-key',
+        environment: 'staging' as const,
+      };
+
+      await SquadSportsSDK.setup(configNoUserData);
+
+      const apiClient = (SquadApiClient as any)();
+      expect(apiClient.setSilentReAuth).not.toHaveBeenCalled();
+    });
+
+    test('tracks sdk_initialized at the end', async () => {
+      await SquadSportsSDK.setup(fullConfig);
+
+      expect(AnalyticsTracker.shared.track).toHaveBeenCalledWith(
+        'sdk_initialized',
+        expect.objectContaining({
+          partnerId: 'test-partner',
+          environment: 'staging',
+        }),
+      );
+    });
+  });
+
+  // --- reset() ---
+
+  describe('reset()', () => {
+    test('destroys analytics and clears caches', async () => {
+      const config = { apiKey: 'k', environment: 'staging' as const };
+      await SquadSportsSDK.setup(config);
+
+      jest.clearAllMocks();
+      SquadSportsSDK.reset();
+
+      const apiClient = (SquadApiClient as any)();
+      expect(apiClient.cancelAllRequests).toHaveBeenCalled();
+      expect(apiClient.clearAllCaches).toHaveBeenCalled();
+      expect(AnalyticsTracker.shared.destroy).toHaveBeenCalled();
+      expect(SquadSportsSDK.isInitialized).toBe(false);
+    });
+  });
+
+  // --- initialize() ---
+
+  describe('initialize()', () => {
+    test('prevents double-init and returns existing instance', () => {
+      const config = { apiKey: 'k', environment: 'staging' as const };
+      const warnSpy = jest.spyOn(console, 'warn').mockImplementation();
+
+      const first = SquadSportsSDK.initialize(config);
+      const second = SquadSportsSDK.initialize(config);
+
+      expect(first).toBe(second);
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Already initialized'),
+      );
+
+      warnSpy.mockRestore();
+    });
+  });
+
+  // --- shared ---
+
+  describe('shared', () => {
+    test('throws when not initialized', () => {
+      expect(() => SquadSportsSDK.shared).toThrow('Not initialized');
+    });
+
+    test('returns instance when initialized', () => {
+      const config = { apiKey: 'k', environment: 'staging' as const };
+      SquadSportsSDK.initialize(config);
+      expect(SquadSportsSDK.shared).toBeDefined();
+    });
+  });
+});