jest-setup.ts

import '@testing-library/react-native/extend-expect';

// Mock react-native-safe-area-context — its source build reads StyleSheet at import time,
// which explodes in suites that stub react-native with a minimal factory (e.g. navigation tests).
jest.mock('react-native-safe-area-context', () => {
  const React = require('react');

  const SafeAreaView = ({ children }: any) => React.createElement(React.Fragment, null, children);

  return {
    SafeAreaView,
    SafeAreaProvider: ({ children }: any) => children,
    useSafeAreaInsets: jest.fn(() => ({ top: 0, bottom: 0, left: 0, right: 0 })),
    useSafeAreaFrame: jest.fn(() => ({ x: 0, y: 0, width: 375, height: 667 })),
    initialWindowMetrics: {
      insets: { top: 0, bottom: 0, left: 0, right: 0 },
      frame: { x: 0, y: 0, width: 375, height: 667 },
    },
  };
});

// Mock @sentry/react-native — native module (RNSentry) is unavailable in Jest
jest.mock('@sentry/react-native', () => ({
  captureException: jest.fn(),
  captureMessage: jest.fn(),
  init: jest.fn(),
  wrap: jest.fn((fn: any) => fn),
  withScope: jest.fn((cb: any) => cb({ setExtra: jest.fn(), setTag: jest.fn() })),
  setUser: jest.fn(),
  setTag: jest.fn(),
  setExtra: jest.fn(),
  addBreadcrumb: jest.fn(),
  configureScope: jest.fn(),
  ReactNavigationInstrumentation: jest.fn(),
  ReactNativeTracing: jest.fn(),
}));

// react-hook form setup for testing
// @ts-ignore
global.window = {};
// @ts-ignore
global.window = global;

// Mock react-native Platform globally
// Must include `default` export because react-native/index.js and processColor.js
// access Platform via require('./Libraries/Utilities/Platform').default
jest.mock('react-native/Libraries/Utilities/Platform', () => {
  const platform = {
    OS: 'ios' as const,
    select: jest.fn((obj: any) => obj.ios ?? obj.native ?? obj.default),
    Version: 14,
    constants: {
      osVersion: '14.0',
      interfaceIdiom: 'phone',
      isTesting: true,
      reactNativeVersion: { major: 0, minor: 76, patch: 0 },
      systemName: 'iOS',
    },
    isTesting: true,
    isPad: false,
    isTV: false,
    isVision: false,
    isMacCatalyst: false,
  };
  return {
    __esModule: true,
    default: platform,
    ...platform,
  };
});

// Mock expo-audio globally
jest.mock('expo-audio', () => ({
  createAudioPlayer: jest.fn(() => ({
    play: jest.fn(),
    pause: jest.fn(),
    remove: jest.fn(),
    replace: jest.fn(),
    seekTo: jest.fn(),
    playing: false,
    paused: false,
    isLoaded: true,
    duration: 0,
    currentTime: 0,
    volume: 1,
    muted: false,
    loop: false,
    playbackRate: 1,
    id: 1,
    isAudioSamplingSupported: false,
    isBuffering: false,
    shouldCorrectPitch: false,
  })),
  useAudioPlayer: jest.fn(),
  useAudioPlayerStatus: jest.fn(),
  setAudioModeAsync: jest.fn(),
  setIsAudioActiveAsync: jest.fn(),
}));

