@smileid/usesmileid 12.0.0 → 12.0.2

package/src/presentation/screen/__tests__/use_smile_id_capture_screen.test.tsx

@@ -11,19 +11,37 @@ import * as Brightness from "expo-brightness";
 import { StatusBar } from "react-native";
 import { UseSmileIDCaptureScreen } from "../use_smile_id_capture_screen";
 import { CaptureType } from "../../../core/models/ml_config";
+import { DocumentCaptureMode } from "../../../core/models/document_capture_mode";
+import { mockedTakePhoto } from "../../../__tests__/setup_react_native";
 import { enStrings } from "../../../l10n/strings_en";
 import {
-  ScanStateType,
+  UseSmileIDScanStateType,
   CaptureReadyEventKind,
 } from "@smileid/usesmileid_bridge";
 import type {
-  ScanState,
+  UseSmileIDScanState,
   CaptureReadyEvent,
   FaceScanResult,
 } from "@smileid/usesmileid_bridge";
+import { scriptedFaceScanResults } from "../../../testing/scripted_scan_results";
+import { parseScriptedScenario } from "../../../testing/scenario_loader";
 import { isSessionBoundary } from "../helpers/capture_ui_state";
 import { UseSmileIDFeedbackDebouncer } from "../helpers/feedback_debouncer";
 import { UseSmileIDMotion } from "../../theme/use_smile_id_motion";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+// The shared scenario set lives at the repo root (e2e/scenarios/), outside this
+// package's tsc rootDir (./src), so the test reads selfie-happy-path.json at run
+// time. These minimal ambient decls keep the read typed without pulling
+// @types/node in (which would collide with react-native's global timer types).
+declare module "node:fs" {
+  export function readFileSync(path: string, encoding: "utf8"): string;
+}
+declare module "node:path" {
+  export function dirname(path: string): string;
+  export function join(...parts: string[]): string;
+}
 
 // Capture the screen's per-frame `onResult` so tests can drive synthetic
 // sequences — the vision-camera worklet can't run in vitest, and `onResult`
@@ -195,6 +213,18 @@ describe("UseSmileIDCaptureScreen", () => {
     expect(mockedUseCameraDevice).toHaveBeenCalledWith("back");
   });
 
