@smileid/usesmileid 12.0.0 → 12.0.2

package/src/camera/__tests__/use_smile_id_camera_preview.test.tsx

@@ -0,0 +1,461 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import * as React from "react";
+import { create as createRenderer, act } from "react-test-renderer";
+import { Pressable, View } from "react-native";
+import * as VisionCamera from "react-native-vision-camera";
+import { FrameProcessorPluginNotRegisteredException } from "@smileid/usesmileid_bridge";
+
+import { UseSmileIDCameraPreview } from "../use_smile_id_camera_preview";
+import { UseSmileIDCameraSystem } from "../use_smile_id_camera_system";
+import { CameraLens } from "../camera_lens";
+import { CameraDefaults } from "../camera_defaults";
+import type { CameraSystemState } from "../camera_configuration";
+import type { FocusState } from "../focus_state";
+
+/**
+ * Component-level tests for `<UseSmileIDCameraPreview>` — the seam
+ * between the camera orchestrator and vision-camera. The native
+ * bindings are mocked in `setup_react_native.ts`; these tests drive
+ * the boundary the preview owns: ref attach/detach, subscription
+ * fan-out, plugin initialisation + the missing-plugin error, the
+ * frame-processor worklet body, layout-normalised tap-to-focus, and
+ * the function-as-children overlay contract.
+ */
+
+const mockedUseCameraDevice = vi.mocked(VisionCamera.useCameraDevice);
+const mockedUseCameraFormat = vi.mocked(VisionCamera.useCameraFormat);
+const mockedUseFrameProcessor = vi.mocked(VisionCamera.useFrameProcessor);
+const mockedInitPlugin = vi.mocked(
+  VisionCamera.VisionCameraProxy.initFrameProcessorPlugin,
+);
+
+type CameraDevice = ReturnType<typeof VisionCamera.useCameraDevice>;
+
+const fakeDevice = {
+  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 CameraDevice;
+
+function render(element: React.ReactElement) {
+  let tree!: ReturnType<typeof createRenderer>;
+  act(() => {
+    tree = createRenderer(element);
+  });
+  return tree;
+}
+
+type CameraProps = {
+  readonly isActive: boolean;
+  readonly fps: number;
+  readonly photo: boolean;
+  readonly device: unknown;
+  readonly outputOrientation: string;
+  readonly format?: unknown;
+  readonly frameProcessor?: unknown;
+  readonly onOutputOrientationChanged: (orientation: string) => void;
+};
+
+function cameraProps(root: ReturnType<typeof render>["root"]): CameraProps {
+  return root.findByType(VisionCamera.Camera).props as unknown as CameraProps;
+}
+
+function findCameras(root: ReturnType<typeof render>["root"]) {
+  return root.findAllByType(VisionCamera.Camera);
+}
+
+/** Drives `onLayout` on the preview's root `<View>` so taps normalise. */
+function layout(
+  root: ReturnType<typeof render>["root"],
+  width: number,
+  height: number,
+) {
+  const view = root.findAllByType(View)[0];
+  act(() => {
+    (
+      view.props as {
+        onLayout: (event: {
+          nativeEvent: { layout: { width: number; height: number } };
+        }) => void;
+      }
+    ).onLayout({ nativeEvent: { layout: { width, height } } });
+  });
+}
+
+function tap(
+  root: ReturnType<typeof render>["root"],
+  locationX: number,
+  locationY: number,
+) {
+  const pressable = root.findAllByType(Pressable)[0];
+  act(() => {
+    (
+      pressable.props as {
+        onPress: (event: {
+          nativeEvent: { locationX: number; locationY: number };
+        }) => void;
+      }
+    ).onPress({ nativeEvent: { locationX, locationY } });
+  });
+}
+
+describe("UseSmileIDCameraPreview", () => {
+  beforeEach(() => {
+    mockedUseCameraDevice.mockReset();
+    mockedUseCameraDevice.mockReturnValue(fakeDevice);
+    mockedUseCameraFormat.mockReset();
+    mockedUseCameraFormat.mockReturnValue(
+      undefined as unknown as ReturnType<typeof VisionCamera.useCameraFormat>,
+    );
+    mockedUseFrameProcessor.mockReset();
+    mockedUseFrameProcessor.mockImplementation(
+      (worklet) =>
+        worklet as unknown as ReturnType<typeof VisionCamera.useFrameProcessor>,
+    );
+    mockedInitPlugin.mockReset();
+    mockedInitPlugin.mockReturnValue({
+      call: vi.fn(() => ({})),
+    } as unknown as ReturnType<
+      typeof VisionCamera.VisionCameraProxy.initFrameProcessorPlugin
+    >);
+  });
+
+  it("renders the camera for the system's current lens", () => {
+    const system = new UseSmileIDCameraSystem(CameraLens.back);
+    const { root } = render(<UseSmileIDCameraPreview cameraSystem={system} />);
+
+    expect(mockedUseCameraDevice).toHaveBeenCalledWith(CameraLens.back);
+    expect(cameraProps(root).photo).toBe(true);
+    expect(cameraProps(root).outputOrientation).toBe("device");
+  });
+
+  it("omits the camera entirely when no device is available", () => {
+    mockedUseCameraDevice.mockReturnValue(
+      undefined as unknown as CameraDevice as CameraDevice,
+    );
+    const system = new UseSmileIDCameraSystem();
+    const { root } = render(<UseSmileIDCameraPreview cameraSystem={system} />);
+
+    expect(findCameras(root)).toHaveLength(0);
+    // The tap surface still mounts so overlays render without a device.
+    expect(root.findAllByType(Pressable)).toHaveLength(1);
+  });
+
+  it("drives isActive off the system's streaming state", async () => {
+    const system = new UseSmileIDCameraSystem();
+    const { root } = render(<UseSmileIDCameraPreview cameraSystem={system} />);
+    expect(cameraProps(root).isActive).toBe(false);
+
+    await act(async () => {
+      await system.start();
+    });
+    expect(cameraProps(root).isActive).toBe(true);
+
+    act(() => {
+      system.stop();
+    });
+    expect(cameraProps(root).isActive).toBe(false);
+  });
+
+  it("pins the default fps and honours a configured override", () => {
+    const system = new UseSmileIDCameraSystem();
+    const first = render(<UseSmileIDCameraPreview cameraSystem={system} />);
+    expect(cameraProps(first.root).fps).toBe(CameraDefaults.analysisTargetFps);
+
+    const configured = new UseSmileIDCameraSystem();
+    configured.configure({ fps: 24 });
+    const second = render(
+      <UseSmileIDCameraPreview cameraSystem={configured} />,
+    );
+    expect(cameraProps(second.root).fps).toBe(24);
+  });
+
+  it("requests a 4:3 30fps analysis format and forwards it when resolved", () => {
+    const format = { videoWidth: 640, videoHeight: 480 };
+    mockedUseCameraFormat.mockReturnValue(
+      format as unknown as ReturnType<typeof VisionCamera.useCameraFormat>,
+    );
+    const system = new UseSmileIDCameraSystem();
+    const { root } = render(<UseSmileIDCameraPreview cameraSystem={system} />);
+
+    expect(mockedUseCameraFormat).toHaveBeenCalledWith(fakeDevice, [
+      { videoAspectRatio: 4 / 3 },
+      {
+        videoResolution: {
+          width: CameraDefaults.analysisTargetResolution.width,
+          height: CameraDefaults.analysisTargetResolution.height,
+        },
+      },
+      { fps: CameraDefaults.analysisTargetFps },
+    ]);
+    expect(cameraProps(root).format).toBe(format);
+  });
+
+  it("omits the format key entirely when none resolves", () => {
+    const system = new UseSmileIDCameraSystem();
+    const { root } = render(<UseSmileIDCameraPreview cameraSystem={system} />);
+    expect("format" in cameraProps(root)).toBe(false);
+  });
+
+  it("attaches the camera ref on mount and detaches it on unmount", () => {
+    const system = new UseSmileIDCameraSystem();
+    const attachRef = vi.spyOn(system, "attachRef");
+    const tree = render(<UseSmileIDCameraPreview cameraSystem={system} />);
+
+    expect(attachRef).toHaveBeenCalledTimes(1);
+    expect(attachRef.mock.calls[0]?.[0]).not.toBeNull();
+
+    act(() => {
+      tree.unmount();
+    });
+    expect(attachRef).toHaveBeenLastCalledWith(null);
+  });
+
+  it("unsubscribes from the system on unmount", () => {
+    const system = new UseSmileIDCameraSystem();
+    const unsubscribe = vi.fn();
+    vi.spyOn(system, "subscribe").mockReturnValue(unsubscribe);
+
+    const tree = render(<UseSmileIDCameraPreview cameraSystem={system} />);
+    expect(unsubscribe).not.toHaveBeenCalled();
+
+    act(() => {
+      tree.unmount();
+    });
+    expect(unsubscribe).toHaveBeenCalledTimes(1);
+  });
+
+  it("passes live state and focus state to function-as-children overlays", async () => {
+    const system = new UseSmileIDCameraSystem();
+    const seen: Array<{ state: CameraSystemState; focusState: FocusState }> =
+      [];
+    render(
+      <UseSmileIDCameraPreview cameraSystem={system}>
+        {(args) => {
+          seen.push(args);
+          return null;
+        }}
+      </UseSmileIDCameraPreview>,
+    );
+
+    expect(seen[0]?.state.isStreaming).toBe(false);
+    expect(seen[0]?.focusState.kind).toBe("unspecified");
+
+    await act(async () => {
+      await system.start();
+    });
+    const latest = seen[seen.length - 1];
+    expect(latest?.state.isStreaming).toBe(true);
+  });
+
+  it("renders plain node children inside the tap surface", () => {
+    const system = new UseSmileIDCameraSystem();
+    const { root } = render(
+      <UseSmileIDCameraPreview cameraSystem={system}>
+        <View testID="si_overlay" />
+      </UseSmileIDCameraPreview>,
+    );
+    expect(
+      root.findAllByProps({ testID: "si_overlay" }).length,
+    ).toBeGreaterThan(0);
+  });
+
+  it("normalises a tap into [0..1] focus coordinates after layout", () => {
+    const system = new UseSmileIDCameraSystem();
+    const tapToFocus = vi
+      .spyOn(system, "tapToFocus")
+      .mockResolvedValue(undefined);
+    const { root } = render(<UseSmileIDCameraPreview cameraSystem={system} />);
+
+    layout(root, 200, 400);
+    tap(root, 50, 100);
+
+    expect(tapToFocus).toHaveBeenCalledWith({ x: 0.25, y: 0.25 });
+  });
+
+  it("ignores taps before the preview has been laid out", () => {
+    const system = new UseSmileIDCameraSystem();
+    const tapToFocus = vi
+      .spyOn(system, "tapToFocus")
+      .mockResolvedValue(undefined);
+    const { root } = render(<UseSmileIDCameraPreview cameraSystem={system} />);
+
+    tap(root, 50, 100);
+    expect(tapToFocus).not.toHaveBeenCalled();
+
+    // A zero-height layout is still degenerate — division would be Infinity.
+    layout(root, 200, 0);
+    tap(root, 50, 100);
+    expect(tapToFocus).not.toHaveBeenCalled();
+  });
+
+  it("skips plugin initialisation when no frame analysis is supplied", () => {
+    const system = new UseSmileIDCameraSystem();
+    const { root } = render(<UseSmileIDCameraPreview cameraSystem={system} />);
+
+    expect(mockedInitPlugin).not.toHaveBeenCalled();
+    expect("frameProcessor" in cameraProps(root)).toBe(false);
+  });
+
+  it("initialises the named plugin and attaches a frame processor", () => {
+    const system = new UseSmileIDCameraSystem();
+    const onResult = vi.fn();
+    const { root } = render(
+      <UseSmileIDCameraPreview
+        cameraSystem={system}
+        frameAnalysis={{ pluginName: "UseSmileIDFaceScan", onResult }}
+      />,
+    );
+
+    expect(mockedInitPlugin).toHaveBeenCalledWith("UseSmileIDFaceScan", {});
+    expect(cameraProps(root).frameProcessor).toBeTypeOf("function");
+  });
+
+  it("forwards each frame's raw result to onResult with the device rotation", () => {
+    const call = vi.fn(() => ({ state: { type: "initial" } }));
+    mockedInitPlugin.mockReturnValue({ call } as unknown as ReturnType<
+      typeof VisionCamera.VisionCameraProxy.initFrameProcessorPlugin
+    >);
+    const system = new UseSmileIDCameraSystem();
+    const onResult = vi.fn();
+    const { root } = render(
+      <UseSmileIDCameraPreview
+        cameraSystem={system}
+        frameAnalysis={{ pluginName: "UseSmileIDFaceScan", onResult }}
+      />,
+    );
+
+    act(() => {
+      cameraProps(root).onOutputOrientationChanged("landscape-left");
+    });
+
+    const frame = { width: 640, height: 480 };
+    const worklet = cameraProps(root).frameProcessor as (
+      frame: unknown,
+    ) => void;
+    worklet(frame);
+
+    expect(call).toHaveBeenCalledWith(frame, { rotation: 90 });
+    expect(onResult).toHaveBeenCalledWith({ state: { type: "initial" } });
+  });
+
+  it("frame processor is inert when the plugin failed to initialise", () => {
+    mockedInitPlugin.mockReturnValue(
+      null as unknown as ReturnType<
+        typeof VisionCamera.VisionCameraProxy.initFrameProcessorPlugin
+      >,
+    );
+    const system = new UseSmileIDCameraSystem();
+    const onResult = vi.fn();
+    render(
+      <UseSmileIDCameraPreview
+        cameraSystem={system}
+        frameAnalysis={{ pluginName: "UseSmileIDFaceScan", onResult }}
+      />,
+    );
+
+    const worklet = mockedUseFrameProcessor.mock.calls[0]?.[0] as (
+      frame: unknown,
+    ) => void;
+    expect(() => worklet({ width: 1, height: 1 })).not.toThrow();
+    expect(onResult).not.toHaveBeenCalled();
+  });
+
+  it("reports a missing native plugin exactly once through onError", () => {
+    mockedInitPlugin.mockReturnValue(
+      null as unknown as ReturnType<
+        typeof VisionCamera.VisionCameraProxy.initFrameProcessorPlugin
+      >,
+    );
+    const system = new UseSmileIDCameraSystem();
+    const onError = vi.fn();
+    const frameAnalysis = {
+      pluginName: "UseSmileIDMissingPlugin",
+      onResult: vi.fn(),
+      onError,
+    };
+    const tree = render(
+      <UseSmileIDCameraPreview
+        cameraSystem={system}
+        frameAnalysis={frameAnalysis}
+      />,
+    );
+
+    expect(onError).toHaveBeenCalledTimes(1);
+    expect(onError.mock.calls[0]?.[0]).toBeInstanceOf(
+      FrameProcessorPluginNotRegisteredException,
+    );
+
+    // A re-render with the same plugin name must not re-fire.
+    act(() => {
+      tree.update(
+        <UseSmileIDCameraPreview
+          cameraSystem={system}
+          frameAnalysis={frameAnalysis}
+        />,
+      );
+    });
+    expect(onError).toHaveBeenCalledTimes(1);
+  });
+
+  it("stays silent when the plugin resolves", () => {
+    const system = new UseSmileIDCameraSystem();
+    const onError = vi.fn();
+    render(
+      <UseSmileIDCameraPreview
+        cameraSystem={system}
+        frameAnalysis={{
+          pluginName: "UseSmileIDFaceScan",
+          onResult: vi.fn(),
+          onError,
+        }}
+      />,
+    );
+    expect(onError).not.toHaveBeenCalled();
+  });
+
+  it("picks up a swapped onError handler without re-firing the effect", () => {
+    mockedInitPlugin.mockReturnValue(
+      null as unknown as ReturnType<
+        typeof VisionCamera.VisionCameraProxy.initFrameProcessorPlugin
+      >,
+    );
+    const system = new UseSmileIDCameraSystem();
+    const first = vi.fn();
+    const second = vi.fn();
+    const onResult = vi.fn();
+    const tree = render(
+      <UseSmileIDCameraPreview
+        cameraSystem={system}
+        frameAnalysis={{
+          pluginName: "UseSmileIDMissingPlugin",
+          onResult,
+          onError: first,
+        }}
+      />,
+    );
+    expect(first).toHaveBeenCalledTimes(1);
+
+    act(() => {
+      tree.update(
+        <UseSmileIDCameraPreview
+          cameraSystem={system}
+          frameAnalysis={{
+            pluginName: "UseSmileIDMissingPlugin",
+            onResult,
+            onError: second,
+          }}
+        />,
+      );
+    });
+    expect(second).not.toHaveBeenCalled();
+    expect(first).toHaveBeenCalledTimes(1);
+  });
+});

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

@@ -0,0 +1,103 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+/**
+ * Boundary characterization for `UseSmileIDCameraSystem`'s lifecycle state machine
+ * (permission gating, running/streaming flags, lens config, listener fan-out). The
+ * frame loop is a vision-camera worklet pinned separately by
+ * `use_smile_id_frame_stream.test.ts`. Must hold byte-identically across any
+ * camera-implementation swap.
+ */
+const permissions = vi.hoisted(() => ({
+  getStatus: vi.fn(),
+  request: vi.fn(),
+}));
+
+vi.mock("../camera_permissions", () => ({
+  getCameraPermissionStatus: permissions.getStatus,
+  requestCameraPermission: permissions.request,
+}));
+
+import { CameraLens } from "../camera_lens";
+import { UseSmileIDCameraSystem } from "../use_smile_id_camera_system";
+
+describe("UseSmileIDCameraSystem — boundary characterization", () => {
+  beforeEach(() => {
+    permissions.getStatus.mockReset();
+    permissions.request.mockReset();
+  });
+
+  it("starts idle with the configured lens", () => {
+    const system = new UseSmileIDCameraSystem(CameraLens.back);
+    const state = system.getState();
+    expect(state.isCameraRunning).toBe(false);
+    expect(state.isStreaming).toBe(false);
+    expect(state.hasPermission).toBe(false);
+    expect(state.currentLens).toBe(CameraLens.back);
+  });
+
+  it("start() runs + streams when permission is already granted (no re-prompt)", async () => {
+    permissions.getStatus.mockResolvedValue("granted");
+    const system = new UseSmileIDCameraSystem();
+    await system.start();
+    const state = system.getState();
+    expect(state.isCameraRunning).toBe(true);
+    expect(state.isStreaming).toBe(true);
+    expect(state.hasPermission).toBe(true);
+    expect(permissions.request).not.toHaveBeenCalled();
+  });
+
+  it("start() prompts when undetermined, then runs on grant", async () => {
+    permissions.getStatus.mockResolvedValue("undetermined");
+    permissions.request.mockResolvedValue("granted");
+    const system = new UseSmileIDCameraSystem();
+    await system.start();
+    expect(permissions.request).toHaveBeenCalledTimes(1);
+    expect(system.getState().isCameraRunning).toBe(true);
+  });
+
+  it("start() stays off when permission is denied", async () => {
+    permissions.getStatus.mockResolvedValue("undetermined");
+    permissions.request.mockResolvedValue("denied");
+    const system = new UseSmileIDCameraSystem();
+    await system.start();
+    const state = system.getState();
+    expect(state.isCameraRunning).toBe(false);
+    expect(state.hasPermission).toBe(false);
+  });
+
+  it("start() after release() throws — a released system is unusable", async () => {
+    permissions.getStatus.mockResolvedValue("granted");
+    const system = new UseSmileIDCameraSystem();
+    system.release();
+    await expect(system.start()).rejects.toThrow(/after release/);
+  });
+
+  it("stop() pauses running + streaming without releasing (re-startable)", async () => {
+    permissions.getStatus.mockResolvedValue("granted");
+    const system = new UseSmileIDCameraSystem();
+    await system.start();
+    system.stop();
+    const state = system.getState();
+    expect(state.isCameraRunning).toBe(false);
+    expect(state.isStreaming).toBe(false);
+  });
+
+  it("configure() swaps the lens and notifies subscribers", () => {
+    const system = new UseSmileIDCameraSystem(CameraLens.front);
+    const seenLenses: CameraLens[] = [];
+    system.subscribe((state) => seenLenses.push(state.currentLens));
+    system.configure({ lens: CameraLens.back });
+    expect(system.getState().currentLens).toBe(CameraLens.back);
+    expect(seenLenses).toContain(CameraLens.back);
+  });
+
+  it("unsubscribe stops further notifications", async () => {
+    permissions.getStatus.mockResolvedValue("granted");
+    const system = new UseSmileIDCameraSystem();
+    const listener = vi.fn();
+    const unsubscribe = system.subscribe(listener);
+    unsubscribe();
+    await system.start();
+    expect(listener).not.toHaveBeenCalled();
+  });
+});