@smileid/usesmileid 12.0.2 → 12.1.0

package/src/metadata/__tests__/metadata_configuration_objects.test.ts

@@ -1,86 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  type BuilderConfiguration,
-  builderConfigurationToJson,
-} from "../builder_configuration";
-import {
-  type ModelConfiguration,
-  ModelProvider,
-  modelConfigurationToJson,
-} from "../model_configuration";
-
-const builderConfiguration: BuilderConfiguration = {
-  consentScreenUsed: true,
-  consentIconProvided: true,
-  consentIconDimensions: { width: 120, height: 80 },
-  consentAttributionShown: true,
-  instructionsScreenUsed: true,
-  selfiePreviewEnabled: true,
-  documentPreviewEnabled: false,
-  submissionSkipped: false,
-  allowAgentMode: true,
-  enhancedLivenessEnabled: false,
-  autoCaptureEnabled: "autocapture_default",
-  allowGalleryUpload: true,
-  captureBothSides: true,
-  allowSkipBack: false,
-  globalPrivacyControl: "opt-out",
-};
-
-const modelConfiguration: ModelConfiguration = {
-  faceModel: {
-    provider: ModelProvider.Google,
-    name: "play-services-mlkit-face-detection",
-    version: "17.1.0",
-    bundled: false,
-  },
-  documentModel: {
-    provider: ModelProvider.Smile,
-    name: "noop_document_detector",
-    version: "12.0.2",
-    bundled: true,
-  },
-};
-
-describe("builder_configuration_object", () => {
-  it("serialises the full schema with snake_case keys", () => {
-    const json = builderConfigurationToJson(builderConfiguration);
-    expect(json.consent_screen_used).toBe(true);
-    expect(json.consent_icon_provided).toBe(true);
-    expect(json.consent_icon_dimensions).toEqual({ width: 120, height: 80 });
-    expect(json.auto_capture_enabled).toBe("autocapture_default");
-    expect(json.allow_gallery_upload).toBe(true);
-  });
-
-  it("emits consent_icon_dimensions as null when absent", () => {
-    const json = builderConfigurationToJson({
-      ...builderConfiguration,
-      consentIconProvided: false,
-      consentIconDimensions: null,
-    });
-    expect(json.consent_icon_dimensions).toBeNull();
-    // round-trips through JSON.stringify as an explicit null, not an omitted key
-    const reparsed = JSON.parse(JSON.stringify(json)) as Record<
-      string,
-      unknown
-    >;
-    expect("consent_icon_dimensions" in reparsed).toBe(true);
-    expect(reparsed.consent_icon_dimensions).toBeNull();
-  });
-});
-
-describe("model_configuration_object", () => {
-  it("serialises both model descriptors", () => {
-    const json = modelConfigurationToJson(modelConfiguration);
-    const face = json.face_model as Record<string, unknown>;
-    expect(face.provider).toBe("google");
-    expect(face.name).toBe("play-services-mlkit-face-detection");
-    expect(face.version).toBe("17.1.0");
-    expect(face.bundled).toBe(false);
-
-    const document = json.document_model as Record<string, unknown>;
-    expect(document.provider).toBe("smile");
-    expect(document.bundled).toBe(true);
-  });
-});

package/src/metadata/__tests__/metadata_device_context.test.ts

