@smileid/usesmileid 12.0.0 → 12.0.2

package/src/presentation/flow/screen/__tests__/orchestrated_consent_screen.test.tsx

@@ -0,0 +1,165 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import * as React from "react";
+import { create as createRenderer, act } from "react-test-renderer";
+
+// `vi.mock` is hoisted above the imports, so anything its factory closes over
+// must be created with `vi.hoisted` or it is still in the TDZ when the factory
+// runs.
+const { captureException, screenProps } = vi.hoisted(() => ({
+  captureException: vi.fn(),
+  screenProps: { current: {} as Record<string, unknown> },
+}));
+
+vi.mock("@smileid/usesmileid_bridge", async () => {
+  const actual =
+    await vi.importActual<typeof import("@smileid/usesmileid_bridge")>(
+      "@smileid/usesmileid_bridge",
+    );
+  return {
+    ...actual,
+    UseSmileIDCrashReporting: { captureException },
+  };
+});
+
+// Stand in for the leaf screen so these tests exercise the orchestration
+// (consent storage, partner hook, navigation) rather than re-testing the
+// consent UI, which has its own component suite.
+vi.mock("../../../screen/use_smile_id_consent_screen", () => ({
+  UseSmileIDConsentScreen: (props: Record<string, unknown>) => {
+    screenProps.current = props;
+    return null;
+  },
+}));
+
+import { OrchestratedConsentScreen } from "../orchestrated_consent_screen";
+import { FlowNavigationProvider } from "../../flow_navigation_context";
+import { ConsentDeniedException } from "../../../../core/exception";
+import { GlobalPrivacyControl } from "../../../../core/models/global_privacy_control";
+import type { FlowNavigationManager } from "../../flow_navigation_manager";
+import type { ConsentInformation } from "../../../../core/models/params";
+
+function makeManager(overrides: Record<string, unknown> = {}) {
+  return {
+    setConsent: vi.fn(),
+    exit: vi.fn(),
+    navigateToNext: vi.fn(),
+    navigateBack: vi.fn(),
+    configuration: { config: {} },
+    ...overrides,
+  } as unknown as FlowNavigationManager & {
+    setConsent: ReturnType<typeof vi.fn>;
+    exit: ReturnType<typeof vi.fn>;
+    navigateToNext: ReturnType<typeof vi.fn>;
+  };
+}
+
+function renderWith(
+  manager: FlowNavigationManager,
+  configuration: Record<string, unknown> = {},
+) {
+  act(() => {
+    createRenderer(
+      <FlowNavigationProvider manager={manager}>
+        <OrchestratedConsentScreen
+          configuration={
+            configuration as React.ComponentProps<
+              typeof OrchestratedConsentScreen
+            >["configuration"]
+          }
+        />
+      </FlowNavigationProvider>,
+    );
+  });
+}
+
+const consent: ConsentInformation = {
+  consentGrantedDate: "2026-07-30T00:00:00.000Z",
+  personalDetailsConsentGranted: true,
+  contactInformationConsentGranted: true,
+  documentInformationConsentGranted: true,
+} as ConsentInformation;
+
+describe("OrchestratedConsentScreen", () => {
+  beforeEach(() => {
+    captureException.mockClear();
+  });
+
+  it("stores consent before advancing so the next screen can read it", () => {
+    const manager = makeManager();
+    const order: string[] = [];
+    (manager.setConsent as ReturnType<typeof vi.fn>).mockImplementation(() =>
+      order.push("setConsent"),
+    );
+    (manager.navigateToNext as ReturnType<typeof vi.fn>).mockImplementation(
+      () => order.push("navigateToNext"),
+    );
+
+    renderWith(manager, { partnerName: "Acme" });
+    (screenProps.current.onAllow as (c: ConsentInformation) => void)(consent);
+
+    expect(manager.setConsent).toHaveBeenCalledWith(consent);
+    expect(order).toEqual(["setConsent", "navigateToNext"]);
+  });
+
+  it("fires the partner onConsentGranted hook with the consent payload", () => {
+    const manager = makeManager();
+    const onConsentGranted = vi.fn();
+
+    renderWith(manager, { partnerName: "Acme", onConsentGranted });
+    (screenProps.current.onAllow as (c: ConsentInformation) => void)(consent);
+
+    expect(onConsentGranted).toHaveBeenCalledWith(consent);
+    expect(manager.navigateToNext).toHaveBeenCalled();
+  });
+
+  it("a throwing partner hook is captured and still advances the flow", () => {
+    const manager = makeManager();
+    const boom = new Error("partner analytics is down");
+    const onConsentGranted = vi.fn(() => {
+      throw boom;
+    });
+
+    renderWith(manager, { partnerName: "Acme", onConsentGranted });
+    expect(() =>
+      (screenProps.current.onAllow as (c: ConsentInformation) => void)(consent),
+    ).not.toThrow();
+
+    expect(captureException).toHaveBeenCalledWith(boom);
+    expect(manager.navigateToNext).toHaveBeenCalled();
+  });
+
+  it("deny exits with a typed ConsentDeniedException", () => {
+    const manager = makeManager();
+
+    renderWith(manager, { partnerName: "Acme" });
+    (screenProps.current.onDeny as () => void)();
+
+    expect(manager.navigateToNext).not.toHaveBeenCalled();
+    const [[arg]] = (manager.exit as ReturnType<typeof vi.fn>).mock.calls;
+    expect(arg.kind).toBe("failed");
+    expect(arg.error).toBeInstanceOf(ConsentDeniedException);
+  });
+
+  it("defaults globalPrivacyControl to OptOut when the flow config omits it", () => {
+    renderWith(makeManager(), { partnerName: "Acme" });
+    expect(screenProps.current.globalPrivacyControl).toBe(
+      GlobalPrivacyControl.OptOut,
+    );
+  });
+
+  it("honours an explicit globalPrivacyControl from the flow config", () => {
+    const manager = makeManager({
+      configuration: { config: { globalPrivacyControl: GlobalPrivacyControl.OptIn } },
+    });
+    renderWith(manager, { partnerName: "Acme" });
+    expect(screenProps.current.globalPrivacyControl).toBe(
+      GlobalPrivacyControl.OptIn,
+    );
+  });
+
+  it("omits optional partner props entirely when unset", () => {
+    renderWith(makeManager(), { partnerName: "Acme" });
+    expect("partnerIcon" in screenProps.current).toBe(false);
+    expect("partnerPrivacyPolicyUrl" in screenProps.current).toBe(false);
+  });
+});

