@smileid/usesmileid 12.0.0 → 12.0.2

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

@@ -0,0 +1,234 @@
+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();
+  });
+});

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

@@ -23,7 +23,7 @@ import { SdkConfigSource } from "../../data/model/sdk_config_source";
 // survive `toEntries()` from this fixture are the truly-always-present ones
 // (SDK constants, sessionId, sdk_config_source).
 const baseFields: UseSmileIDMetadataFields = Object.freeze({
-  sdkVersion: "12.0.0",
+  sdkVersion: "12.0.2",
   sdk: "react-native-expo",
   deviceOs: "",
   deviceModel: "",