@@ -1,147 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  UseSmileIDMetadata,
-  type UseSmileIDMetadataFields,
-} from "../use_smile_id_metadata";
-
-function fields(
-  overrides: Partial<UseSmileIDMetadataFields> = {},
-): UseSmileIDMetadataFields {
-  return {
-    sdkVersion: "12.0.2",
-    sdk: "react-native-expo",
-    deviceOs: "Android 14",
-    deviceModel: "",
-    appName: "TestApp",
-    sessionId: "session",
-    clientIp: "",
-    networkConnection: "",
-    carrierInfo: "",
-    proxy: false,
-    timezone: "",
-    locale: "",
-    screenResolution: "",
-    memoryInfoMb: 0,
-    deviceOrientation: "",
-    systemArchitecture: "",
-    numberOfCameras: 0,
-    hostApplication: "",
-    proximitySensor: false,
-    securityPolicyVersion: "",
-    sdkConfigSource: "default",
-    imageWidth: 0,
-    imageHeight: 0,
-    livenessImageWidth: 0,
-    livenessImageHeight: 0,
-    ...overrides,
-  };
-}
-
-function value(name: string, fieldsValue: UseSmileIDMetadataFields) {
-  return new UseSmileIDMetadata(fieldsValue)
-    .toEntries()
-    .find((entry) => entry.name === name)?.value;
-}
-
-describe("device-context keys (62-key parity)", () => {
-  it("omits the new keys at their defaults", () => {
-    const names = new UseSmileIDMetadata(fields())
-      .toEntries()
-      .map((entry) => entry.name);
-    for (const key of [
-      "build_brand",
-      "build_device",
-      "build_fingerprint",
-      "build_product",
-      "local_time_of_enrolment",
-      "battery_status",
-    ]) {
-      expect(names).not.toContain(key);
-    }
-  });
-
-  it("emits build + carrier + local time when present", () => {
-    const populated = fields({
-      buildBrand: "google",
-      buildDevice: "husky",
-      buildFingerprint: "google/husky:14",
-      buildProduct: "husky",
-      carrierInfo: "MTN",
-      localTimeOfEnrolment: "2026-06-24T10:00:00.000+03:00",
-    });
-    expect(value("build_brand", populated)).toBe("google");
-    expect(value("build_device", populated)).toBe("husky");
-    expect(value("build_fingerprint", populated)).toBe("google/husky:14");
-    expect(value("build_product", populated)).toBe("husky");
-    expect(value("carrier_info", populated)).toBe("MTN");
-    expect(value("local_time_of_enrolment", populated)).toBe(
-      "2026-06-24T10:00:00.000+03:00",
-    );
-  });
-
-  it("emits battery_status including the meaningful on-battery value", () => {
-    expect(value("battery_status", fields({ batteryStatus: 0 }))).toBe("0");
-    expect(value("battery_status", fields({ batteryStatus: 1 }))).toBe("1");
-    expect(value("battery_status", fields({ batteryStatus: -1 }))).toBe("-1");
-  });
-
-  it("emits wrapper identity when present and omits it when blank", () => {
-    const populated = fields({
-      wrapperName: "react_native_expo",
-      wrapperVersion: "12.0.2",
-    });
-    expect(value("wrapper_name", populated)).toBe("react_native_expo");
-    expect(value("wrapper_version", populated)).toBe("12.0.2");
-
-    const names = new UseSmileIDMetadata(fields())
-      .toEntries()
-      .map((entry) => entry.name);
-    expect(names).not.toContain("wrapper_name");
-  });
-
-  it("emits sdk_launch_count when positive and omits it when zero/undefined", () => {
-    expect(value("sdk_launch_count", fields({ sdkLaunchCount: 9 }))).toBe("9");
-    const zero = new UseSmileIDMetadata(fields({ sdkLaunchCount: 0 }))
-      .toEntries()
-      .map((entry) => entry.name);
-    expect(zero).not.toContain("sdk_launch_count");
-    const absent = new UseSmileIDMetadata(fields())
-      .toEntries()
-      .map((entry) => entry.name);
-    expect(absent).not.toContain("sdk_launch_count");
-  });
-
-  it("emits privileges verbatim and omits it when absent", () => {
-    const raw = '{"1":"100010","8":"100100"}';
-    expect(value("privileges", fields({ privileges: raw }))).toBe(raw);
-    const absent = new UseSmileIDMetadata(fields())
-      .toEntries()
-      .map((entry) => entry.name);
-    expect(absent).not.toContain("privileges");
-  });
-
-  it("emits geolocation as a JSON-object string and omits it when absent", () => {
-    const raw = value(
-      "geolocation",
-      fields({
-        geolocation: {
-          latitude: 1.5,
-          longitude: -2.5,
-          accuracy: "precise",
-          source: "gps",
-        },
-      }),
-    );
-    expect(JSON.parse(raw!)).toEqual({
-      latitude: 1.5,
-      longitude: -2.5,
-      accuracy: "precise",
-      source: "gps",
-    });
-    const absent = new UseSmileIDMetadata(fields())
-      .toEntries()
-      .map((entry) => entry.name);
-    expect(absent).not.toContain("geolocation");
-  });
-});

package/src/metadata/__tests__/metadata_device_os_android.test.ts