package/src/presentation/flow/screen/__tests__/orchestrated_instructions_screen.test.tsx

@@ -0,0 +1,163 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import * as React from "react";
+import { create as createRenderer, act } from "react-test-renderer";
+
+// `vi.mock` hoists above the imports, so its captured values must come from
+// `vi.hoisted` or they are still in the TDZ when the factory runs.
+const { getStatus, requestPermission, screenProps } = vi.hoisted(() => ({
+  getStatus: vi.fn(),
+  requestPermission: vi.fn(),
+  screenProps: { current: {} as Record<string, unknown> },
+}));
+
+vi.mock("../../../../camera/camera_permissions", () => ({
+  getCameraPermissionStatus: getStatus,
+  requestCameraPermission: requestPermission,
+}));
+
+// Stand in for the leaf screen: these tests cover the permission gate and the
+// config resolution, not the instructions UI (which has its own suite).
+vi.mock("../../../screen/use_smile_id_instructions_screen", () => ({
+  UseSmileIDInstructionsScreen: (props: Record<string, unknown>) => {
+    screenProps.current = props;
+    return null;
+  },
+}));
+
+import { OrchestratedInstructionsScreen } from "../orchestrated_instructions_screen";
+import { FlowNavigationProvider } from "../../flow_navigation_context";
+import type { FlowNavigationManager } from "../../flow_navigation_manager";
+
+const onNavigateNext = vi.fn();
+const onBack = vi.fn();
+
+function makeManager(overrides: Record<string, unknown> = {}) {
+  return {
+    navigateToNext: onNavigateNext,
+    navigateBack: onBack,
+    enhancedLivenessEnabled: false,
+    documentType: undefined,
+    configuration: { config: {} },
+    ...overrides,
+  } as unknown as FlowNavigationManager;
+}
+
+function renderWith(
+  manager: FlowNavigationManager,
+  configuration: Record<string, unknown> = {},
+) {
+  act(() => {
+    createRenderer(
+      <FlowNavigationProvider manager={manager}>
+        <OrchestratedInstructionsScreen
+          configuration={
+            configuration as React.ComponentProps<
+              typeof OrchestratedInstructionsScreen
+            >["configuration"]
+          }
+        />
+      </FlowNavigationProvider>,
+    );
+  });
+}
+
+async function pressContinue() {
+  await act(async () => {
+    await (screenProps.current.onContinue as () => Promise<void>)();
+  });
+}
+
+describe("OrchestratedInstructionsScreen permission gate", () => {
+  beforeEach(() => {
+    getStatus.mockReset();
+    requestPermission.mockReset();
+    onNavigateNext.mockReset();
+    onBack.mockReset();
+  });
+
+  it("advances without prompting when permission is already granted", async () => {
+    getStatus.mockResolvedValue("granted");
+    renderWith(makeManager());
+
+    await pressContinue();
+
+    expect(requestPermission).not.toHaveBeenCalled();
+    expect(onNavigateNext).toHaveBeenCalledTimes(1);
+  });
+
+  it("prompts and advances when the user grants on request", async () => {
+    getStatus.mockResolvedValue("undetermined");
+    requestPermission.mockResolvedValue("granted");
+    renderWith(makeManager());
+
+    await pressContinue();
+
+    expect(requestPermission).toHaveBeenCalledTimes(1);
+    expect(onNavigateNext).toHaveBeenCalledTimes(1);
+  });
+
+  it("stays on the screen when the user denies — never enters a camera screen without permission", async () => {
+    getStatus.mockResolvedValue("undetermined");
+    requestPermission.mockResolvedValue("denied");
+    renderWith(makeManager());
+
+    await pressContinue();
+
+    expect(requestPermission).toHaveBeenCalledTimes(1);
+    expect(onNavigateNext).not.toHaveBeenCalled();
+  });
+
+  it("re-prompts rather than advancing when the status is already denied", async () => {
+    getStatus.mockResolvedValue("denied");
+    requestPermission.mockResolvedValue("denied");
+    renderWith(makeManager());
+
+    await pressContinue();
+
+    expect(requestPermission).toHaveBeenCalledTimes(1);
+    expect(onNavigateNext).not.toHaveBeenCalled();
+  });
+});
+
+describe("OrchestratedInstructionsScreen config resolution", () => {
+  beforeEach(() => {
+    getStatus.mockResolvedValue("granted");
+    onNavigateNext.mockReset();
+  });
+
+  it("suppresses the hero oval progress ring when enhanced liveness is on", () => {
+    renderWith(makeManager({ enhancedLivenessEnabled: true }));
+    expect(screenProps.current.showHeroOvalProgress).toBe(false);
+  });
+
+  it("keeps the hero oval progress ring for the standard selfie flow", () => {
+    renderWith(makeManager({ enhancedLivenessEnabled: false }));
+    expect(screenProps.current.showHeroOvalProgress).toBe(true);
+  });
+
+  it("passes onBack straight through to the leaf screen", () => {
+    renderWith(makeManager());
+    expect(typeof screenProps.current.onBack).toBe("function");
+  });
+
+  it("omits the continueButton slot when the partner supplies none", () => {
+    renderWith(makeManager());
+    expect("continueButton" in screenProps.current).toBe(false);
+  });
+
+  it("adapts a partner continueButton slot to the leaf screen's shape", () => {
+    const continueButton = vi.fn(() => null);
+    renderWith(makeManager(), { continueButton });
+
+    const onClick = vi.fn();
+    (
+      screenProps.current.continueButton as (args: {
+        onClick: () => void;
+      }) => unknown
+    )({ onClick });
+
+    // The config slot takes `{ onClick, enabled }`; Continue is always
+    // actionable, so the adapter fills `enabled: true`.
+    expect(continueButton).toHaveBeenCalledWith({ onClick, enabled: true });
+  });
+});

