@smileid/usesmileid 12.0.1 → 12.0.2

package/src/presentation/flow/__tests__/use_smile_id_flow.test.tsx

@@ -0,0 +1,651 @@
+import { describe, it, expect, vi, beforeEach, afterEach } 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 {
+  crashReporting,
+  fontsLoaded,
+  colorScheme,
+  rendered,
+  makeNetworkingFactory,
+} = vi.hoisted(() => ({
+  crashReporting: {
+    enable: vi.fn(),
+    disable: vi.fn(),
+    setUserId: vi.fn(),
+    captureBreadcrumb: vi.fn(),
+    captureException: vi.fn(),
+  },
+  fontsLoaded: vi.fn(() => true),
+  colorScheme: { current: "light" as "light" | "dark" | null },
+  rendered: {
+    current: undefined as
+      | {
+          step: unknown;
+          manager: unknown;
+          theme: unknown;
+          localizations: unknown;
+        }
+      | undefined,
+  },
+  makeNetworkingFactory: vi.fn(),
+}));
+
+vi.mock("react-native", async () => {
+  const actual = await vi.importActual<Record<string, unknown>>("react-native");
+  return { ...actual, useColorScheme: () => colorScheme.current };
+});
+
+vi.mock("@smileid/usesmileid_bridge", async () => {
+  const actual = await vi.importActual<
+    typeof import("@smileid/usesmileid_bridge")
+  >("@smileid/usesmileid_bridge");
+  return { ...actual, UseSmileIDCrashReporting: crashReporting };
+});
+
+// Bundled-font registration hits `expo-font`; it is a fire-and-forget side
+// effect for these tests.
+vi.mock("../../theme/use_use_smile_id_fonts", () => ({
+  useUseSmileIDFonts: fontsLoaded,
+}));
+
+vi.mock("../../../data/factory/networking_factory", () => ({
+  makeNetworkingFactory,
+}));
+
+// Stand in for the graph dispatcher so these tests cover the flow runtime
+// (theme + localization resolution, crash-reporting lifecycle, exit routing)
+// rather than re-rendering every orchestrated screen. The stub reads the
+// contexts the runtime mounts so their presence is observable.
+vi.mock("../graph/screen_renderer", async () => {
+  const { useFlowNavigation } = await import("../flow_navigation_context");
+  const { useUseSmileIDTheme } = await import("../../theme/theme_context");
+  const { useUseSmileIDLocalizations } =
+    await import("../../../l10n/use_smile_id_localizations_provider");
+  return {
+    ScreenRenderer: ({ step }: { step: unknown }) => {
+      rendered.current = {
+        step,
+        manager: useFlowNavigation(),
+        theme: useUseSmileIDTheme(),
+        localizations: useUseSmileIDLocalizations(),
+      };
+      return null;
+    },
+  };
+});
+
+import {
+  FlowInvalidDispatcher,
+  FlowSuccessRenderer,
+} from "../use_smile_id_flow";
+import {
+  CaptureType,
+  ScreensBuilder,
+  type ScreensConfig,
+} from "../dsl/builder/screens_builder";
+import type { FlowConfiguration } from "../config/flow_configuration";
+import type { FlowNavigationManager } from "../flow_navigation_manager";
+import { UseSmileIDLocalizations } from "../../../l10n/use_smile_id_localizations";
+import { AppState } from "../../../__tests__/react_native_mock";
+import { BuilderValidationException } from "../../../core/exception/builder_validation_exception";
+import {
+  MissingMLConfigurationBlockException,
+  MissingRequiredFieldException,
+} from "../../../core/exception";
+import { defaultDarkTheme, defaultLightTheme } from "../../theme/theme";
+import type { UseSmileIDResult } from "../../../core/models/result";
+import type { JobSubmissionResponse } from "../../../data/model/job_submission_response";
+import type { ValidationStateInvalid } from "../validation/validation_state";
+
+function buildScreens(block: (screens: ScreensBuilder) => void): ScreensConfig {
+  const screensBuilder = new ScreensBuilder();
+  block(screensBuilder);
+  return screensBuilder.build();
+}
+
+const selfieFlowScreens = buildScreens((screens) => {
+  screens.instructions();
+  screens.capture((capture) => {
+    capture.captureType = CaptureType.selfie;
+  });
+  screens.processing();
+});
+
+function makeConfiguration(
+  overrides: Partial<FlowConfiguration> = {},
+): FlowConfiguration {
+  return {
+    screens: selfieFlowScreens,
+    onResult: vi.fn(),
+    ...overrides,
+  } as FlowConfiguration;
+}
+
+function renderFlow(configuration: FlowConfiguration) {
+  let renderer!: ReturnType<typeof createRenderer>;
+  act(() => {
+    renderer = createRenderer(
+      <FlowSuccessRenderer configuration={configuration} />,
+    );
+  });
+  return renderer;
+}
+
+function readRendered() {
+  const current = rendered.current;
+  if (!current) throw new Error("ScreenRenderer was not mounted");
+  return current;
+}
+
+function activeManager(): FlowNavigationManager {
+  return readRendered().manager as FlowNavigationManager;
+}
+
+const partnerNetwork = {
+  config: {
+    jobType: "smart_selfie_enrollment",
+    token: "jwt-token",
+    partnerConfig: { partnerId: "002", useSandbox: false },
+  },
+} as unknown as FlowConfiguration["network"];
+
+beforeEach(() => {
+  rendered.current = undefined;
+  colorScheme.current = "light";
+  fontsLoaded.mockReset();
+  fontsLoaded.mockReturnValue(true);
+  makeNetworkingFactory.mockReset();
+  makeNetworkingFactory.mockReturnValue({
+    api: { submitJob: vi.fn() },
+    metadata: { snapshot: vi.fn(() => []) },
+  });
+  for (const spy of Object.values(crashReporting)) spy.mockReset();
+  UseSmileIDLocalizations.clearRegistry();
+});
+
+afterEach(() => {
+  UseSmileIDLocalizations.clearRegistry();
+});
+
+describe("FlowSuccessRenderer — screen dispatch", () => {
+  it("mounts the first configured screen inside the navigation provider", () => {
+    renderFlow(makeConfiguration());
+
+    expect((readRendered().step as { kind: string }).kind).toBe("instructions");
+    expect(activeManager().currentDepth).toBe(0);
+  });
+
+  it("re-renders on the manager's cursor moves", () => {
+    renderFlow(makeConfiguration());
+
+    act(() => {
+      activeManager().navigateToNext();
+    });
+
+    expect((readRendered().step as { kind: string }).kind).toBe("capture");
+    expect(activeManager().currentDepth).toBe(1);
+  });
+
+  it("renders the empty-screens hint instead of a blank screen", () => {
+    const renderer = renderFlow(
+      makeConfiguration({ screens: buildScreens(() => {}) }),
+    );
+
+    expect(rendered.current).toBeUndefined();
+    const text = JSON.stringify(renderer.toJSON());
+    expect(text).toContain("No screens configured");
+  });
+
+  it("registers the bundled fonts once per flow", () => {
+    renderFlow(makeConfiguration());
+    expect(fontsLoaded).toHaveBeenCalled();
+  });
+
+  it("stops notifying the renderer after unmount", () => {
+    const renderer = renderFlow(makeConfiguration());
+    const manager = activeManager();
+
+    act(() => {
+      renderer.unmount();
+    });
+    rendered.current = undefined;
+    act(() => {
+      manager.navigateToNext();
+    });
+
+    expect(rendered.current).toBeUndefined();
+  });
+});
+
+describe("FlowSuccessRenderer — theme resolution", () => {
+  it("uses the SDK light defaults when the partner sets no theme", () => {
+    renderFlow(makeConfiguration());
+    expect(readRendered().theme).toBe(defaultLightTheme);
+  });
+
+  it("switches to the SDK dark defaults when the device is dark", () => {
+    colorScheme.current = "dark";
+    renderFlow(makeConfiguration());
+    expect(readRendered().theme).toBe(defaultDarkTheme);
+  });
+
+  it("prefers the partner's resolved light tokens in light mode", () => {
+    const theme = { light: defaultLightTheme, dark: defaultDarkTheme };
+    renderFlow(
+      makeConfiguration({
+        theme: theme as unknown as FlowConfiguration["theme"],
+      }),
+    );
+    expect(readRendered().theme).toBe(theme.light);
+  });
+
+  it("prefers the partner's resolved dark tokens in dark mode", () => {
+    colorScheme.current = "dark";
+    const partnerDark = { ...defaultDarkTheme };
+    renderFlow(
+      makeConfiguration({
+        theme: {
+          light: defaultLightTheme,
+          dark: partnerDark,
+        } as unknown as FlowConfiguration["theme"],
+      }),
+    );
+    expect(readRendered().theme).toBe(partnerDark);
+  });
+});
+
+describe("FlowSuccessRenderer — crash reporting lifecycle", () => {
+  it("enables reporting and stamps a per-flow session id on mount", () => {
+    renderFlow(makeConfiguration());
+
+    expect(crashReporting.enable).toHaveBeenCalledWith({ useSandbox: false });
+    expect(crashReporting.setUserId).toHaveBeenCalledTimes(1);
+    const [sessionId] = crashReporting.setUserId.mock.calls[0] as [string];
+    expect(sessionId).toMatch(/\S/);
+    expect(crashReporting.captureBreadcrumb).toHaveBeenCalledWith({
+      category: "flow.navigation",
+      message: "flow mounted",
+    });
+  });
+
+  it("tears down any prior client before enabling so useSandbox can change", () => {
+    renderFlow(makeConfiguration());
+
+    const order = crashReporting.disable.mock.invocationCallOrder[0];
+    const enableOrder = crashReporting.enable.mock.invocationCallOrder[0];
+    expect(order).toBeLessThan(enableOrder as number);
+  });
+
+  it("routes sandbox sessions to the sandbox reporter", () => {
+    renderFlow(makeConfiguration({ network: partnerNetwork }));
+
+    expect(crashReporting.enable).toHaveBeenCalledWith({ useSandbox: false });
+
+    crashReporting.enable.mockClear();
+    renderFlow(
+      makeConfiguration({
+        network: {
+          config: {
+            ...(partnerNetwork as { config: Record<string, unknown> }).config,
+            partnerConfig: { partnerId: "002", useSandbox: true },
+          },
+        } as unknown as FlowConfiguration["network"],
+      }),
+    );
+
+    expect(crashReporting.enable).toHaveBeenCalledWith({ useSandbox: true });
+  });
+
+  it("stays disabled when the partner opts out", () => {
+    renderFlow(
+      makeConfiguration({
+        config: {
+          enableCrashReporting: false,
+        } as unknown as FlowConfiguration["config"],
+      }),
+    );
+
+    expect(crashReporting.enable).not.toHaveBeenCalled();
+    expect(crashReporting.setUserId).not.toHaveBeenCalled();
+  });
+
+  it("disables reporting when the flow unmounts", () => {
+    const renderer = renderFlow(makeConfiguration());
+    crashReporting.disable.mockClear();
+
+    act(() => {
+      renderer.unmount();
+    });
+
+    expect(crashReporting.disable).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("FlowSuccessRenderer — exit routing", () => {
+  function renderWithResultSpy() {
+    const onResult = vi.fn();
+    renderFlow(makeConfiguration({ onResult }));
+    return { onResult, manager: activeManager() };
+  }
+
+  it("delivers a successful submission as a success result", () => {
+    const { onResult, manager } = renderWithResultSpy();
+    const job: JobSubmissionResponse = {
+      userId: "user-1",
+      jobId: "job-1",
+      status: "approved",
+      message: "done",
+    };
+
+    act(() => {
+      manager.exit({ kind: "completed", job });
+    });
+
+    const [result] = onResult.mock.calls[0] as [
+      UseSmileIDResult<JobSubmissionResponse>,
+    ];
+    expect(result.status).toBe("success");
+    expect((result as { value: JobSubmissionResponse }).value).toBe(job);
+  });
+
+  it("reports a deliberate exit as cancelled, not failed", () => {
+    const { onResult, manager } = renderWithResultSpy();
+
+    act(() => {
+      manager.exit({ kind: "cancelled" });
+    });
+
+    expect((onResult.mock.calls[0]?.[0] as { status: string }).status).toBe(
+      "cancelled",
+    );
+  });
+
+  it("passes a failure exit through with its error", () => {
+    const { onResult, manager } = renderWithResultSpy();
+    const error = new Error("submission rejected");
+
+    act(() => {
+      manager.exit({ kind: "failed", error });
+    });
+
+    const [result] = onResult.mock.calls[0] as [
+      UseSmileIDResult<JobSubmissionResponse>,
+    ];
+    expect(result.status).toBe("failure");
+    expect((result as { error: unknown }).error).toBe(error);
+  });
+
+  it("captures a throwing partner handler instead of crashing the SDK", () => {
+    const boom = new Error("partner navigation stack is gone");
+    const onResult = vi.fn(() => {
+      throw boom;
+    });
+    renderFlow(makeConfiguration({ onResult }));
+    const manager = activeManager();
+
+    expect(() => {
+      act(() => {
+        manager.exit({ kind: "cancelled" });
+      });
+    }).not.toThrow();
+    expect(crashReporting.captureException).toHaveBeenCalledWith(boom);
+  });
+});
+
+describe("FlowSuccessRenderer — repository wiring", () => {
+  it("builds the networking stack once per network config", () => {
+    renderFlow(makeConfiguration({ network: partnerNetwork }));
+
+    expect(makeNetworkingFactory).toHaveBeenCalledTimes(1);
+    expect(makeNetworkingFactory).toHaveBeenCalledWith(partnerNetwork);
+  });
+
+  it("skips the networking stack when no partnerConfig is supplied", () => {
+    renderFlow(
+      makeConfiguration({
+        network: {
+          config: { jobType: "smart_selfie_enrollment" },
+        } as unknown as FlowConfiguration["network"],
+      }),
+    );
+
+    expect(makeNetworkingFactory).not.toHaveBeenCalled();
+  });
+
+  it("surfaces the 'not configured' failure when the flow has no repository", async () => {
+    renderFlow(makeConfiguration());
+    const manager = activeManager();
+
+    await act(async () => {
+      manager.beginSubmissionIfNeeded();
+    });
+
+    const state = manager.jobSubmissionState;
+    expect(state.kind).toBe("failure");
+    expect((state as { error: Error }).error.message).toContain(
+      "Job submission not configured",
+    );
+  });
+
+  it("hands the manager a real repository once partnerConfig is present", async () => {
+    renderFlow(makeConfiguration({ network: partnerNetwork }));
+    const manager = activeManager();
+
+    await act(async () => {
+      manager.beginSubmissionIfNeeded();
+    });
+
+    const state = manager.jobSubmissionState;
+    expect(state.kind).toBe("failure");
+    // The repository exists, so submission gets far enough to fail on the
+    // missing selfie capture rather than on the absent network stack.
+    expect((state as { error: Error }).error.message).not.toContain(
+      "Job submission not configured",
+    );
+  });
+});
+
+describe("FlowSuccessRenderer — localizations", () => {
+  it("uses the partner's explicit localizations over everything else", () => {
+    const localizations = new UseSmileIDLocalizations({
+      si_consent_title: "Explicit",
+    });
+    renderFlow(makeConfiguration({ localizations }));
+
+    expect(readRendered().localizations).toBe(localizations);
+  });
+
+  it("auto-resolves from the registry when the partner registered locales", () => {
+    UseSmileIDLocalizations.register("en", { si_consent_title: "Registered" });
+    renderFlow(makeConfiguration());
+
+    const resolved = readRendered().localizations as UseSmileIDLocalizations;
+    expect(resolved).toBeInstanceOf(UseSmileIDLocalizations);
+    expect(resolved).not.toBe(undefined);
+  });
+
+  it("re-resolves the locale when the app returns to the foreground", () => {
+    UseSmileIDLocalizations.register("en", { si_consent_allow: "Allow" });
+    UseSmileIDLocalizations.register("fr", { si_consent_allow: "Autoriser" });
+    const originalResolver = UseSmileIDLocalizations.localeResolver;
+    UseSmileIDLocalizations.localeResolver = () => "en";
+
+    try {
+      renderFlow(makeConfiguration());
+      expect(
+        (readRendered().localizations as UseSmileIDLocalizations)
+          .siConsentAllow,
+      ).toBe("Allow");
+
+      UseSmileIDLocalizations.localeResolver = () => "fr";
+      act(() => {
+        AppState.emit("active");
+      });
+
+      expect(
+        (readRendered().localizations as UseSmileIDLocalizations)
+          .siConsentAllow,
+      ).toBe("Autoriser");
+    } finally {
+      UseSmileIDLocalizations.localeResolver = originalResolver;
+    }
+  });
+
+  it("falls back to the English context default with no registered locales", () => {
+    renderFlow(makeConfiguration());
+
+    const resolved = readRendered().localizations as UseSmileIDLocalizations;
+    expect(resolved).toBeInstanceOf(UseSmileIDLocalizations);
+  });
+});
+
+describe("FlowSuccessRenderer — font registration gate", () => {
+  it("holds the first frame until the bundled faces are registered", () => {
+    fontsLoaded.mockReturnValue(false);
+    renderFlow(makeConfiguration());
+
+    expect(rendered.current).toBeUndefined();
+  });
+
+  it("renders the flow once registration completes", () => {
+    fontsLoaded.mockReturnValue(false);
+    const renderer = renderFlow(makeConfiguration());
+
+    fontsLoaded.mockReturnValue(true);
+    act(() => {
+      renderer.update(
+        <FlowSuccessRenderer configuration={makeConfiguration()} />,
+      );
+    });
+
+    expect(rendered.current).toBeDefined();
+  });
+
+  it("renders anyway once the wait expires, so a font failure can't strand the flow", () => {
+    vi.useFakeTimers();
+    try {
+      fontsLoaded.mockReturnValue(false);
+      renderFlow(makeConfiguration());
+      expect(rendered.current).toBeUndefined();
+
+      act(() => {
+        vi.advanceTimersByTime(1000);
+      });
+
+      expect(rendered.current).toBeDefined();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});
+
+describe("FlowInvalidDispatcher", () => {
+  function makeValidationState(): ValidationStateInvalid {
+    return {
+      valid: false,
+      issues: [
+        new MissingRequiredFieldException({ fieldName: "captureType" }),
+        new MissingMLConfigurationBlockException(),
+      ],
+    } as ValidationStateInvalid;
+  }
+
+  function renderDispatcher(
+    onResult: (result: UseSmileIDResult<JobSubmissionResponse>) => void,
+    enableDebugMode: boolean,
+    validation = makeValidationState(),
+  ) {
+    let renderer!: ReturnType<typeof createRenderer>;
+    act(() => {
+      renderer = createRenderer(
+        <FlowInvalidDispatcher
+          result={{ kind: "invalid", validation }}
+          onResult={onResult}
+          enableDebugMode={enableDebugMode}
+        />,
+      );
+    });
+    return renderer;
+  }
+
+  it("reports the validation failure through onResult as a typed exception", () => {
+    const onResult = vi.fn();
+    const validation = makeValidationState();
+    renderDispatcher(onResult, false, validation);
+
+    const [result] = onResult.mock.calls[0] as [
+      UseSmileIDResult<JobSubmissionResponse>,
+    ];
+    expect(result.status).toBe("failure");
+    const error = (result as { error: unknown }).error;
+    expect(error).toBeInstanceOf(BuilderValidationException);
+    expect(
+      (error as BuilderValidationException).validationState.issues,
+    ).toHaveLength(2);
+  });
+
+  it("renders nothing in production so partners only see onResult", () => {
+    const renderer = renderDispatcher(vi.fn(), false);
+    expect(renderer.toJSON()).toBeNull();
+  });
+
+  it("renders every failing rule in debug mode", () => {
+    const renderer = renderDispatcher(vi.fn(), true);
+
+    const text = JSON.stringify(renderer.toJSON());
+    expect(text).toContain("UseSmileID Configuration Error");
+    expect(text).toContain("2");
+    expect(text).toContain("Required field 'captureType' is missing");
+    expect(text).toContain("Provide a value for the required field.");
+    expect(text).toContain(
+      "Flow contains a Capture screen but the ml { } block is missing",
+    );
+    // Errors render crimson, warnings amber — the two severities are
+    // distinguishable at a glance in the debug screen.
+    expect(text).toContain("#B91C1C");
+    expect(text).toContain("#B45309");
+  });
+
+  it("captures a throwing partner handler rather than crashing the mount", () => {
+    const boom = new Error("partner blew up on failure");
+    expect(() =>
+      renderDispatcher(() => {
+        throw boom;
+      }, false),
+    ).not.toThrow();
+    expect(crashReporting.captureException).toHaveBeenCalledWith(boom);
+  });
+});
+
+describe("FlowSuccessRenderer — teardown delivery", () => {
+  it("an unmounted-before-finishing flow delivers a cancelled result exactly once", () => {
+    const onResult = vi.fn();
+    const renderer = renderFlow(makeConfiguration({ onResult }));
+
+    act(() => {
+      renderer.unmount();
+    });
+
+    expect(onResult).toHaveBeenCalledTimes(1);
+    expect(onResult.mock.calls[0]?.[0]).toMatchObject({ status: "cancelled" });
+  });
+
+  it("a finished flow delivers nothing extra at unmount", () => {
+    const onResult = vi.fn();
+    const renderer = renderFlow(makeConfiguration({ onResult }));
+    const manager = activeManager();
+
+    act(() => {
+      manager.exit({ kind: "cancelled" });
+    });
+    act(() => {
+      renderer.unmount();
+    });
+
+    expect(onResult).toHaveBeenCalledTimes(1);
+  });
+});