@@ -1,18 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-vi.mock("react-native", () => ({
-  Platform: { OS: "android", Version: 31, constants: { Release: "12" } },
-  Dimensions: {
-    get: () => ({ width: 1080, height: 2400, scale: 3 }),
-  },
-}));
-
-import { UseSmileIDMetadataFactory } from "../use_smile_id_metadata_factory";
-
-describe("device_os on Android", () => {
-  it("reports the release version, not the API level", () => {
-    const factory = new UseSmileIDMetadataFactory();
-
-    expect(factory.make().toFields().deviceOs).toBe("Android 12");
-  });
-});

package/src/metadata/__tests__/metadata_golden_fixture.json

@@ -1,13 +0,0 @@
-{
-  "_comment": "Shared cross-SDK golden parity vectors. These metadata keys must serialise to the EXACT same wire value on Android, iOS, Flutter, and React Native for the standard fully-populated golden snapshot. Each SDK's metadata-payload golden test asserts its payload contains every entry below verbatim. Maintained manually — keep the four copies (android/ios/flutter/react-native-expo test dirs) in sync.",
-  "expected": {
-    "sdk_version": "12.0.2",
-    "proxy": "true",
-    "proximity_sensor": "true",
-    "sdk_config_source": "sdk_config",
-    "battery_status": "0",
-    "sdk_launch_count": "5",
-    "vpn": "false",
-    "privileges": "{\"1\":\"100010\",\"8\":\"100100\"}"
-  }
-}

package/src/metadata/__tests__/metadata_payload_golden.test.ts

