Mocking Native Modules

// __tests__/location-screen-test.tsx
import { render, screen, waitFor } from "@testing-library/react-native";
import * as Location from "expo-location";
import { LocationScreen } from "../src/screens/location-screen";
 
jest.mock("expo-location");
 
const mockLocation = jest.mocked(Location);
 
beforeEach(() => {
  mockLocation.requestForegroundPermissionsAsync.mockResolvedValue({
    status: "granted",
    granted: true,
    canAskAgain: true,
    expires: "never",
  });
 
  mockLocation.getCurrentPositionAsync.mockResolvedValue({
    coords: { latitude: 37.77, longitude: -122.42, altitude: 0, accuracy: 5, altitudeAccuracy: 5, heading: 0, speed: 0 },
    timestamp: 1_700_000_000_000,
  });
});
 
test("shows coordinates when permission is granted", async () => {
  render(<LocationScreen />);
  expect(await screen.findByText(/37\.77/)).toBeOnTheScreen();
  await waitFor(() => {
    expect(mockLocation.getCurrentPositionAsync).toHaveBeenCalled();
  });
});

// src/services/push-token-service.ts
import * as Notifications from "expo-notifications";
import * as Device from "expo-device";
 
export async function registerForPushNotifications(): Promise<string | null> {
  if (!Device.isDevice) {
    return null;
  }
 
  const { status: existing } = await Notifications.getPermissionsAsync();
  let finalStatus = existing;
 
  if (existing !== "granted") {
    const { status } = await Notifications.requestPermissionsAsync();
    finalStatus = status;
  }
 
  if (finalStatus !== "granted") {
    throw new Error("Push permission denied");
  }
 
  const token = await Notifications.getExpoPushTokenAsync();
  return token.data;
}

// __tests__/push-token-service-test.tsx
import * as Notifications from "expo-notifications";
import * as Device from "expo-device";
import { registerForPushNotifications } from "../src/services/push-token-service";
 
jest.mock("expo-notifications");
jest.mock("expo-device");
 
const notifications = jest.mocked(Notifications);
const device = jest.mocked(Device);
 
describe("registerForPushNotifications", () => {
  beforeEach(() => {
    jest.clearAllMocks();
    device.isDevice = true;
  });
 
  test("returns token when permission already granted", async () => {
    notifications.getPermissionsAsync.mockResolvedValue({
      status: "granted",
      granted: true,
      canAskAgain: true,
      expires: "never",
    });
    notifications.getExpoPushTokenAsync.mockResolvedValue({
      data: "ExponentPushToken[abc]",
      type: "expo",
    });
 
    await expect(registerForPushNotifications()).resolves.toBe(
      "ExponentPushToken[abc]"
    );
    expect(notifications.requestPermissionsAsync).not.toHaveBeenCalled();
  });
 
  test("requests permission when not yet granted", async () => {
    notifications.getPermissionsAsync.mockResolvedValue({
      status: "undetermined",
      granted: false,
      canAskAgain: true,
      expires: "never",
    });
    notifications.requestPermissionsAsync.mockResolvedValue({
      status: "granted",
      granted: true,
      canAskAgain: true,
      expires: "never",
    });
    notifications.getExpoPushTokenAsync.mockResolvedValue({
      data: "ExponentPushToken[xyz]",
      type: "expo",
    });
 
    await expect(registerForPushNotifications()).resolves.toBe(
      "ExponentPushToken[xyz]"
    );
    expect(notifications.requestPermissionsAsync).toHaveBeenCalledTimes(1);
  });
 
  test("throws when permission denied", async () => {
    notifications.getPermissionsAsync.mockResolvedValue({
      status: "denied",
      granted: false,
      canAskAgain: false,
      expires: "never",
    });
 
    await expect(registerForPushNotifications()).rejects.toThrow(
      "Push permission denied"
    );
  });
 
  test("returns null on simulator", async () => {
    device.isDevice = false;
 
    await expect(registerForPushNotifications()).resolves.toBeNull();
    expect(notifications.getPermissionsAsync).not.toHaveBeenCalled();
  });
});

jest.mock("expo-secure-store", () => ({
  getItemAsync: jest.fn(),
  setItemAsync: jest.fn(),
  deleteItemAsync: jest.fn(),
}));

// src/__mocks__/analytics.ts
export const trackEvent = jest.fn();
export const identifyUser = jest.fn();

jest.mock("expo-linking", () => {
  const actual = jest.requireActual<typeof import("expo-linking")>("expo-linking");
  return {
    ...actual,
    openURL: jest.fn(actual.openURL),
  };
});

import type { LocationObject } from "expo-location";
 
function buildLocation(overrides: Partial<LocationObject> = {}): LocationObject {
  return {
    coords: {
      latitude: 0,
      longitude: 0,
      altitude: 0,
      accuracy: 0,
      altitudeAccuracy: 0,
      heading: 0,
      speed: 0,
    },
    timestamp: Date.now(),
    ...overrides,
  };
}
 
mockLocation.getCurrentPositionAsync.mockResolvedValue(
  buildLocation({ coords: { latitude: 51.5, longitude: -0.12, altitude: 0, accuracy: 1, altitudeAccuracy: 1, heading: 0, speed: 0 } })
);