@smileid/usesmileid 12.0.0 → 12.0.2

package/src/__tests__/snapshots/screens_structural.test.tsx

@@ -0,0 +1,230 @@
+import { describe, it, expect } from "vitest";
+import * as React from "react";
+import { View } from "react-native";
+import { act, create as createRenderer } from "react-test-renderer";
+import { CaptureType } from "../../core/models/ml_config";
+import { UseSmileIDCaptureContent } from "../../presentation/components/use_smile_id_capture_content";
+import type { UseSmileIDCaptureContentState } from "../../presentation/components/use_smile_id_capture_content";
+import { UseSmileIDConsentScreen } from "../../presentation/screen/use_smile_id_consent_screen";
+import { UseSmileIDDocumentBackInstructions } from "../../presentation/screen/use_smile_id_document_back_instructions";
+import { UseSmileIDDocumentPreviewScreen } from "../../presentation/screen/use_smile_id_document_preview_screen";
+import { UseSmileIDInstructionsScreen } from "../../presentation/screen/use_smile_id_instructions_screen";
+import { UseSmileIDPreviewScreen } from "../../presentation/screen/use_smile_id_preview_screen";
+import { UseSmileIDProcessingScreen } from "../../presentation/screen/use_smile_id_processing_screen";
+import { UseSmileIDFaceOverlay } from "../../presentation/components/use_smile_id_face_overlay";
+import { UseSmileIDDocumentOverlay } from "../../presentation/components/use_smile_id_document_overlay";
+import {
+  OVERLAY_STATE_COUNT,
+  UseSmileIDOverlayState,
+} from "../../presentation/state/use_smile_id_overlay_state";
+
+/**
+ * Structural snapshots: pin the rendered element tree, not pixels (pixels are
+ * the Detox lane's job). Keys follow the `<flow>/<screen>/<state>` contract.
+ */
+
+function render(element: React.ReactElement) {
+  let tree!: ReturnType<typeof createRenderer>;
+  act(() => {
+    tree = createRenderer(element);
+  });
+  return tree;
+}
+
+const CONTAINER = { containerWidth: 390, containerHeight: 520 } as const;
+
+const DOCUMENT_STATES = Object.values(UseSmileIDOverlayState).filter((s) =>
+  s.startsWith("DOCUMENT_"),
+);
+const FACE_STATES = Object.values(UseSmileIDOverlayState).filter(
+  (s) => !s.startsWith("DOCUMENT_"),
+);
+
+describe("structural snapshots", () => {
+  it("pins the overlay state inventory", () => {
+    expect(FACE_STATES.length + DOCUMENT_STATES.length).toBe(
+      OVERLAY_STATE_COUNT,
+    );
+  });
+
+  describe("selfie/instructions", () => {
+    it("selfie/instructions/default", () => {
+      const tree = render(
+        <UseSmileIDInstructionsScreen
+          onBack={() => {}}
+          onContinue={() => {}}
+        />,
+      );
+      expect(tree.toJSON()).toMatchSnapshot();
+    });
+  });
+
+  describe("selfie/capture overlay", () => {
+    it.each(FACE_STATES)("selfie/capture/%s", (state) => {
+      const tree = render(
+        <UseSmileIDFaceOverlay state={state} progress={0.5} {...CONTAINER} />,
+      );
+      expect(tree.toJSON()).toMatchSnapshot();
+    });
+  });
+
+  describe("document/capture overlay", () => {
+    it.each(DOCUMENT_STATES)("document/capture/%s", (state) => {
+      const tree = render(
+        <UseSmileIDDocumentOverlay state={state} {...CONTAINER} />,
+      );
+      expect(tree.toJSON()).toMatchSnapshot();
+    });
+  });
+
+  describe("consent", () => {
+    it("consent/default", () => {
+      const tree = render(
+        <UseSmileIDConsentScreen
+          partnerName="Acme Bank"
+          partnerPrivacyPolicyUrl="https://usesmileid.com/privacy"
+          onAllow={() => {}}
+          onDeny={() => {}}
+        />,
+      );
+      expect(tree.toJSON()).toMatchSnapshot();
+    });
+  });
+
+  describe("document/back_instructions", () => {
+    it("document/back_instructions/default", () => {
+      const tree = render(
+        <UseSmileIDDocumentBackInstructions
+          documentTypeDisplayName="National ID"
+          onCaptureBack={() => {}}
+          allowSkip
+          onSkip={() => {}}
+          onBack={() => {}}
+        />,
+      );
+      expect(tree.toJSON()).toMatchSnapshot();
+    });
+  });
+
+  describe("document/preview", () => {
+    it("document/preview/default", () => {
+      const tree = render(
+        <UseSmileIDDocumentPreviewScreen
+          documentAspectRatio={1.586}
+          onAccept={() => {}}
+          onReject={() => {}}
+          onClose={() => {}}
+        />,
+      );
+      expect(tree.toJSON()).toMatchSnapshot();
+    });
+  });
+
+  // Composed capture screen: camera slot + overlay + feedback + controls.
+  function renderCaptureContent(
+    overrides: Partial<UseSmileIDCaptureContentState>,
+  ) {
+    return render(
+      <UseSmileIDCaptureContent
+        state={{
+          captureType: CaptureType.selfie,
+          overlayState: UseSmileIDOverlayState.INSTRUCTION,
+          enableEnhancedLiveness: false,
+          animationDirection: null,
+          poseMatched: false,
+          feedbackKey: null,
+          showCaptureButton: false,
+          ...overrides,
+        }}
+        captureProgress={0}
+        cameraPreview={<View testID="camera-slot" />}
+        onStartCapture={() => {}}
+        startCaptureEnabled={true}
+        showAttribution={true}
+        onManualShutter={() => {}}
+        onGalleryUpload={() => {}}
+      />,
+    );
+  }
+
+  describe("selfie/capture content", () => {
+    it("selfie/capture/start_button", () => {
+      const tree = renderCaptureContent({
+        overlayState: UseSmileIDOverlayState.INSTRUCTION,
+        feedbackKey: "si_start_capture_instruction",
+        showCaptureButton: true,
+      });
+      expect(tree.toJSON()).toMatchSnapshot();
+    });
+  });
+
+  describe("document/capture content", () => {
+    const DOCUMENT_VARIANTS: ReadonlyArray<
+      [string, Partial<UseSmileIDCaptureContentState>]
+    > = [
+      ["card_front", { documentTypeKind: "genericDocument" }],
+      ["card_back", { documentTypeKind: "genericDocument", isBackSide: true }],
+      // TD3 passport data page ratio (125×88 mm).
+      ["passport", { documentTypeKind: "passport", knownIdAspectRatio: 1.42 }],
+      ["green_book", { documentTypeKind: "southAfricaGreenBook" }],
+    ];
+
+    it.each(DOCUMENT_VARIANTS)("document/capture/%s", (_name, overrides) => {
+      const tree = renderCaptureContent({
+        captureType: CaptureType.document,
+        overlayState: UseSmileIDOverlayState.IDLE,
+        knownIdAspectRatio: 1.586,
+        showGalleryUpload: true,
+        ...overrides,
+      });
+      expect(tree.toJSON()).toMatchSnapshot();
+    });
+
+    it("document/capture/manual_shutter", () => {
+      const tree = renderCaptureContent({
+        captureType: CaptureType.document,
+        overlayState: UseSmileIDOverlayState.DOCUMENT_TOO_FAR,
+        feedbackKey: "si_document_too_far",
+        documentTypeKind: "genericDocument",
+        knownIdAspectRatio: 1.586,
+        showManualShutter: true,
+        showGalleryUpload: true,
+      });
+      expect(tree.toJSON()).toMatchSnapshot();
+    });
+  });
+
+  describe("selfie/preview", () => {
+    it("selfie/preview/default", () => {
+      const tree = render(<UseSmileIDPreviewScreen />);
+      expect(tree.toJSON()).toMatchSnapshot();
+    });
+  });
+
+  describe("selfie/processing", () => {
+    it("selfie/processing/loading", () => {
+      const tree = render(
+        <UseSmileIDProcessingScreen state={{ kind: "loading" }} />,
+      );
+      expect(tree.toJSON()).toMatchSnapshot();
+    });
+
+    it("selfie/processing/success", () => {
+      const tree = render(
+        <UseSmileIDProcessingScreen
+          state={{ kind: "success", message: "Verification submitted" }}
+        />,
+      );
+      expect(tree.toJSON()).toMatchSnapshot();
+    });
+
+    it("selfie/processing/failed", () => {
+      const tree = render(
+        <UseSmileIDProcessingScreen
+          state={{ kind: "failed", errorMessage: "Network unavailable" }}
+        />,
+      );
+      expect(tree.toJSON()).toMatchSnapshot();
+    });
+  });
+});

