jest.setup.js

import 'react-native-gesture-handler/jestSetup';

// Mock Expo Crypto
jest.mock('expo-crypto', () => ({
  getRandomBytes: jest.fn((length) => new Uint8Array(length).fill(0)), // Mocked random bytes
}));

// Mock Expo SecureStore
jest.mock('expo-secure-store', () => ({
  setItemAsync: jest.fn(() => Promise.resolve()),
  getItemAsync: jest.fn(() => Promise.resolve(null)),
  deleteItemAsync: jest.fn(() => Promise.resolve()),
}));

// Mock Expo LocalAuthentication
jest.mock('expo-local-authentication', () => ({
  hasHardwareAsync: jest.fn(() => Promise.resolve(true)),
  isEnrolledAsync: jest.fn(() => Promise.resolve(true)),
  authenticateAsync: jest.fn(() => Promise.resolve({ success: true })),
}));

// Mock Expo Localization
jest.mock('expo-localization', () => ({
  locale: 'it-IT',
  locales: ['it-IT'],
  getLocales: () => [{ languageCode: 'it', regionCode: 'IT', languageTag: 'it-IT' }],
}));

// Mock Expo NavigationBar
jest.mock('expo-navigation-bar', () => ({
  __esModule: true,
  NavigationBar: jest.fn(() => null),
}));

// Mock Expo FileSystem
jest.mock('expo-file-system', () => ({
  File: class MockFile {
    constructor(...parts) {
      this.uri = parts
        .map((part) => (typeof part === 'string' ? part : part.uri))
        .reduce((path, part) => `${path.replace(/\/$/, '')}/${part.replace(/^\//, '')}`);
      this.exists = true;
      this.extension = this.uri.match(/\.[a-z0-9]+$/i)?.[0] ?? '';
    }

    copy() {
      return Promise.resolve();
    }
  },
  Paths: { document: { uri: 'file:///test-directory' } },
  documentDirectory: 'file:///test-directory/',
  writeAsStringAsync: jest.fn(() => Promise.resolve()),
  readAsStringAsync: jest.fn(() => Promise.resolve('')),
  deleteAsync: jest.fn(() => Promise.resolve()),
  getInfoAsync: jest.fn(() => Promise.resolve({ exists: true })),
  makeDirectoryAsync: jest.fn(() => Promise.resolve()),
}));

// Mock Expo Constants
jest.mock('expo-constants', () => ({
  manifest: {
    extra: {},
  },
}));

// Mock Expo Font
jest.mock('expo-font', () => ({
  loadAsync: jest.fn(() => Promise.resolve()),
  isLoaded: jest.fn(() => true),
}));

// Mock Expo Notifications
jest.mock('expo-notifications', () => ({
  AndroidImportance: { DEFAULT: 3 },
  setNotificationHandler: jest.fn(),
  setNotificationChannelAsync: jest.fn().mockResolvedValue(undefined),
  cancelAllScheduledNotificationsAsync: jest.fn().mockResolvedValue(undefined),
  cancelScheduledNotificationAsync: jest.fn().mockResolvedValue(undefined),
  getAllScheduledNotificationsAsync: jest.fn().mockResolvedValue([]),
  getPermissionsAsync: jest.fn().mockResolvedValue({ status: 'granted' }),
  requestPermissionsAsync: jest.fn().mockResolvedValue({ status: 'granted' }),
  scheduleNotificationAsync: jest.fn().mockResolvedValue('notification-id'),
  addNotificationReceivedListener: jest.fn(() => ({ remove: jest.fn() })),
  addNotificationResponseReceivedListener: jest.fn(() => ({ remove: jest.fn() })),
}));

// Mock Argon2 for tests (avoid native dependency warnings)
jest.mock('react-native-argon2', () => ({
  argon2: jest.fn(async (password, salt, options) => ({
    rawHash: `argon2-${password}-${salt}-${options?.iterations ?? 0}-${options?.memory ?? 0}`,
  })),
}));

// Mock React Native Reanimated
jest.mock('react-native-reanimated', () => {
  const React = require('react');
  const { View } = require('react-native');
  const enteringBuilder = {
    duration: jest.fn(() => enteringBuilder),
    delay: jest.fn(() => enteringBuilder),
  };
  const AnimatedView = ({ entering: _entering, exiting: _exiting, ...props }) =>
    React.createElement(View, props);

  return {
    __esModule: true,
    default: { View: AnimatedView },
    FadeIn: enteringBuilder,
    FadeInDown: enteringBuilder,
    FadeInUp: enteringBuilder,
    FadeOutUp: enteringBuilder,
  };
});

// Mock Safe Area Context
jest.mock('react-native-safe-area-context', () => {
  const inset = { top: 0, right: 0, bottom: 0, left: 0 };
  return {
    SafeAreaProvider: jest.fn(({ children }) => children),
    SafeAreaView: jest.fn(({ children }) => children),
    useSafeAreaInsets: jest.fn(() => inset),
  };
});

// Mock Navigation
const mockNavigate = jest.fn();
const mockGoBack = jest.fn();
const mockSetOptions = jest.fn();
const mockNavigation = {
  navigate: mockNavigate,
  goBack: mockGoBack,
  setOptions: mockSetOptions,
  addListener: jest.fn(),
  removeListener: jest.fn(),
  dispatch: jest.fn(),
  canGoBack: jest.fn(),
  isFocused: jest.fn().mockReturnValue(true),
};

jest.mock('@react-navigation/native', () => {
  const actualNav = jest.requireActual('@react-navigation/native');
  return {
    ...actualNav,
    useNavigation: () => mockNavigation,
    useRoute: () => ({
      params: {},
    }),
    useIsFocused: () => true,
  };
});

// Silence warnings
const originalConsoleError = console.error;
console.error = (...args) => {
  if (typeof args[0] === 'string' && args[0].includes('not wrapped in act')) {
    return;
  }
  originalConsoleError(...args);
};