// Mock the host component names function to prevent testing library errors
// Check if the internal module exists (for pre-v13 compatibility)
try {
  require.resolve('@testing-library/react-native/build/helpers/host-component-names');
  // If the internal module exists, mock it (pre-v13)
  jest.mock('@testing-library/react-native/build/helpers/host-component-names', () => ({
    getHostComponentNames: jest.fn(() => ({
      text: 'Text',
      view: 'View',
      scrollView: 'ScrollView',
      touchable: 'TouchableOpacity',
      switch: 'Switch',
      textInput: 'TextInput',
    })),
    configureHostComponentNamesIfNeeded: jest.fn(),
    isHostText: jest.fn((element) => element?.type === 'Text' || element?._fiber?.type === 'Text' || (typeof element === 'object' && element?.props?.children && typeof element.props.children === 'string')),
    isHostTextInput: jest.fn((element) => element?.type === 'TextInput' || element?._fiber?.type === 'TextInput'),
    isHostImage: jest.fn((element) => element?.type === 'Image' || element?._fiber?.type === 'Image'),
    isHostSwitch: jest.fn((element) => element?.type === 'Switch' || element?._fiber?.type === 'Switch'),
    isHostScrollView: jest.fn((element) => element?.type === 'ScrollView' || element?._fiber?.type === 'ScrollView'),
    isHostModal: jest.fn((element) => element?.type === 'Modal' || element?._fiber?.type === 'Modal'),
  }));
} catch (error) {
  // Module doesn't exist (v13+), try to use the public API if available
  try {
    const { configureHostComponentNames } = require('@testing-library/react-native');
    // Configure host component names using the public API (v13+)
    if (configureHostComponentNames) {
      configureHostComponentNames({
        text: 'Text',
        view: 'View',
        scrollView: 'ScrollView',
        touchable: 'TouchableOpacity',
        switch: 'Switch',
        textInput: 'TextInput',
      });
    }
  } catch (publicApiError) {
    // If neither internal nor public API is available, log a warning but continue
    console.warn('Unable to configure host component names for @testing-library/react-native. Tests may fail if they rely on component type detection.');
  }
}

// Global mocks for common problematic modules
jest.mock('@notifee/react-native', () => {
  const mockNotifee = {
    createChannel: jest.fn().mockResolvedValue('mock-channel-id'),
    displayNotification: jest.fn().mockResolvedValue('mock-notification-id'),
    requestPermission: jest.fn().mockResolvedValue({ authorizationStatus: 1 }),
    getPermissionSettings: jest.fn().mockResolvedValue({ authorizationStatus: 1 }),
    setBadgeCount: jest.fn().mockResolvedValue(undefined),
    decrementBadgeCount: jest.fn().mockResolvedValue(undefined),
    incrementBadgeCount: jest.fn().mockResolvedValue(undefined),
    getBadgeCount: jest.fn().mockResolvedValue(0),
    cancelNotification: jest.fn().mockResolvedValue(undefined),
    cancelAllNotifications: jest.fn().mockResolvedValue(undefined),
    onForegroundEvent: jest.fn(),
    onBackgroundEvent: jest.fn(),
    getInitialNotification: jest.fn().mockResolvedValue(null),
    getDisplayedNotifications: jest.fn().mockResolvedValue([]),
    getTriggerNotifications: jest.fn().mockResolvedValue([]),
    openBatteryOptimizationSettings: jest.fn().mockResolvedValue(undefined),
    openNotificationSettings: jest.fn().mockResolvedValue(undefined),
    openPowerManagerSettings: jest.fn().mockResolvedValue(undefined),
    getPowerManagerInfo: jest.fn().mockResolvedValue({}),
    isBatteryOptimizationEnabled: jest.fn().mockResolvedValue(false),
    registerForegroundService: jest.fn().mockResolvedValue(undefined),
    stopForegroundService: jest.fn().mockResolvedValue(undefined),
  };

  const AndroidImportance = {
    DEFAULT: 'default',
    HIGH: 'high',
    LOW: 'low',
    MIN: 'min',
    NONE: 'none',
    UNSPECIFIED: 'unspecified',
  };

  const AndroidForegroundServiceType = {
    FOREGROUND_SERVICE_TYPE_MICROPHONE: 128,
    FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE: 16,
  };

  return {
    __esModule: true,
    default: mockNotifee,
    AndroidImportance,
    AndroidForegroundServiceType,
  };
});