package/src/camera/__tests__/camera_permissions.test.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { Camera } from "react-native-vision-camera";
+import {
+  getCameraPermissionStatus,
+  requestCameraPermission,
+} from "../camera_permissions";
+
+// The shared setup mocks `react-native-vision-camera`; these are its
+// permission statics, re-armed per test.
+const getStatus = vi.mocked(Camera.getCameraPermissionStatus);
+const requestStatus = vi.mocked(Camera.requestCameraPermission);
+
+beforeEach(() => {
+  getStatus.mockReset();
+  requestStatus.mockReset();
+});
+
+describe("getCameraPermissionStatus", () => {
+  it("reports granted without prompting", async () => {
+    getStatus.mockReturnValue("granted");
+
+    await expect(getCameraPermissionStatus()).resolves.toBe("granted");
+    expect(requestStatus).not.toHaveBeenCalled();
+  });
+
+  it("normalises vision-camera's not-determined to undetermined", async () => {
+    getStatus.mockReturnValue("not-determined");
+
+    await expect(getCameraPermissionStatus()).resolves.toBe("undetermined");
+  });
+
+  it("reports denied as denied", async () => {
+    getStatus.mockReturnValue("denied");
+
+    await expect(getCameraPermissionStatus()).resolves.toBe("denied");
+  });
+
+  it("collapses restricted to denied so callers need only three branches", async () => {
+    getStatus.mockReturnValue("restricted");
+
+    await expect(getCameraPermissionStatus()).resolves.toBe("denied");
+  });
+});
+
+describe("requestCameraPermission", () => {
+  it("prompts and reports the granted outcome", async () => {
+    requestStatus.mockResolvedValue("granted");
+
+    await expect(requestCameraPermission()).resolves.toBe("granted");
+    expect(requestStatus).toHaveBeenCalledTimes(1);
+  });
+
+  it("reports a dismissed prompt as denied", async () => {
+    requestStatus.mockResolvedValue("denied");
+
+    await expect(requestCameraPermission()).resolves.toBe("denied");
+  });
+
+  it("maps a restricted device to denied rather than leaking the raw status", async () => {
+    requestStatus.mockResolvedValue("restricted");
+
+    await expect(requestCameraPermission()).resolves.toBe("denied");
+  });
+
+  it("never reports undetermined once the prompt has resolved granted", async () => {
+    requestStatus.mockResolvedValue("granted");
+
+    const status = await requestCameraPermission();
+
+    expect(status).not.toBe("undetermined");
+  });
+});

