@smileid/usesmileid 12.0.2 → 12.1.0

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

@@ -1,651 +0,0 @@
-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);
-  });
-});