@smileid/usesmileid 12.0.0-beta01

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

@@ -0,0 +1,616 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import * as React from "react";
+import {
+  create as createRenderer,
+  act,
+  type ReactTestInstance,
+} from "react-test-renderer";
+import { Pressable, Text } from "react-native";
+import * as VisionCamera from "react-native-vision-camera";
+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 { enStrings } from "../../../l10n/strings_en";
+import {
+  ScanStateType,
+  CaptureReadyEventKind,
+} from "@smileid/usesmileid_bridge";
+import type {
+  ScanState,
+  CaptureReadyEvent,
+  FaceScanResult,
+} from "@smileid/usesmileid_bridge";
+import { isSessionBoundary } from "../helpers/capture_ui_state";
+import { UseSmileIDFeedbackDebouncer } from "../helpers/feedback_debouncer";
+import { UseSmileIDMotion } from "../../theme/use_smile_id_motion";
+
+// Capture the screen's per-frame `onResult` so tests can drive synthetic
+// sequences — the vision-camera worklet can't run in vitest, and `onResult`
+// gets a validated result, so this bypasses only the native plugin.
+let capturedOnResult: ((result: FaceScanResult) => void) | null = null;
+vi.mock("../../../camera/use_smile_id_frame_stream", async () => {
+  const actual = await vi.importActual<
+    typeof import("../../../camera/use_smile_id_frame_stream")
+  >("../../../camera/use_smile_id_frame_stream");
+  return {
+    ...actual,
+    useSmileIDFrameStream: (
+      _analyzer: unknown,
+      onResult: (result: FaceScanResult) => void,
+    ) => {
+      capturedOnResult = onResult;
+      return { onFrameResult: () => {} };
+    },
+  };
+});
+
+/**
+ * Component-level tests for the capture screen:
+ *   - light-only theme on every leaf (forceLightMode propagation)
+ *   - camera preview rendered for the correct lens
+ *   - permission auto-request fires once on mount
+ *   - feedback string follows the overlay state
+ *   - start button only present in INSTRUCTION state, gated by readiness
+ *   - back button forwards taps
+ *   - brightness hook engaged on mount
+ *
+ * Mocks for `react-native-vision-camera`, `react-native-worklets-core`,
+ * `expo-brightness`, `expo-keep-awake` are installed in
+ * `setup_react_native.ts`. Tests reset the granted permission contract
+ * per-block.
+ */
+
+const mockedUseCameraPermission = vi.mocked(VisionCamera.useCameraPermission);
+const mockedUseCameraDevice = vi.mocked(VisionCamera.useCameraDevice);
+const mockedSetBrightness = vi.mocked(Brightness.setBrightnessAsync);
+const mockedGetBrightness = vi.mocked(Brightness.getBrightnessAsync);
+
+function render(element: React.ReactElement) {
+  let tree!: ReturnType<typeof createRenderer>;
+  act(() => {
+    tree = createRenderer(element);
+  });
+  return tree;
+}
+
+function findByTestID(
+  root: ReactTestInstance,
+  testID: string,
+): ReactTestInstance | null {
+  const matches = root.findAllByProps({ testID });
+  return matches[0] ?? null;
+}
+
+function findTextNode(
+  root: ReactTestInstance,
+  expected: string,
+): ReactTestInstance | null {
+  const matches = root.findAll(
+    (node) => {
+      if (node.type !== Text) return false;
+      return collectText(node).includes(expected);
+    },
+    { deep: true },
+  );
+  return matches[0] ?? null;
+}
+
+function collectText(node: ReactTestInstance): string {
+  return node.children
+    .map((child) =>
+      typeof child === "string"
+        ? child
+        : collectText(child as ReactTestInstance),
+    )
+    .join("");
+}
+
+// vision-camera's `CameraDevice` shape — only the fields the screen
+// touches need to be present for tests. The mock returns the same
+// device regardless of position; tests that care about the lens
+// inspect what `useCameraDevice` was called with instead.
+const fakeFrontDevice = {
+  id: "test-front",
+  position: "front" as const,
+  hasFlash: false,
+  hasTorch: false,
+  formats: [],
+  isMultiCam: false,
+  supportsRawCapture: false,
+  supportsLowLightBoost: false,
+  supportsFocus: true,
+  name: "Front Camera (test)",
+} as unknown as ReturnType<typeof VisionCamera.useCameraDevice>;
+
+// Minimal analyzer fixture — the screen reads `frameProcessorPluginName`
+// at render time (to initialise the native frame processor plugin) and
+// calls lifecycle methods from result callbacks. Tests that assert
+// flush/complete behaviour override `flush` per-test.
+function makeFakeAnalyzer() {
+  return {
+    kind: "face",
+    key: "mlkit-face",
+    frameProcessorPluginName: "UseSmileIDTestFrameProcessor",
+    configure: vi.fn(async () => {}),
+    reset: vi.fn(async () => {}),
+    flush: vi.fn(async () => {}),
+    close: vi.fn(async () => {}),
+  } as unknown as React.ComponentProps<
+    typeof UseSmileIDCaptureScreen
+  >["analyzer"];
+}
+const fakeAnalyzer = makeFakeAnalyzer();
+
+describe("UseSmileIDCaptureScreen", () => {
+  beforeEach(() => {
+    mockedGetBrightness.mockReset();
+    mockedGetBrightness.mockResolvedValue(0.5);
+    mockedSetBrightness.mockReset();
+    mockedSetBrightness.mockResolvedValue(undefined);
+    mockedUseCameraPermission.mockReset();
+    mockedUseCameraPermission.mockReturnValue({
+      hasPermission: true,
+      requestPermission: vi.fn(async () => true),
+    });
+    mockedUseCameraDevice.mockReset();
+    mockedUseCameraDevice.mockReturnValue(fakeFrontDevice);
+  });
+
+  it("renders the capture screen container", () => {
+    const { root } = render(
+      <UseSmileIDCaptureScreen
+        analyzer={fakeAnalyzer}
+        captureType={CaptureType.selfie}
+      />,
+    );
+    expect(findByTestID(root, "si_capture_screen")).not.toBeNull();
+  });
+
+  it("renders the camera preview when permission is granted", () => {
+    const { root } = render(
+      <UseSmileIDCaptureScreen
+        analyzer={fakeAnalyzer}
+        captureType={CaptureType.selfie}
+      />,
+    );
+    const preview = findByTestID(root, "si_capture_camera_preview");
+    expect(preview).not.toBeNull();
+    // Selfie capture uses the front lens; document uses back. The
+    // screen reads its device from `useCameraDevice(facing)` so the
+    // lens choice surfaces as the hook's argument, not a `<Camera>`
+    // prop.
+    expect(mockedUseCameraDevice).toHaveBeenCalledWith("front");
+  });
+
+  it("uses the back lens for document captures", () => {
+    const { root } = render(
+      <UseSmileIDCaptureScreen
+        analyzer={fakeAnalyzer}
+        captureType={CaptureType.document}
+      />,
+    );
+    const preview = findByTestID(root, "si_capture_camera_preview");
+    expect(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({
+      hasPermission: false,
+      requestPermission,
+    });
+
+    const { root } = render(
+      <UseSmileIDCaptureScreen
+        analyzer={fakeAnalyzer}
+        captureType={CaptureType.selfie}
+      />,
+    );
+    expect(findByTestID(root, "si_capture_camera_placeholder")).not.toBeNull();
+    expect(findByTestID(root, "si_capture_camera_preview")).toBeNull();
+  });
+
+  it("auto-requests permission once when undetermined", () => {
+    const requestPermission = vi.fn(async () => true);
+    mockedUseCameraPermission.mockReturnValue({
+      hasPermission: false,
+      requestPermission,
+    });
+
+    render(
+      <UseSmileIDCaptureScreen
+        analyzer={fakeAnalyzer}
+        captureType={CaptureType.selfie}
+      />,
+    );
+
+    expect(requestPermission).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not re-prompt when permission is granted", () => {
+    const requestPermission = vi.fn(async () => true);
+    mockedUseCameraPermission.mockReturnValue({
+      hasPermission: true,
+      requestPermission,
+    });
+
+    render(
+      <UseSmileIDCaptureScreen
+        analyzer={fakeAnalyzer}
+        captureType={CaptureType.selfie}
+      />,
+    );
+    expect(requestPermission).not.toHaveBeenCalled();
+  });
+
+  it("renders the start button enabled in INSTRUCTION state", () => {
+    const { root } = render(
+      <UseSmileIDCaptureScreen
+        analyzer={fakeAnalyzer}
+        captureType={CaptureType.selfie}
+      />,
+    );
+    const start = findByTestID(root, "si_capture_start_button");
+    expect(start).not.toBeNull();
+    // INSTRUCTION is the *only* state where Start Capture renders, and
+    // it's the user's affirmative action to begin the analyzer
+    // pipeline — so it must be enabled. Disabled-during-INSTRUCTION
+    // would leave the user with no way to advance the flow.
+    expect(start!.props.enabled).toBe(true);
+  });
+
+  it("does not begin capture on mount — it waits for the Start tap", () => {
+    // Capture never auto-begins; the user must tap Start (parity across
+    // SDKs), so onStartCapture does not fire on mount.
+    const onStartCapture = vi.fn();
+    render(
+      <UseSmileIDCaptureScreen
+        analyzer={fakeAnalyzer}
+        captureType={CaptureType.selfie}
+        onStartCapture={onStartCapture}
+      />,
+    );
+    expect(onStartCapture).not.toHaveBeenCalled();
+  });
+
+  // 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
+  // pin against. Phase 4 follow-up re-authors these as analyzer-driven
+  // tests that feed synthetic ScanState transitions through a mock
+  // analyzer + frame stream.
+
+  it("forwards the back tap to onBack when the back button is supplied", () => {
+    const onBack = vi.fn();
+    const { root } = render(
+      <UseSmileIDCaptureScreen
+        analyzer={fakeAnalyzer}
+        captureType={CaptureType.selfie}
+        onBack={onBack}
+      />,
+    );
+    const back = findByTestID(root, "si_capture_back_button");
+    expect(back).not.toBeNull();
+    act(() => {
+      (back!.props.onClick as () => void)();
+    });
+    expect(onBack).toHaveBeenCalledTimes(1);
+  });
+
+  it("omits the back button when onBack isn't supplied", () => {
+    const { root } = render(
+      <UseSmileIDCaptureScreen
+        analyzer={fakeAnalyzer}
+        captureType={CaptureType.selfie}
+      />,
+    );
+    expect(findByTestID(root, "si_capture_back_button")).toBeNull();
+  });
+
+  it("forces light mode on the back button, start button, and attribution", () => {
+    const { root } = render(
+      <UseSmileIDCaptureScreen
+        analyzer={fakeAnalyzer}
+        captureType={CaptureType.selfie}
+        onBack={() => {}}
+      />,
+    );
+    expect(
+      findByTestID(root, "si_capture_back_button")!.props.forceLightMode,
+    ).toBe(true);
+    expect(
+      findByTestID(root, "si_capture_start_button")!.props.forceLightMode,
+    ).toBe(true);
+    // Attribution renders the SVG with accessibilityLabel "Powered by Smile ID".
+    expect(
+      root.findAllByProps({ accessibilityLabel: "Powered by Smile ID" })[0],
+    ).toBeTruthy();
+  });
+
+  // Removed in Phase 3 — feedback text is now driven by the analyzer's
+  // ScanState 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.
+
+  it("hides attribution when showAttribution is false", () => {
+    const { root } = render(
+      <UseSmileIDCaptureScreen
+        analyzer={fakeAnalyzer}
+        captureType={CaptureType.selfie}
+        showAttribution={false}
+      />,
+    );
+    expect(
+      root.findAllByProps({ accessibilityLabel: "Powered by Smile ID" }),
+    ).toHaveLength(0);
+  });
+
+  it("forwards onStartCapture from a slot button tapped during INSTRUCTION", () => {
+    // The Start Capture button begins the analyzer pipeline. During
+    // INSTRUCTION (the only state where the slot renders), tapping
+    // the partner-supplied control must forward through to
+    // `onStartCapture` so the orchestrator can advance the flow.
+    const onStartCapture = vi.fn();
+    const { root } = render(
+      <UseSmileIDCaptureScreen
+        analyzer={fakeAnalyzer}
+        captureType={CaptureType.selfie}
+        onStartCapture={onStartCapture}
+        startButton={({ onClick }) => (
+          <Pressable testID="si_custom_start" onPress={onClick}>
+            <Text>Go</Text>
+          </Pressable>
+        )}
+      />,
+    );
+
+    act(() => {
+      (findByTestID(root, "si_custom_start")!.props.onPress as () => void)();
+    });
+    expect(onStartCapture).toHaveBeenCalledTimes(1);
+  });
+
+  it("renders a partner-supplied start button slot in INSTRUCTION state", () => {
+    const onStartCapture = vi.fn();
+    const { root } = render(
+      <UseSmileIDCaptureScreen
+        analyzer={fakeAnalyzer}
+        captureType={CaptureType.selfie}
+        onStartCapture={onStartCapture}
+        startButton={({ onClick, enabled }) => (
+          <Pressable
+            testID="si_custom_start"
+            onPress={onClick}
+            accessibilityState={{ disabled: !enabled }}
+          >
+            <Text>Go</Text>
+          </Pressable>
+        )}
+      />,
+    );
+    const slot = findByTestID(root, "si_custom_start");
+    expect(slot).not.toBeNull();
+    // Slot only renders during INSTRUCTION, where the analyzer
+    // hasn't started yet — `enabled` propagates as true.
+    expect(slot!.props.accessibilityState.disabled).toBe(false);
+    // Default start button must NOT also render — concrete scenario:
+    // a future refactor that double-renders both would silently stack.
+    expect(findByTestID(root, "si_capture_start_button")).toBeNull();
+  });
+
+  it("primes the guidance with the standard instruction before the first frame", () => {
+    const { root } = render(
+      <UseSmileIDCaptureScreen
+        analyzer={fakeAnalyzer}
+        captureType={CaptureType.selfie}
+      />,
+    );
+    const text = findByTestID(root, "si_capture_feedback_text");
+    // Pre-capture shows the press-Start instruction — the visible
+    // Start Capture button is the next action.
+    expect(collectText(text!)).toBe(enStrings.si_start_capture_instruction);
+  });
+
+  it("primes the guidance with the press-Start copy under Enhanced Smart Selfie too", () => {
+    // The ESS head-turn primer belongs to the scanning Initial state;
+    // pre-capture shows the press-Start instruction in both modes.
+    const { root } = render(
+      <UseSmileIDCaptureScreen
+        analyzer={fakeAnalyzer}
+        captureType={CaptureType.selfie}
+        enableEnhancedLiveness
+      />,
+    );
+    const text = findByTestID(root, "si_capture_feedback_text");
+    expect(collectText(text!)).toBe(enStrings.si_start_capture_instruction);
+  });
+
+  it("engages the brightness hook on mount", async () => {
+    render(
+      <UseSmileIDCaptureScreen
+        analyzer={fakeAnalyzer}
+        captureType={CaptureType.selfie}
+      />,
+    );
+    // The hook awaits getBrightness before issuing setBrightness.
+    // Two microtask flushes drain the chain.
+    await act(async () => {
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+    expect(mockedGetBrightness).toHaveBeenCalledTimes(1);
+    expect(mockedSetBrightness).toHaveBeenCalledWith(1);
+  });
+
+  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(
+      <UseSmileIDCaptureScreen
+        analyzer={fakeAnalyzer}
+        captureType={CaptureType.selfie}
+      />,
+    );
+    const statusBar = root.findAllByType(StatusBar)[0];
+    expect(statusBar).toBeTruthy();
+    expect(statusBar!.props.translucent).toBe(true);
+  });
+
+  it("drops capture events accumulated before an unsatisfied reset", async () => {
+    // Regression: events accumulated before an `unsatisfied` reset are stale
+    // and must not reach the submission set — only post-reset events should.
+    const onCaptureComplete = vi.fn();
+    let resolveFlush!: () => void;
+    const analyzer = makeFakeAnalyzer();
+    // flush() gates onCaptureComplete; resolve it manually to control timing.
+    vi.mocked(analyzer.flush).mockReturnValue(
+      new Promise<void>((resolve) => {
+        resolveFlush = resolve;
+      }),
+    );
+
+    // Reset so the assertion below proves THIS render registered the
+    // callback, not a leftover from an earlier test.
+    capturedOnResult = null;
+    render(
+      <UseSmileIDCaptureScreen
+        analyzer={analyzer}
+        captureType={CaptureType.selfie}
+        onCaptureComplete={onCaptureComplete}
+      />,
+    );
+    expect(capturedOnResult).not.toBeNull();
+    const emit = (result: FaceScanResult) => {
+      act(() => {
+        capturedOnResult!(result);
+      });
+    };
+
+    const output = { faces: [], brightness: 0 };
+    const event = (
+      kind: CaptureReadyEvent["kind"],
+      captureIndex: number,
+    ): CaptureReadyEvent => ({
+      kind,
+      captureIndex,
+      url: `file://${kind}-${captureIndex}`,
+    });
+
+    const staleSelfie = event(CaptureReadyEventKind.Selfie, 0);
+    const staleLiveness = event(CaptureReadyEventKind.Liveness, 0);
+    const freshSelfie = event(CaptureReadyEventKind.Selfie, 1);
+    const freshLiveness = event(CaptureReadyEventKind.Liveness, 1);
+
+    // Stale events → unsatisfied reset (drops them) → fresh events → finished.
+    emit({
+      output,
+      state: { type: ScanStateType.Found },
+      capturedEvents: [staleSelfie, staleLiveness],
+    });
+    emit({
+      output,
+      state: { type: ScanStateType.Unsatisfied },
+      capturedEvents: [],
+    });
+    emit({
+      output,
+      state: { type: ScanStateType.Found },
+      capturedEvents: [freshSelfie, freshLiveness],
+    });
+    emit({
+      output,
+      state: { type: ScanStateType.Finished },
+      capturedEvents: [],
+    });
+
+    await act(async () => {
+      resolveFlush();
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+
+    expect(onCaptureComplete).toHaveBeenCalledTimes(1);
+    // Only the post-reset events survive — the stale ones were cleared.
+    expect(onCaptureComplete).toHaveBeenCalledWith([
+      freshSelfie,
+      freshLiveness,
+    ]);
+  });
+});
+
+/**
+ * Session-boundary debouncer regression, exercised on
+ * `UseSmileIDFeedbackDebouncer` directly because the route harness
+ * cannot drive multi-step scan-state sequences. Mirrors the capture
+ * screen's frame-result callback: `isSessionBoundary` decides when to
+ * `reset()` + `seed()`.
+ */
+describe("session-boundary epoch reset — debouncer regression", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("re-emits the smile key after an unsatisfied reset clears the debouncer", () => {
+    const emitted: string[] = [];
+    const debouncer = new UseSmileIDFeedbackDebouncer<string>({
+      emit: (value) => emitted.push(value),
+      delayMs: UseSmileIDMotion.feedbackDebounce,
+      isImmediate: () => false,
+    });
+
+    let previousScanState: ScanState | null = null;
+    const processTransition = (
+      nextScanState: ScanState,
+      nextFeedbackKey: string,
+    ) => {
+      const boundary =
+        previousScanState !== null &&
+        isSessionBoundary(previousScanState, nextScanState);
+      previousScanState = nextScanState;
+      if (boundary) {
+        debouncer.reset();
+        debouncer.seed(nextFeedbackKey);
+      } else {
+        debouncer.publish(nextFeedbackKey);
+      }
+    };
+
+    // found — smile key settles after the debounce window.
+    processTransition(
+      { type: ScanStateType.Found, feedback: "si_capture_smile" },
+      "si_capture_smile",
+    );
+    vi.advanceTimersByTime(UseSmileIDMotion.feedbackDebounce);
+    expect(emitted).toEqual(["si_capture_smile"]);
+
+    // Entering unsatisfied is not a boundary — no reset.
+    processTransition(
+      { type: ScanStateType.Unsatisfied },
+      "si_selfie_capture_unsatisfied",
+    );
+    vi.advanceTimersByTime(UseSmileIDMotion.feedbackDebounce);
+    expect(emitted).toEqual([
+      "si_capture_smile",
+      "si_selfie_capture_unsatisfied",
+    ]);
+
+    // 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" },
+      "si_capture_smile",
+    );
+    // seed() emits synchronously; no timer advance needed.
+    expect(emitted).toEqual([
+      "si_capture_smile",
+      "si_selfie_capture_unsatisfied",
+      "si_capture_smile",
+    ]);
+  });
+});