WellNuo/services/__tests__/api.performance.test.ts

/**
 * API Performance Tests
 *
 * Tests for API timeout handling to ensure app startup < 3 seconds
 */

describe('API Performance - getStoredUser timeout', () => {
  const PROFILE_TIMEOUT_MS = 2000; // Matches timeout in api.ts

  it('should have profile fetch timeout of 2 seconds', () => {
    // This ensures we don't block app startup waiting for slow API
    expect(PROFILE_TIMEOUT_MS).toBe(2000);
  });

  it('should leave buffer for other startup operations', () => {
    // App startup target: 3 seconds
    // Profile fetch timeout: 2 seconds
    // Buffer for other operations: 1 second
    const APP_STARTUP_TARGET = 3000;
    const otherOperationsBuffer = APP_STARTUP_TARGET - PROFILE_TIMEOUT_MS;

    expect(otherOperationsBuffer).toBeGreaterThanOrEqual(1000);
  });

  describe('Promise.race timeout behavior', () => {
    it('should resolve with faster promise when API responds quickly', async () => {
      const quickApiCall = new Promise<{ data: string }>((resolve) =>
        setTimeout(() => resolve({ data: 'user' }), 100)
      );
      const timeout = new Promise<null>((resolve) =>
        setTimeout(() => resolve(null), PROFILE_TIMEOUT_MS)
      );

      const result = await Promise.race([quickApiCall, timeout]);
      expect(result).toEqual({ data: 'user' });
    });

    it('should resolve with null when API is slow', async () => {
      const slowApiCall = new Promise<{ data: string }>((resolve) =>
        setTimeout(() => resolve({ data: 'user' }), PROFILE_TIMEOUT_MS + 500)
      );
      const timeout = new Promise<null>((resolve) =>
        setTimeout(() => resolve(null), 100) // Simulate faster timeout for testing
      );

      const result = await Promise.race([slowApiCall, timeout]);
      expect(result).toBeNull();
    });
  });
});

describe('App Startup Performance Budget', () => {
  it('should allocate time correctly for startup operations', () => {
    const TOTAL_BUDGET_MS = 3000; // 3 seconds target

    // Time budget allocation:
    const tokenCheck = 50; // SecureStore read (very fast)
    const profileFetch = 2000; // API call with timeout
    const navigationSetup = 200; // React navigation init
    const splashHide = 50; // Splash screen animation

    const totalAllocated = tokenCheck + profileFetch + navigationSetup + splashHide;

    // Should have some margin for safety
    expect(totalAllocated).toBeLessThanOrEqual(TOTAL_BUDGET_MS);

    // Verify profile fetch is the largest component (expected)
    expect(profileFetch).toBeGreaterThan(tokenCheck);
    expect(profileFetch).toBeGreaterThan(navigationSetup);
    expect(profileFetch).toBeGreaterThan(splashHide);
  });

  it('should handle worst-case scenario within budget', () => {
    const TOTAL_BUDGET_MS = 3000;

    // Worst case: API times out, fallback to local data
    const worstCaseProfileFetch = 2000; // Timeout
    const localDataFallback = 100; // Read from SecureStore

    // Even in worst case, should complete within budget
    const worstCaseTotalTime = worstCaseProfileFetch + localDataFallback;
    expect(worstCaseTotalTime).toBeLessThan(TOTAL_BUDGET_MS);
  });
});

describe('Network Resilience', () => {
  it('should fall back gracefully on network failure', () => {
    // When API fails or times out, getStoredUser should return minimal user data
    // from SecureStore (userId, email) to allow app to continue

    // This is tested by the actual implementation, but we verify the concept:
    const fallbackUser = {
      user_id: 123,
      email: 'test@example.com',
      privileges: '',
      max_role: 0,
    };

    // Fallback user should have minimal required fields
    expect(fallbackUser.user_id).toBeDefined();
    expect(fallbackUser.email).toBeDefined();

    // These fields may be empty in fallback mode
    expect(fallbackUser.privileges).toBe('');
    expect(fallbackUser.max_role).toBe(0);
  });

  it('should not log out user on network timeout', () => {
    // Network errors should NOT trigger logout
    // Only explicit 401 Unauthorized should trigger logout

    // This ensures users don't lose their session just because
    // they have slow/intermittent connectivity
  });
});