@@ -1,193 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  UseSmileIDMetadata,
-  type UseSmileIDMetadataFields,
-} from "../use_smile_id_metadata";
-import goldenFixture from "./metadata_golden_fixture.json";
-
-/**
- * Golden check that a fully-populated `UseSmileIDMetadata` emits the device-context payload with the
- * right value shapes, and that a default snapshot emits only the always-present keys.
- *
- * Capture-telemetry / document-origin / config-object keys ride as flow-manager `extraEntries`
- * (verified in `document_flow_navigation.test.ts`); this suite covers the field-based device-context
- * keys, using the same inputs/expected values as the sibling Android / iOS / Flutter golden suites.
- */
-describe("metadata payload (golden, device-context fields)", () => {
-  function fullyPopulated(): UseSmileIDMetadataFields {
-    return {
-      sdkVersion: "12.0.2",
-      sdk: "react-native-expo",
-      deviceOs: "Android 14",
-      deviceModel: "Google Pixel 8",
-      appName: "TestApp",
-      sessionId: "session-123",
-      clientIp: "192.168.1.5",
-      networkConnection: "wifi",
-      carrierInfo: "MTN",
-      proxy: true,
-      timezone: "Africa/Lagos",
-      locale: "en_NG",
-      screenResolution: "1080x2400",
-      memoryInfoMb: 7777,
-      deviceOrientation: "portrait",
-      systemArchitecture: "arm64-v8a",
-      numberOfCameras: 3,
-      hostApplication: "TestApp v1.2",
-      proximitySensor: true,
-      securityPolicyVersion: "12.0.0",
-      sdkConfigSource: "sdk_config",
-      imageWidth: 480,
-      imageHeight: 640,
-      livenessImageWidth: 320,
-      livenessImageHeight: 240,
-      timezoneOffsetMinutes: 60,
-      buildBrand: "Google",
-      buildDevice: "husky",
-      buildFingerprint: "google/husky:14",
-      buildProduct: "husky",
-      buildHardware: "husky",
-      buildSource: "com.android.vending",
-      packageName: "com.partner.app",
-      fingerprint: "android-id-123",
-      localTimeOfEnrolment: "2026-06-24T10:00:00.000+03:00",
-      batteryStatus: 0,
-      vpn: false,
-      certificateDigest: ["AA:BB", "CC:DD"],
-      wrapperName: "react_native_expo",
-      wrapperVersion: "12.0.2",
-      sdkLaunchCount: 5,
-      geolocation: {
-        latitude: 1.5,
-        longitude: -2.5,
-        accuracy: "precise",
-        source: "gps",
-      },
-      privileges: '{"1":"100010","8":"100100"}',
-    };
-  }
-
-  function entriesOf(fields: UseSmileIDMetadataFields): Map<string, string> {
-    return new Map(
-      new UseSmileIDMetadata(fields).toEntries().map((e) => [e.name, e.value]),
-    );
-  }
-
-  // Field-based device-context keys the fully-populated payload must emit.
-  const expectedKeys = [
-    "sdk_version",
-    "sdk",
-    "device_os",
-    "device_model",
-    "app_name",
-    "session_id",
-    "proxy",
-    "proximity_sensor",
-    "sdk_config_source",
-    "client_ip",
-    "network_connection",
-    "carrier_info",
-    "timezone",
-    "locale",
-    "screen_resolution",
-    "device_orientation",
-    "system_architecture",
-    "host_application",
-    "security_policy_version",
-    "selfie_image_dimensions",
-    "liveness_image_dimensions",
-    "timezone_offset",
-    "memory_info",
-    "number_of_cameras",
-    "build_brand",
-    "build_device",
-    "build_fingerprint",
-    "build_product",
-    "build_hardware",
-    "build_source",
-    "package_name",
-    "fingerprint",
-    "local_time_of_enrolment",
-    "battery_status",
-    "vpn",
-    "certificate_digest",
-    "wrapper_name",
-    "wrapper_version",
-    "sdk_launch_count",
-    "geolocation",
-    "privileges",
-  ];
-
-  it("emits every expected device-context key", () => {
-    const map = entriesOf(fullyPopulated());
-    for (const key of expectedKeys) {
-      expect(map.has(key), `missing key: ${key}`).toBe(true);
-    }
-  });
-
-  it("emits scalar + meaningful-falsey + JSON-shaped values correctly", () => {
-    const map = entriesOf(fullyPopulated());
-    expect(map.get("sdk_version")).toBe("12.0.2");
-    expect(map.get("proxy")).toBe("true");
-    expect(map.get("battery_status")).toBe("0"); // 0 is meaningful
-    expect(map.get("sdk_config_source")).toBe("sdk_config");
-    expect(map.get("wrapper_name")).toBe("react_native_expo");
-    expect(map.get("privileges")).toBe('{"1":"100010","8":"100100"}'); // verbatim
-    expect(map.get("vpn")).toBe("false"); // false is meaningful
-    expect(map.get("fingerprint")).toBe("android-id-123");
-    expect(map.get("package_name")).toBe("com.partner.app");
-    expect(JSON.parse(map.get("certificate_digest")!)).toEqual([
-      "AA:BB",
-      "CC:DD",
-    ]);
-    expect(JSON.parse(map.get("geolocation")!).accuracy).toBe("precise");
-  });
-
-  it("matches the cross-SDK parity fixture values", () => {
-    const map = entriesOf(fullyPopulated());
-    for (const [key, value] of Object.entries(goldenFixture.expected)) {
-      expect(map.get(key), `cross-SDK parity mismatch for ${key}`).toBe(value);
-    }
-  });
-
-  it("default snapshot emits only the always-present keys", () => {
-    const minimal: UseSmileIDMetadataFields = {
-      sdkVersion: "12.0.2",
-      sdk: "react-native-expo",
-      deviceOs: "Android 14",
-      deviceModel: "",
-      appName: "App",
-      sessionId: "s",
-      clientIp: "",
-      networkConnection: "",
-      carrierInfo: "",
-      timezone: "",
-      locale: "",
-      screenResolution: "",
-      memoryInfoMb: 0,
-      deviceOrientation: "",
-      systemArchitecture: "",
-      numberOfCameras: 0,
-      hostApplication: "",
-      securityPolicyVersion: "",
-      sdkConfigSource: "default",
-      imageWidth: 0,
-      imageHeight: 0,
-      livenessImageWidth: 0,
-      livenessImageHeight: 0,
-    };
-    const keys = new Set(entriesOf(minimal).keys());
-    // device_model is "" here so it omits; the rest of the required identity keys + source.
-    expect(keys.has("sdk_version")).toBe(true);
-    expect(keys.has("sdk_config_source")).toBe(true);
-    // Never-measured booleans → omitted rather than an inaccurate false.
-    expect(keys.has("proxy")).toBe(false);
-    expect(keys.has("proximity_sensor")).toBe(false);
-    // Optionals absent → omitted.
-    expect(keys.has("build_brand")).toBe(false);
-    expect(keys.has("geolocation")).toBe(false);
-    expect(keys.has("privileges")).toBe(false);
-    expect(keys.has("battery_status")).toBe(false);
-  });
-});

package/src/metadata/__tests__/optional_native_modules.test.ts