jest.mock('livekit-client', () => ({
  Room: jest.fn().mockImplementation(() => ({
    on: jest.fn(),
    off: jest.fn(),
    connect: jest.fn().mockResolvedValue(undefined),
    disconnect: jest.fn().mockResolvedValue(undefined),
    localParticipant: {
      setMicrophoneEnabled: jest.fn().mockResolvedValue(undefined),
    },
    participants: new Map(),
    state: 'disconnected',
    name: 'test-room',
  })),
  RoomEvent: {
    Connected: 'connected',
    Disconnected: 'disconnected',
    ParticipantConnected: 'participantConnected',
    ParticipantDisconnected: 'participantDisconnected',
    TrackSubscribed: 'trackSubscribed',
    TrackUnsubscribed: 'trackUnsubscribed',
    LocalTrackPublished: 'localTrackPublished',
    LocalTrackUnpublished: 'localTrackUnpublished',
  },
  ConnectionState: {
    Connected: 'connected',
    Connecting: 'connecting',
    Disconnected: 'disconnected',
    Reconnecting: 'reconnecting',
  },
}));

jest.mock('react-native-permissions', () => ({
  PERMISSIONS: {
    ANDROID: {
      RECORD_AUDIO: 'android.permission.RECORD_AUDIO',
      CAMERA: 'android.permission.CAMERA',
    },
    IOS: {
      MICROPHONE: 'ios.permission.MICROPHONE',
      CAMERA: 'ios.permission.CAMERA',
    },
  },
  RESULTS: {
    UNAVAILABLE: 'unavailable',
    DENIED: 'denied',
    LIMITED: 'limited',
    GRANTED: 'granted',
    BLOCKED: 'blocked',
  },
  check: jest.fn().mockResolvedValue('granted'),
  request: jest.fn().mockResolvedValue('granted'),
  requestMultiple: jest.fn().mockResolvedValue({}),
  openSettings: jest.fn().mockResolvedValue(undefined),
  checkNotifications: jest.fn().mockResolvedValue({
    status: 'granted',
    settings: {},
  }),
  requestNotifications: jest.fn().mockResolvedValue({
    status: 'granted',
    settings: {},
  }),
}));

// Mock nativewind (v5) to avoid react-native-css runtime issues
jest.mock('nativewind', () => ({
  styled: jest.fn((Component: any) => Component),
  cssInterop: jest.fn((Component: any) => Component),
  vars: jest.fn((v: any) => v),
  VariableContextProvider: ({ children }: { children?: React.ReactNode }) => children,
  useColorScheme: jest.fn(() => ({
    colorScheme: 'light',
    setColorScheme: jest.fn(),
    toggleColorScheme: jest.fn(),
    get: jest.fn(() => 'light'),
  })),
  __esModule: true,
}));

// Avoid loading expo-video's native module in component tests.
jest.mock('expo-video', () => ({
  VideoView: 'VideoView',
  useVideoPlayer: jest.fn(() => ({
    play: jest.fn(),
    pause: jest.fn(),
    addListener: jest.fn(() => ({ remove: jest.fn() })),
  })),
}));

// Mock zod globally to avoid validation schema issues in tests
jest.mock('zod', () => ({
  z: {
    object: jest.fn(() => ({
      parse: jest.fn((data) => data),
      safeParse: jest.fn((data) => ({ success: true, data })),
    })),
    string: jest.fn(() => ({
      min: jest.fn(() => ({
        parse: jest.fn((data) => data),
        safeParse: jest.fn((data) => ({ success: true, data })),
      })),
      parse: jest.fn((data) => data),
      safeParse: jest.fn((data) => ({ success: true, data })),
    })),
  },
  __esModule: true,
}));

// Mock NetInfo globally — the native module isn't available in the Jest environment
jest.mock('@react-native-community/netinfo', () => ({
  __esModule: true,
  default: {
    addEventListener: jest.fn(() => jest.fn()),
    fetch: jest.fn(() => Promise.resolve({ isConnected: true, isInternetReachable: true, type: 'wifi', details: {} })),
  },
  addEventListener: jest.fn(() => jest.fn()),
  fetch: jest.fn(() => Promise.resolve({ isConnected: true, isInternetReachable: true, type: 'wifi', details: {} })),
}));