+  it("uses the back lens for an agent-mode selfie capture", () => {
+    const { root } = render(
+      <UseSmileIDCaptureScreen
+        analyzer={fakeAnalyzer}
+        captureType={CaptureType.selfie}
+        allowAgentMode
+      />,
+    );
+    expect(findByTestID(root, "si_capture_camera_preview")).not.toBeNull();
+    expect(mockedUseCameraDevice).toHaveBeenCalledWith("back");
+  });
+
   it("shows a placeholder (not the camera) when permission is undetermined", () => {
     const requestPermission = vi.fn(async () => true);
     mockedUseCameraPermission.mockReturnValue({
@@ -278,9 +308,9 @@ describe("UseSmileIDCaptureScreen", () => {
   // NOTE: the legacy `overlayState` / `captureProgress` prop-driven tests
   // were removed in Phase 3 of the per-frame migration. The capture
   // screen now owns its overlay state internally (derived from the
-  // analyzer's per-frame ScanState), so there's no external prop to
+  // analyzer's per-frame UseSmileIDScanState), so there's no external prop to
   // pin against. Phase 4 follow-up re-authors these as analyzer-driven
-  // tests that feed synthetic ScanState transitions through a mock
+  // tests that feed synthetic UseSmileIDScanState transitions through a mock
   // analyzer + frame stream.
 
   it("forwards the back tap to onBack when the back button is supplied", () => {
@@ -331,7 +361,7 @@ describe("UseSmileIDCaptureScreen", () => {
   });
 
   // Removed in Phase 3 — feedback text is now driven by the analyzer's
-  // ScanState rather than a partner-supplied overlayState prop. Phase 4
+  // UseSmileIDScanState rather than a partner-supplied overlayState prop. Phase 4
   // re-authors this against a mock analyzer that yields a synthetic
   // "found + feedback=si_capture_low_light" result through the
   // frame stream.
@@ -446,6 +476,18 @@ describe("UseSmileIDCaptureScreen", () => {
     expect(mockedSetBrightness).toHaveBeenCalledWith(1);
   });
 
+  it("asks for dark status-bar content, matching the white capture scrim", () => {
+    const { root } = render(
+      <UseSmileIDCaptureScreen
+        analyzer={fakeAnalyzer}
+        captureType={CaptureType.selfie}
+      />,
+    );
+    expect(root.findAllByType(StatusBar)[0]!.props.barStyle).toBe(
+      "dark-content",
+    );
+  });
+
   it("renders a translucent status bar so the preview is edge-to-edge", () => {
     // Translucent status bar = full-bleed window = full-screen oval reference.
     const { root } = render(
@@ -507,22 +549,22 @@ describe("UseSmileIDCaptureScreen", () => {
     // Stale events → unsatisfied reset (drops them) → fresh events → finished.
     emit({
       output,
-      state: { type: ScanStateType.Found },
+      state: { type: UseSmileIDScanStateType.Found },
       capturedEvents: [staleSelfie, staleLiveness],
     });
     emit({
       output,
-      state: { type: ScanStateType.Unsatisfied },
+      state: { type: UseSmileIDScanStateType.Unsatisfied },
       capturedEvents: [],
     });
     emit({
       output,
-      state: { type: ScanStateType.Found },
+      state: { type: UseSmileIDScanStateType.Found },
       capturedEvents: [freshSelfie, freshLiveness],
     });
     emit({
       output,
-      state: { type: ScanStateType.Finished },
+      state: { type: UseSmileIDScanStateType.Finished },
       capturedEvents: [],
     });
 
@@ -541,6 +583,58 @@ describe("UseSmileIDCaptureScreen", () => {
       expect.objectContaining({ retries: 1 }),
     );
   });
+
+  it("replays the shared selfie scenario to a full capture completion", async () => {
+    // Drives the capture gap headlessly through the frame stream's onResult
+    // seam: the shared scenario replayed to `finished` must reach
+    // onCaptureComplete with the scripted selfie + liveness events.
+    const onCaptureComplete = vi.fn();
+    const analyzer = makeFakeAnalyzer();
+    capturedOnResult = null;
+    render(
+      <UseSmileIDCaptureScreen
+        analyzer={analyzer}
+        captureType={CaptureType.selfie}
+        onCaptureComplete={onCaptureComplete}
+      />,
+    );
+    expect(capturedOnResult).not.toBeNull();
+
+    // Consume the real shared scenario (not a hand-written copy) so a drift in
+    // the canonical script is caught here rather than silently diverging.
+    const scenarioDir = dirname(import.meta.url.replace(/^file:\/\//, ""));
+    const scenario = parseScriptedScenario(
+      JSON.parse(
+        readFileSync(
+          join(
+            scenarioDir,
+            "../../../../../e2e/scenarios/selfie-happy-path.json",
+          ),
+          "utf8",
+        ),
+      ),
+    );
+    for (const result of scriptedFaceScanResults(scenario, {
+      livenessCount: 2,
+    })) {
+      act(() => {
+        capturedOnResult!(result);
+      });
+    }
+    await act(async () => {
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+
+    expect(onCaptureComplete).toHaveBeenCalledTimes(1);
+    const events = onCaptureComplete.mock.calls[0][0] as CaptureReadyEvent[];
+    expect(
+      events.filter((e) => e.kind === CaptureReadyEventKind.Selfie),
+    ).toHaveLength(1);
+    expect(
+      events.filter((e) => e.kind === CaptureReadyEventKind.Liveness),
+    ).toHaveLength(2);
+  });
 });
 
 /**
@@ -566,9 +660,9 @@ describe("session-boundary epoch reset — debouncer regression", () => {
       isImmediate: () => false,
     });
 
-    let previousScanState: ScanState | null = null;
+    let previousScanState: UseSmileIDScanState | null = null;
     const processTransition = (
-      nextScanState: ScanState,
+      nextScanState: UseSmileIDScanState,
       nextFeedbackKey: string,
     ) => {
       const boundary =
@@ -585,7 +679,7 @@ describe("session-boundary epoch reset — debouncer regression", () => {
 
     // found — smile key settles after the debounce window.
     processTransition(
-      { type: ScanStateType.Found, feedback: "si_capture_smile" },
+      { type: UseSmileIDScanStateType.Found, feedback: "si_capture_smile" },
       "si_capture_smile",
     );
     vi.advanceTimersByTime(UseSmileIDMotion.feedbackDebounce);
@@ -593,7 +687,7 @@ describe("session-boundary epoch reset — debouncer regression", () => {
 
     // Entering unsatisfied is not a boundary — no reset.
     processTransition(
-      { type: ScanStateType.Unsatisfied },
+      { type: UseSmileIDScanStateType.Unsatisfied },
       "si_selfie_capture_unsatisfied",
     );
     vi.advanceTimersByTime(UseSmileIDMotion.feedbackDebounce);
@@ -605,7 +699,7 @@ describe("session-boundary epoch reset — debouncer regression", () => {
     // Leaving unsatisfied is a boundary — without the reset the repeated
     // smile key would be suppressed as a duplicate.
     processTransition(
-      { type: ScanStateType.Found, feedback: "si_capture_smile" },
+      { type: UseSmileIDScanStateType.Found, feedback: "si_capture_smile" },
       "si_capture_smile",
     );
     // seed() emits synchronously; no timer advance needed.
@@ -615,4 +709,420 @@ describe("session-boundary epoch reset — debouncer regression", () => {
       "si_capture_smile",
     ]);
   });
+
+  // Document capture has no Start button, so a scan timeout has to leave the
+  // user a way forward — the sibling SDKs surface the manual shutter as the
+  // recovery affordance (their shared scan state sets `showCaptureButton` on
+  // the timeout state). Without these, a timed-out flow is a dead end: only
+  // Back and ✕ remain.
+  describe("document capture timeout recovery", () => {
+    function renderDocumentScreen(props: {
+      readonly captureMode: ReturnType<typeof DocumentCaptureMode.AutoCapture>;
+      readonly allowGalleryUpload?: boolean;
+    }) {
+      const tree = render(
+        <UseSmileIDCaptureScreen
+          analyzer={fakeAnalyzer}
+          captureType={CaptureType.document}
+          captureMode={props.captureMode}
+          allowGalleryUpload={props.allowGalleryUpload ?? true}
+        />,
+      );
+      // The overlay and its controls only mount once the canvas is measured;
+      // `onLayout` never fires under the test renderer, so drive it (landscape,
+      // as a document capture screen is).
+      act(() => {
+        findByTestID(tree.root, "si_capture_screen")!.props.onLayout({
+          nativeEvent: { layout: { width: 800, height: 400 } },
+        });
+      });
+      return tree;
+    }
+
+    function emitTimeout() {
+      expect(capturedOnResult).not.toBeNull();
+      act(() => {
+        capturedOnResult!({
+          output: { faces: [], brightness: 0 },
+          state: { type: UseSmileIDScanStateType.Timeout },
+          capturedEvents: [],
+        });
+      });
+    }
+
+    it("offers the manual shutter after a timeout, in every capture mode", () => {
+      const { root } = renderDocumentScreen({
+        captureMode: DocumentCaptureMode.AutoCapture,
+      });
+
+      emitTimeout();
+
+      expect(findByTestID(root, "si_document_manual_shutter")).not.toBeNull();
+    });
+
+    it("keeps the gallery button available after a timeout", () => {
+      const { root } = renderDocumentScreen({
+        captureMode: DocumentCaptureMode.AutoCaptureWithManualFallback({
+          activateManualAfterMs: 3000,
+        }),
+      });
+
+      emitTimeout();
+
+      expect(findByTestID(root, "si_document_gallery_upload")).not.toBeNull();
+    });
+
+    it("leaves the manual shutter usable after a timeout", () => {
+      const { root } = renderDocumentScreen({
+        captureMode: DocumentCaptureMode.ManualCapture,
+      });
+
+      emitTimeout();
+
+      const shutter = findByTestID(root, "si_document_manual_shutter");
+      expect(shutter).not.toBeNull();
+      // The timeout must not latch the one-shot delivery gate, or the button
+      // renders but does nothing.
+      act(() => {
+        shutter!.props.onPress();
+      });
+      expect(mockedTakePhoto).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("selfie capture timeout recovery", () => {
+    function renderSelfieScreen() {
+      return render(
+        <UseSmileIDCaptureScreen
+          analyzer={fakeAnalyzer}
+          captureType={CaptureType.selfie}
+        />,
+      );
+    }
+
+    function startCapture(root: ReactTestInstance) {
+      act(() => {
+        findByTestID(root, "si_capture_start_button")!.props.onClick();
+      });
+    }
+
+    function emit(state: UseSmileIDScanState) {
+      expect(capturedOnResult).not.toBeNull();
+      act(() => {
+        capturedOnResult!({
+          output: { faces: [], brightness: 0 },
+          state,
+          capturedEvents: [],
+        });
+      });
+    }
+
+    it("offers Start again after a timeout", () => {
+      const { root } = renderSelfieScreen();
+      startCapture(root);
+
+      emit({ type: UseSmileIDScanStateType.Timeout });
+
+      const start = findByTestID(root, "si_capture_start_button");
+      expect(start).not.toBeNull();
+      expect(start!.props.enabled).toBe(true);
+    });
+
+    it("resets the native session when Start is tapped after a timeout", async () => {
+      const { root } = renderSelfieScreen();
+      startCapture(root);
+      emit({ type: UseSmileIDScanStateType.Timeout });
+      fakeAnalyzer.reset.mockClear();
+
+      startCapture(root);
+      await act(async () => {
+        await Promise.resolve();
+      });
+
+      // The native session is terminal after a timeout — without a reset the
+      // first retry frame re-reports Timeout and re-latches the error.
+      expect(fakeAnalyzer.reset).toHaveBeenCalledTimes(1);
+    });
+
+    it("restarts the session when Start is tapped after a timeout", () => {
+      const onStartCapture = vi.fn();
+      const { root } = render(
+        <UseSmileIDCaptureScreen
+          analyzer={fakeAnalyzer}
+          captureType={CaptureType.selfie}
+          onStartCapture={onStartCapture}
+        />,
+      );
+      startCapture(root);
+      emit({ type: UseSmileIDScanStateType.Timeout });
+
+      startCapture(root);
+
+      expect(onStartCapture).toHaveBeenCalledTimes(2);
+    });
+
+    it("still delivers a capture that completes on the retry", async () => {
+      const onCaptureComplete = vi.fn();
+      const { root } = render(
+        <UseSmileIDCaptureScreen
+          analyzer={fakeAnalyzer}
+          captureType={CaptureType.selfie}
+          onCaptureComplete={onCaptureComplete}
+        />,
+      );
+      startCapture(root);
+      emit({ type: UseSmileIDScanStateType.Timeout });
+      startCapture(root);
+
+      emit({ type: UseSmileIDScanStateType.Finished });
+      await act(async () => {
+        await Promise.resolve();
+        await Promise.resolve();
+      });
+
+      expect(onCaptureComplete).toHaveBeenCalledTimes(1);
+    });
+
+    it("drops a capture that lands after the timeout was already reported", async () => {
+      const onCaptureComplete = vi.fn();
+      const onCaptureTimeout = vi.fn();
+      const { root } = render(
+        <UseSmileIDCaptureScreen
+          analyzer={fakeAnalyzer}
+          captureType={CaptureType.selfie}
+          onCaptureComplete={onCaptureComplete}
+          onCaptureTimeout={onCaptureTimeout}
+        />,
+      );
+      startCapture(root);
+
+      emit({ type: UseSmileIDScanStateType.Timeout });
+      emit({ type: UseSmileIDScanStateType.Finished });
+      await act(async () => {
+        await Promise.resolve();
+        await Promise.resolve();
+      });
+
+      expect(onCaptureTimeout).toHaveBeenCalledTimes(1);
+      expect(onCaptureComplete).not.toHaveBeenCalled();
+    });
+
+    it("does not pad the retry with frames banked before the timeout", async () => {
+      const onCaptureComplete = vi.fn();
+      const { root } = render(
+        <UseSmileIDCaptureScreen
+          analyzer={fakeAnalyzer}
+          captureType={CaptureType.selfie}
+          onCaptureComplete={onCaptureComplete}
+        />,
+      );
+      startCapture(root);
+      act(() => {
+        capturedOnResult!({
+          output: { faces: [], brightness: 0 },
+          state: { type: UseSmileIDScanStateType.Found },
+          capturedEvents: [
+            {
+              kind: CaptureReadyEventKind.Liveness,
+              captureIndex: 0,
+              url: "file:///stale.jpg",
+            },
+          ] as CaptureReadyEvent[],
+        });
+      });
+      emit({ type: UseSmileIDScanStateType.Timeout });
+
+      startCapture(root);
+      act(() => {
+        capturedOnResult!({
+          output: { faces: [], brightness: 0 },
+          state: { type: UseSmileIDScanStateType.Found },
+          capturedEvents: [
+            {
+              kind: CaptureReadyEventKind.Selfie,
+              captureIndex: 0,
+              url: "file:///fresh.jpg",
+            },
+          ] as CaptureReadyEvent[],
+        });
+      });
+      emit({ type: UseSmileIDScanStateType.Finished });
+      await act(async () => {
+        await Promise.resolve();
+        await Promise.resolve();
+      });
+
+      expect(onCaptureComplete).toHaveBeenCalledTimes(1);
+      const [delivered] = onCaptureComplete.mock.calls[0] as [
+        readonly CaptureReadyEvent[],
+      ];
+      expect(delivered.map((event) => event.url)).toEqual([
+        "file:///fresh.jpg",
+      ]);
+    });
+
+    it("reports the timeout to the partner exactly once", () => {
+      const onCaptureTimeout = vi.fn();
+      const { root } = render(
+        <UseSmileIDCaptureScreen
+          analyzer={fakeAnalyzer}
+          captureType={CaptureType.selfie}
+          onCaptureTimeout={onCaptureTimeout}
+        />,
+      );
+      startCapture(root);
+
+      emit({ type: UseSmileIDScanStateType.Timeout });
+      emit({ type: UseSmileIDScanStateType.Timeout });
+
+      expect(onCaptureTimeout).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("no camera frames at all", () => {
+    beforeEach(() => {
+      vi.useFakeTimers();
+    });
+
+    afterEach(() => {
+      vi.useRealTimers();
+    });
+
+    function renderAndStart() {
+      const tree = render(
+        <UseSmileIDCaptureScreen
+          analyzer={fakeAnalyzer}
+          captureType={CaptureType.selfie}
+        />,
+      );
+      act(() => {
+        findByTestID(tree.root, "si_capture_start_button")!.props.onClick();
+      });
+      return tree;
+    }
+
+    function elapseFirstFrameWait() {
+      act(() => {
+        vi.advanceTimersByTime(10_000);
+      });
+    }
+
+    it("names the cause instead of sitting on the initial instruction", () => {
+      const { root } = renderAndStart();
+
+      elapseFirstFrameWait();
+
+      expect(collectText(findByTestID(root, "si_capture_feedback_text")!)).toBe(
+        enStrings.si_capture_camera_unavailable,
+      );
+    });
+
+    it("leaves the user a way to retry", () => {
+      const { root } = renderAndStart();
+
+      elapseFirstFrameWait();
+
+      const start = findByTestID(root, "si_capture_start_button");
+      expect(start).not.toBeNull();
+      expect(start!.props.enabled).toBe(true);
+    });
+
+    it("reports a terminal timeout so the flow is not left waiting", () => {
+      const onCaptureTimeout = vi.fn();
+      const tree = render(
+        <UseSmileIDCaptureScreen
+          analyzer={fakeAnalyzer}
+          captureType={CaptureType.selfie}
+          onCaptureTimeout={onCaptureTimeout}
+        />,
+      );
+      act(() => {
+        findByTestID(tree.root, "si_capture_start_button")!.props.onClick();
+      });
+
+      elapseFirstFrameWait();
+
+      expect(onCaptureTimeout).toHaveBeenCalledTimes(1);
+    });
+
+    it("drops the stall copy once a frame finally arrives", () => {
+      const { root } = renderAndStart();
+      elapseFirstFrameWait();
+      expect(collectText(findByTestID(root, "si_capture_feedback_text")!)).toBe(
+        enStrings.si_capture_camera_unavailable,
+      );
+
+      act(() => {
+        capturedOnResult!({
+          output: { faces: [], brightness: 0 },
+          state: { type: UseSmileIDScanStateType.Initial },
+          capturedEvents: [],
+        });
+      });
+
+      expect(
+        collectText(findByTestID(root, "si_capture_feedback_text")!),
+      ).not.toBe(enStrings.si_capture_camera_unavailable);
+    });
+
+    it("still fires when the partner passes an inline callback", () => {
+      const onCaptureTimeout = vi.fn();
+      const screen = (
+        <UseSmileIDCaptureScreen
+          analyzer={fakeAnalyzer}
+          captureType={CaptureType.selfie}
+          onCaptureTimeout={(state) => onCaptureTimeout(state)}
+        />
+      );
+      const tree = render(screen);
+      act(() => {
+        findByTestID(tree.root, "si_capture_start_button")!.props.onClick();
+      });
+
+      for (let step = 0; step < 4; step += 1) {
+        act(() => {
+          tree.update(
+            <UseSmileIDCaptureScreen
+              analyzer={fakeAnalyzer}
+              captureType={CaptureType.selfie}
+              onCaptureTimeout={(state) => onCaptureTimeout(state)}
+            />,
+          );
+        });
+        act(() => {
+          vi.advanceTimersByTime(3_000);
+        });
+      }
+
+      expect(onCaptureTimeout).toHaveBeenCalledTimes(1);
+    });
+
+    it("stays quiet once a frame has been analyzed", () => {
+      const onCaptureTimeout = vi.fn();
+      const tree = render(
+        <UseSmileIDCaptureScreen
+          analyzer={fakeAnalyzer}
+          captureType={CaptureType.selfie}
+          onCaptureTimeout={onCaptureTimeout}
+        />,
+      );
+      act(() => {
+        findByTestID(tree.root, "si_capture_start_button")!.props.onClick();
+      });
+      act(() => {
+        capturedOnResult!({
+          output: { faces: [], brightness: 0 },
+          state: { type: UseSmileIDScanStateType.Initial },
+          capturedEvents: [],
+        });
+      });
+
+      elapseFirstFrameWait();
+
+      expect(onCaptureTimeout).not.toHaveBeenCalled();
+      expect(
+        collectText(findByTestID(tree.root, "si_capture_feedback_text")!),
+      ).not.toBe(enStrings.si_capture_camera_unavailable);
+    });
+  });
 });

package/src/presentation/screen/__tests__/use_smile_id_document_back_instructions.test.tsx

@@ -62,7 +62,9 @@ describe("UseSmileIDDocumentBackInstructions", () => {
       />,
     );
     expect(findByTestID(root, "si_document_back_instructions")).not.toBeNull();
-    expect(findTextNode(root, "Flip your Green Book")).not.toBeNull();
+    expect(
+      findTextNode(root, "Flip your \u2068Green Book\u2069"),
+    ).not.toBeNull();
   });
 
   it("invokes onCaptureBack from the primary button", () => {
@@ -104,7 +106,7 @@ describe("UseSmileIDDocumentBackInstructions", () => {
     const skip = findByTestID(root, "si_document_skip_back_button");
     expect(skip).not.toBeNull();
     act(() => {
-      (skip!.props.onPress as () => void)();
+      (skip!.props.onClick as () => void)();
     });
     expect(onSkip).toHaveBeenCalledTimes(1);
   });