@@ -1,234 +0,0 @@
-import { describe, it, expect, afterEach, beforeEach, vi } from "vitest";
-import Module from "node:module";
-
-import {
-  loadExpoDevice,
-  loadExpoNetwork,
-  loadExpoBattery,
-  loadExpoCellular,
-  loadAsyncStorage,
-  loadExpoSensors,
-  loadExpoLocation,
-  _resetOptionalModulesForTesting,
-} from "../optional_native_modules";
-
-/**
- * The optional peer bridges resolve through a dynamic `require()` so a
- * partner who skips `expo-battery` / `expo-sensors` / async-storage
- * still gets a bundle that builds. `vi.mock` can't reach a CommonJS
- * `require`, so these tests intercept Node's module loader itself —
- * that is the exact seam the production code depends on.
- */
-
-type Loader = (id: string, parent: unknown, isMain: boolean) => unknown;
-
-const loaderHost = Module as unknown as { _load: Loader };
-const originalLoad: Loader = loaderHost._load;
-
-/** Resolution table consulted by the patched loader; unlisted ids fall through. */
-let resolutions: Record<string, unknown | (() => never)> = {};
-let requestedIds: string[] = [];
-
-beforeEach(() => {
-  resolutions = {};
-  requestedIds = [];
-  _resetOptionalModulesForTesting();
-  vi.spyOn(loaderHost, "_load").mockImplementation((id, parent, isMain) => {
-    requestedIds.push(id);
-    if (Object.prototype.hasOwnProperty.call(resolutions, id)) {
-      const entry = resolutions[id];
-      if (typeof entry === "function") return (entry as () => never)();
-      return entry;
-    }
-    return originalLoad.call(Module, id, parent, isMain);
-  });
-});
-
-afterEach(() => {
-  vi.restoreAllMocks();
-  _resetOptionalModulesForTesting();
-});
-
-function throwsMissing(id: string) {
-  return () => {
-    const error = new Error(`Cannot find module '${id}'`) as Error & {
-      code: string;
-    };
-    error.code = "MODULE_NOT_FOUND";
-    throw error;
-  };
-}
-
-/** Stands in for `expo-modules-core`'s non-throwing native-module lookup. */
-function expoCore(natives: Record<string, unknown>) {
-  return {
-    requireOptionalNativeModule: <T>(name: string): T | null =>
-      (natives[name] as T) ?? null,
-  };
-}
-
-describe("optional native module bridges", () => {
-  describe("expo-modules-core backed loaders", () => {
-    it("returns the raw ExpoDevice native module when it is linked", () => {
-      const native = { modelName: "Pixel 8", brand: "google" };
-      resolutions["expo-modules-core"] = expoCore({ ExpoDevice: native });
-
-      expect(loadExpoDevice()).toBe(native);
-    });
-
-    it("returns null when the native module is not linked", () => {
-      resolutions["expo-modules-core"] = expoCore({});
-
-      expect(loadExpoDevice()).toBeNull();
-      expect(loadExpoNetwork()).toBeNull();
-      expect(loadExpoBattery()).toBeNull();
-      expect(loadExpoCellular()).toBeNull();
-    });
-
-    it("returns null when expo-modules-core itself cannot be resolved", () => {
-      resolutions["expo-modules-core"] = throwsMissing("expo-modules-core");
-
-      expect(loadExpoDevice()).toBeNull();
-      expect(loadExpoNetwork()).toBeNull();
-      expect(loadExpoBattery()).toBeNull();
-      expect(loadExpoCellular()).toBeNull();
-    });
-
-    it("returns null when the core build predates requireOptionalNativeModule", () => {
-      resolutions["expo-modules-core"] = {};
-
-      expect(loadExpoDevice()).toBeNull();
-      expect(loadExpoBattery()).toBeNull();
-    });
-
-    it("resolves ExpoNetwork, ExpoBattery and ExpoCellular by name", () => {
-      const network = { getNetworkStateAsync: async () => ({ type: "WIFI" }) };
-      const battery = { getBatteryStateAsync: async () => 2 };
-      const cellular = { carrier: "MTN" };
-      resolutions["expo-modules-core"] = expoCore({
-        ExpoNetwork: network,
-        ExpoBattery: battery,
-        ExpoCellular: cellular,
-      });
-
-      expect(loadExpoNetwork()).toBe(network);
-      expect(loadExpoBattery()).toBe(battery);
-      expect(loadExpoCellular()).toBe(cellular);
-    });
-
-    it("caches the resolution — a second call never re-requires", () => {
-      const native = { modelName: "Pixel 8" };
-      resolutions["expo-modules-core"] = expoCore({ ExpoDevice: native });
-
-      expect(loadExpoDevice()).toBe(native);
-      const requiresAfterFirst = requestedIds.filter(
-        (id) => id === "expo-modules-core",
-      ).length;
-
-      // Swap the table: a cached loader must not observe the change.
-      resolutions["expo-modules-core"] = expoCore({
-        ExpoDevice: { modelName: "Different" },
-      });
-      expect(loadExpoDevice()).toBe(native);
-      expect(
-        requestedIds.filter((id) => id === "expo-modules-core").length,
-      ).toBe(requiresAfterFirst);
-    });
-
-    it("caches the null resolution too — a missing module is asked for once", () => {
-      resolutions["expo-modules-core"] = throwsMissing("expo-modules-core");
-
-      expect(loadExpoBattery()).toBeNull();
-      const count = requestedIds.filter(
-        (id) => id === "expo-modules-core",
-      ).length;
-      expect(loadExpoBattery()).toBeNull();
-      expect(
-        requestedIds.filter((id) => id === "expo-modules-core").length,
-      ).toBe(count);
-    });
-  });
-
-  describe("async storage", () => {
-    it("unwraps the CommonJS default export", () => {
-      const storage = {
-        getItem: async () => null,
-        setItem: async () => {},
-      };
-      resolutions["@react-native-async-storage/async-storage"] = {
-        default: storage,
-      };
-
-      expect(loadAsyncStorage()).toBe(storage);
-    });
-
-    it("accepts a namespace without a default export", () => {
-      const storage = {
-        getItem: async () => null,
-        setItem: async () => {},
-      };
-      resolutions["@react-native-async-storage/async-storage"] = storage;
-
-      expect(loadAsyncStorage()).toBe(storage);
-    });
-
-    it("returns null when the package is not installed", () => {
-      resolutions["@react-native-async-storage/async-storage"] = throwsMissing(
-        "@react-native-async-storage/async-storage",
-      );
-
-      expect(loadAsyncStorage()).toBeNull();
-    });
-  });
-
-  describe("expo-sensors and expo-location", () => {
-    it("returns the module namespace when installed", () => {
-      const sensors = {
-        Accelerometer: {
-          setUpdateInterval: () => {},
-          addListener: () => ({ remove: () => {} }),
-        },
-      };
-      const location = {
-        getForegroundPermissionsAsync: async () => ({ granted: true }),
-        getLastKnownPositionAsync: async () => null,
-      };
-      resolutions["expo-sensors"] = sensors;
-      resolutions["expo-location"] = location;
-
-      expect(loadExpoSensors()).toBe(sensors);
-      expect(loadExpoLocation()).toBe(location);
-    });
-
-    it("returns null when either peer dep is absent", () => {
-      resolutions["expo-sensors"] = throwsMissing("expo-sensors");
-      resolutions["expo-location"] = throwsMissing("expo-location");
-
-      expect(loadExpoSensors()).toBeNull();
-      expect(loadExpoLocation()).toBeNull();
-    });
-  });
-
-  it("_resetOptionalModulesForTesting clears every cached bridge", () => {
-    const first = { modelName: "First" };
-    resolutions["expo-modules-core"] = expoCore({ ExpoDevice: first });
-    resolutions["expo-sensors"] = { Accelerometer: {} };
-    expect(loadExpoDevice()).toBe(first);
-    expect(loadExpoSensors()).toEqual({ Accelerometer: {} });
-
-    _resetOptionalModulesForTesting();
-
-    const second = { modelName: "Second" };
-    resolutions["expo-modules-core"] = expoCore({ ExpoDevice: second });
-    resolutions["expo-sensors"] = throwsMissing("expo-sensors");
-    resolutions["expo-location"] = throwsMissing("expo-location");
-    resolutions["@react-native-async-storage/async-storage"] = throwsMissing(
-      "@react-native-async-storage/async-storage",
-    );
-
-    expect(loadExpoDevice()).toBe(second);
-    expect(loadExpoSensors()).toBeNull();
-    expect(loadExpoLocation()).toBeNull();
-    expect(loadAsyncStorage()).toBeNull();
-  });
-});