package/src/camera/__tests__/camera_system_focus.test.ts

@@ -0,0 +1,173 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+/**
+ * Tap-to-focus half of the camera orchestrator: the reticle state machine
+ * (`running` → `success` → `unspecified`), the vision-camera `focus()` call
+ * through the attached ref, and the fail-open behaviour on fixed-focus
+ * devices. The lifecycle half lives in `use_smile_id_camera_system.test.ts`.
+ */
+const { permissions, captureException } = vi.hoisted(() => ({
+  permissions: { getStatus: vi.fn(), request: vi.fn() },
+  captureException: vi.fn(),
+}));
+
+vi.mock("../camera_permissions", () => ({
+  getCameraPermissionStatus: permissions.getStatus,
+  requestCameraPermission: permissions.request,
+}));
+
+vi.mock("@smileid/usesmileid_bridge", async () => {
+  const actual = await vi.importActual<
+    typeof import("@smileid/usesmileid_bridge")
+  >("@smileid/usesmileid_bridge");
+  return {
+    ...actual,
+    UseSmileIDCrashReporting: {
+      ...actual.UseSmileIDCrashReporting,
+      captureException,
+    },
+  };
+});
+
+import type { Camera } from "react-native-vision-camera";
+import { CameraDefaults } from "../camera_defaults";
+import type { FocusState } from "../focus_state";
+import { UseSmileIDCameraSystem } from "../use_smile_id_camera_system";
+
+const POINT = { x: 0.25, y: 0.75 };
+
+function attachCamera(
+  system: UseSmileIDCameraSystem,
+  focus: (point: { x: number; y: number }) => Promise<void>,
+) {
+  const ref = { focus: vi.fn(focus) };
+  system.attachRef(ref as unknown as Camera);
+  return ref;
+}
+
+describe("UseSmileIDCameraSystem — tap to focus", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    permissions.getStatus.mockReset();
+    permissions.request.mockReset();
+    captureException.mockReset();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("drives the reticle through running → success → unspecified", async () => {
+    const system = new UseSmileIDCameraSystem();
+    const seen: FocusState[] = [];
+    system.subscribe((_state, focus) => seen.push(focus));
+
+    await system.tapToFocus(POINT);
+    expect(system.getFocusState()).toEqual({ kind: "running", point: POINT });
+
+    await vi.advanceTimersByTimeAsync(CameraDefaults.focusRunningDurationMs);
+    expect(system.getFocusState()).toEqual({ kind: "success", point: POINT });
+
+    await vi.advanceTimersByTimeAsync(CameraDefaults.focusSettledDurationMs);
+    expect(system.getFocusState()).toEqual({ kind: "unspecified" });
+
+    expect(seen.map((focus) => focus.kind)).toEqual([
+      "running",
+      "success",
+      "unspecified",
+    ]);
+  });
+
+  it("calls vision-camera focus() with the normalized point", async () => {
+    const system = new UseSmileIDCameraSystem();
+    const ref = attachCamera(system, async () => {});
+
+    await system.tapToFocus(POINT);
+
+    expect(ref.focus).toHaveBeenCalledWith({ x: 0.25, y: 0.75 });
+    expect(captureException).not.toHaveBeenCalled();
+  });
+
+  it("keeps the reticle moving when the lens rejects the focus request", async () => {
+    const system = new UseSmileIDCameraSystem();
+    const failure = new Error("fixed-focus front camera");
+    attachCamera(system, async () => {
+      throw failure;
+    });
+
+    await system.tapToFocus(POINT);
+
+    expect(captureException).toHaveBeenCalledWith(failure);
+    expect(system.getFocusState()).toEqual({ kind: "running", point: POINT });
+
+    await vi.advanceTimersByTimeAsync(CameraDefaults.focusRunningDurationMs);
+    expect(system.getFocusState().kind).toBe("success");
+  });
+
+  it("a second tap restarts the timers instead of stacking them", async () => {
+    const system = new UseSmileIDCameraSystem();
+    const secondPoint = { x: 0.9, y: 0.1 };
+
+    await system.tapToFocus(POINT);
+    await vi.advanceTimersByTimeAsync(
+      CameraDefaults.focusRunningDurationMs - 10,
+    );
+    await system.tapToFocus(secondPoint);
+
+    // The first tap's success timer was cleared — 10 ms in, still running.
+    await vi.advanceTimersByTimeAsync(10);
+    expect(system.getFocusState()).toEqual({
+      kind: "running",
+      point: secondPoint,
+    });
+
+    await vi.advanceTimersByTimeAsync(CameraDefaults.focusRunningDurationMs);
+    expect(system.getFocusState()).toEqual({
+      kind: "success",
+      point: secondPoint,
+    });
+  });
+
+  it("is a no-op after release(), and release() cancels pending reticle timers", async () => {
+    const system = new UseSmileIDCameraSystem();
+    const ref = attachCamera(system, async () => {});
+
+    await system.tapToFocus(POINT);
+    system.release();
+
+    await vi.advanceTimersByTimeAsync(
+      CameraDefaults.focusRunningDurationMs +
+        CameraDefaults.focusSettledDurationMs,
+    );
+    // The pending success/settled transitions were cancelled by release().
+    expect(system.getFocusState()).toEqual({ kind: "running", point: POINT });
+
+    ref.focus.mockClear();
+    await system.tapToFocus({ x: 0.5, y: 0.5 });
+    expect(ref.focus).not.toHaveBeenCalled();
+    expect(system.getFocusState()).toEqual({ kind: "running", point: POINT });
+  });
+
+  it("skips the native call when no camera ref is attached", async () => {
+    const system = new UseSmileIDCameraSystem();
+    system.attachRef(null);
+
+    await system.tapToFocus(POINT);
+
+    expect(captureException).not.toHaveBeenCalled();
+    await vi.advanceTimersByTimeAsync(CameraDefaults.focusRunningDurationMs);
+    expect(system.getFocusState().kind).toBe("success");
+  });
+
+  it("never lets a throwing subscriber break the dispatch chain", async () => {
+    const system = new UseSmileIDCameraSystem();
+    const healthy = vi.fn();
+    system.subscribe(() => {
+      throw new Error("partner overlay blew up");
+    });
+    system.subscribe(healthy);
+
+    await expect(system.tapToFocus(POINT)).resolves.toBeUndefined();
+    expect(healthy).toHaveBeenCalled();
+  });
+});