package/src/presentation/flow/screen/__tests__/orchestrated_preview_screen.test.tsx

@@ -0,0 +1,224 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import * as React from "react";
+import { create as createRenderer, act } from "react-test-renderer";
+
+// `vi.mock` is hoisted above the imports, so anything its factory closes over
+// must be created with `vi.hoisted` or it is still in the TDZ when the factory
+// runs.
+const { selfieProps, documentProps } = vi.hoisted(() => ({
+  selfieProps: { current: undefined as Record<string, unknown> | undefined },
+  documentProps: { current: undefined as Record<string, unknown> | undefined },
+}));
+
+// Stand in for the leaf screens so these tests exercise the orchestration
+// (which preview to show, accept/reject routing, retake opt-in) rather than
+// re-testing the preview UI, which has its own component suite.
+vi.mock("../../../screen/use_smile_id_preview_screen", () => ({
+  UseSmileIDPreviewScreen: (props: Record<string, unknown>) => {
+    selfieProps.current = props;
+    return null;
+  },
+}));
+
+vi.mock("../../../screen/use_smile_id_document_preview_screen", () => ({
+  UseSmileIDDocumentPreviewScreen: (props: Record<string, unknown>) => {
+    documentProps.current = props;
+    return null;
+  },
+}));
+
+import { OrchestratedPreviewScreen } from "../orchestrated_preview_screen";
+import { FlowNavigationProvider } from "../../flow_navigation_context";
+import { PreviewConfigBuilder } from "../../dsl/builder/screens_builder";
+import type { FlowNavigationManager } from "../../flow_navigation_manager";
+
+type Fn = ReturnType<typeof vi.fn>;
+
+type FakeManager = FlowNavigationManager & {
+  navigateToNext: Fn;
+  navigateBack: Fn;
+  exit: Fn;
+  retakeCurrentDocumentSide: Fn;
+};
+
+type ManagerOverrides = {
+  readonly isDocument?: boolean;
+  readonly documentPreviewPath?: string;
+  readonly selfiePath?: string;
+  readonly documentFrameAspectRatio?: number;
+};
+
+function makeManager(overrides: ManagerOverrides = {}): FakeManager {
+  return {
+    navigateToNext: vi.fn(),
+    navigateBack: vi.fn(),
+    exit: vi.fn(),
+    retakeCurrentDocumentSide: vi.fn(),
+    currentPreviewIsDocument: () => overrides.isDocument ?? false,
+    currentDocumentPreviewPath: () => overrides.documentPreviewPath,
+    documentFrameAspectRatio: overrides.documentFrameAspectRatio,
+    captured: {
+      ...(overrides.selfiePath !== undefined
+        ? { selfiePath: overrides.selfiePath }
+        : {}),
+    },
+  } as unknown as FakeManager;
+}
+
+function makeConfiguration(
+  overrides: Partial<PreviewConfigBuilder> = {},
+): PreviewConfigBuilder {
+  return Object.assign(new PreviewConfigBuilder(), overrides);
+}
+
+function renderWith(
+  manager: FlowNavigationManager,
+  configuration: PreviewConfigBuilder = makeConfiguration(),
+) {
+  act(() => {
+    createRenderer(
+      <FlowNavigationProvider manager={manager}>
+        <OrchestratedPreviewScreen configuration={configuration} />
+      </FlowNavigationProvider>,
+    );
+  });
+}
+
+function readSelfieProps(): Record<string, unknown> {
+  const props = selfieProps.current;
+  if (!props) throw new Error("UseSmileIDPreviewScreen was not rendered");
+  return props;
+}
+
+function readDocumentProps(): Record<string, unknown> {
+  const props = documentProps.current;
+  if (!props) {
+    throw new Error("UseSmileIDDocumentPreviewScreen was not rendered");
+  }
+  return props;
+}
+
+beforeEach(() => {
+  selfieProps.current = undefined;
+  documentProps.current = undefined;
+});
+
+describe("OrchestratedPreviewScreen — selfie preview", () => {
+  it("shows the selfie preview when the step is not a document preview", () => {
+    renderWith(makeManager({ selfiePath: "file:///selfie.jpg" }));
+
+    expect(documentProps.current).toBeUndefined();
+    expect(readSelfieProps().capturedSelfiePath).toBe("file:///selfie.jpg");
+  });
+
+  it("omits the selfie path entirely when nothing was captured", () => {
+    renderWith(makeManager());
+
+    expect("capturedSelfiePath" in readSelfieProps()).toBe(false);
+  });
+
+  it("accept advances the flow", () => {
+    const manager = makeManager({ selfiePath: "file:///selfie.jpg" });
+    renderWith(manager);
+
+    (readSelfieProps().onAccept as () => void)();
+
+    expect(manager.navigateToNext).toHaveBeenCalledTimes(1);
+  });
+
+  it("reject rewinds to the capture screen when retake is allowed", () => {
+    const manager = makeManager({ selfiePath: "file:///selfie.jpg" });
+    renderWith(manager, makeConfiguration({ allowRetake: true }));
+
+    (readSelfieProps().onReject as () => void)();
+
+    expect(manager.navigateBack).toHaveBeenCalledTimes(1);
+  });
+
+  it("reject is inert when the partner disallowed retakes", () => {
+    const manager = makeManager({ selfiePath: "file:///selfie.jpg" });
+    renderWith(manager, makeConfiguration({ allowRetake: false }));
+
+    expect(readSelfieProps().allowRetake).toBe(false);
+    (readSelfieProps().onReject as () => void)();
+
+    expect(manager.navigateBack).not.toHaveBeenCalled();
+    expect(manager.navigateToNext).not.toHaveBeenCalled();
+  });
+
+  it("forwards the attribution switch", () => {
+    renderWith(makeManager(), makeConfiguration({ showAttribution: false }));
+
+    expect(readSelfieProps().showAttribution).toBe(false);
+  });
+});
+
+describe("OrchestratedPreviewScreen — document preview", () => {
+  it("shows the side the manager's per-side loop is currently on", () => {
+    renderWith(
+      makeManager({
+        isDocument: true,
+        documentPreviewPath: "file:///back.jpg",
+        documentFrameAspectRatio: 1.586,
+      }),
+    );
+
+    expect(selfieProps.current).toBeUndefined();
+    expect(readDocumentProps().capturedDocumentPath).toBe("file:///back.jpg");
+    expect(readDocumentProps().documentAspectRatio).toBeCloseTo(1.586, 5);
+  });
+
+  it("falls back to the landscape default frame when no ratio is known", () => {
+    renderWith(makeManager({ isDocument: true }));
+
+    expect(readDocumentProps().documentAspectRatio).toBeCloseTo(1.586, 5);
+    expect("capturedDocumentPath" in readDocumentProps()).toBe(false);
+  });
+
+  it("accept advances the flow", () => {
+    const manager = makeManager({
+      isDocument: true,
+      documentPreviewPath: "file:///front.jpg",
+    });
+    renderWith(manager);
+
+    (readDocumentProps().onAccept as () => void)();
+
+    expect(manager.navigateToNext).toHaveBeenCalledTimes(1);
+  });
+
+  it("reject discards that side and rewinds when retake is allowed", () => {
+    const manager = makeManager({
+      isDocument: true,
+      documentPreviewPath: "file:///front.jpg",
+    });
+    renderWith(manager, makeConfiguration({ allowRetake: true }));
+
+    (readDocumentProps().onReject as () => void)();
+
+    expect(manager.retakeCurrentDocumentSide).toHaveBeenCalledTimes(1);
+    expect(manager.navigateBack).toHaveBeenCalledTimes(1);
+  });
+
+  it("reject keeps the capture when the partner disallowed retakes", () => {
+    const manager = makeManager({
+      isDocument: true,
+      documentPreviewPath: "file:///front.jpg",
+    });
+    renderWith(manager, makeConfiguration({ allowRetake: false }));
+
+    (readDocumentProps().onReject as () => void)();
+
+    expect(manager.retakeCurrentDocumentSide).not.toHaveBeenCalled();
+    expect(manager.navigateBack).not.toHaveBeenCalled();
+  });
+
+  it("close exits the flow", () => {
+    const manager = makeManager({ isDocument: true });
+    renderWith(manager);
+
+    (readDocumentProps().onClose as () => void)();
+
+    expect(manager.exit).toHaveBeenCalledTimes(1);
+  });
+});