@smileid/usesmileid 12.0.2 → 12.1.0

package/src/testing/__tests__/scenario_expectations.test.ts

@@ -1,110 +0,0 @@
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { describe, expect, it } from "vitest";
-import {
-  expectSubsetInOrder,
-  parseScenarioExpectations,
-} from "../scenario_expectations";
-
-// Read the canonical shared scenario at run time (see the capture-screen test
-// for the same rationale) so a drift in the shared `expected` block is caught
-// here per-PR rather than silently diverging.
-const scenarioDir = dirname(fileURLToPath(import.meta.url));
-const selfieScenario = JSON.parse(
-  readFileSync(
-    join(scenarioDir, "../../../../e2e/scenarios/selfie-happy-path.json"),
-    "utf8",
-  ),
-) as unknown;
-
-const agentModeScenario = JSON.parse(
-  readFileSync(
-    join(scenarioDir, "../../../../e2e/scenarios/selfie-agent-mode.json"),
-    "utf8",
-  ),
-) as unknown;
-
-describe("parseScenarioExpectations", () => {
-  // Nothing is relaxed for the agent, so the shared script must carry the same
-  // terminal contract as the front-camera happy path.
-  it("gives the shared agent-mode scenario the same terminal contract as the happy path", () => {
-    const agentMode = parseScenarioExpectations(agentModeScenario);
-    const happyPath = parseScenarioExpectations(selfieScenario);
-    expect(agentMode.screens).toEqual(happyPath.screens);
-    expect(agentMode.events).toEqual(happyPath.events);
-    expect(agentMode.terminal).toBe("submitted");
-  });
-
-  it("surfaces the shared selfie scenario's expected screens/events/terminal", () => {
-    const expected = parseScenarioExpectations(selfieScenario);
-    expect(expected.screens).toEqual([
-      "consent",
-      "instructions",
-      "capture",
-      "preview",
-      "processing",
-    ]);
-    expect(expected.events).toEqual([
-      "flow_started",
-      "consent_captured",
-      "selfie_captured",
-      "job_submitted",
-      "flow_completed",
-    ]);
-    expect(expected.terminal).toBe("submitted");
-  });
-
-  it("defaults to empty arrays when the block is absent", () => {
-    const expected = parseScenarioExpectations({ name: "x" });
-    expect(expected.screens).toEqual([]);
-    expect(expected.events).toEqual([]);
-  });
-
-  it("rejects a malformed expected block", () => {
-    expect(() =>
-      parseScenarioExpectations({ expected: { screens: [1, 2] } }),
-    ).toThrow(/must be an array of strings/);
-    expect(() =>
-      parseScenarioExpectations({ expected: { terminal: "exploded" } }),
-    ).toThrow(/terminal must be one of/);
-  });
-});
-
-describe("expectSubsetInOrder", () => {
-  it("passes when every expected item appears in order (interleaving allowed)", () => {
-    const { screens, events } = parseScenarioExpectations(selfieScenario);
-    // Recorded stream may carry extra, unlisted events between the required
-    // ones — the contract is subset-in-order, not exact match.
-    const recordedEvents = [
-      "flow_started",
-      "screen_viewed",
-      "consent_captured",
-      "screen_viewed",
-      "selfie_captured",
-      "image_quality_ok",
-      "job_submitted",
-      "flow_completed",
-    ];
-    expect(() => expectSubsetInOrder(recordedEvents, events)).not.toThrow();
-    expect(() => expectSubsetInOrder([...screens], screens)).not.toThrow();
-  });
-
-  it("throws when an expected item is missing", () => {
-    expect(() =>
-      expectSubsetInOrder(
-        ["flow_started", "flow_completed"],
-        ["flow_started", "job_submitted", "flow_completed"],
-      ),
-    ).toThrow(/job_submitted/);
-  });
-
-  it("throws when expected items appear out of order", () => {
-    expect(() =>
-      expectSubsetInOrder(
-        ["flow_completed", "flow_started"],
-        ["flow_started", "flow_completed"],
-      ),
-    ).toThrow(/to appear in order/);
-  });
-});

package/src/testing/__tests__/scenario_loader.test.ts

@@ -1,64 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { parseScriptedScenario } from "../scenario_loader";
-
-describe("parseScriptedScenario", () => {
-  const valid = {
-    name: "selfie-happy-path",
-    captureType: "selfie",
-    steps: [
-      { emit: "noFace", holdFrames: 10 },
-      { emit: "faceCentered", holdFrames: 20 },
-      { emit: "satisfied" },
-    ],
-    // An `expected` block may ride alongside; the loader ignores extra keys.
-    expected: { screens: [], events: [], terminal: "submitted" },
-  };
-
-  it("returns the typed scenario for a valid shape", () => {
-    const scenario = parseScriptedScenario(valid);
-    expect(scenario.name).toBe("selfie-happy-path");
-    expect(scenario.captureType).toBe("selfie");
-    expect(scenario.steps).toHaveLength(3);
-    expect(scenario.steps[2]).toEqual({ emit: "satisfied" });
-  });
-
-  it("rejects an unknown emit (vocabulary drift)", () => {
-    expect(() =>
-      parseScriptedScenario({
-        name: "x",
-        captureType: "selfie",
-        steps: [{ emit: "wink" }],
-      }),
-    ).toThrow(/not a known emission/);
-  });
-
-  it("rejects an unknown captureType", () => {
-    expect(() =>
-      parseScriptedScenario({
-        name: "x",
-        captureType: "iris",
-        steps: [{ emit: "noFace" }],
-      }),
-    ).toThrow(/captureType/);
-  });
-
-  it("rejects empty steps", () => {
-    expect(() =>
-      parseScriptedScenario({ name: "x", captureType: "selfie", steps: [] }),
-    ).toThrow(/non-empty/);
-  });
-
-  it("rejects a non-integer holdFrames", () => {
-    expect(() =>
-      parseScriptedScenario({
-        name: "x",
-        captureType: "selfie",
-        steps: [{ emit: "noFace", holdFrames: 1.5 }],
-      }),
-    ).toThrow(/holdFrames/);
-  });
-
-  it("rejects a non-object input", () => {
-    expect(() => parseScriptedScenario("nope")).toThrow(/JSON object/);
-  });
-});

package/src/testing/fake_face_analyzer.ts

@@ -1,82 +0,0 @@
-import type { FaceAnalyzer } from "@smileid/usesmileid_platform_interface";
-import { AnalyzerFactoryKey } from "@smileid/usesmileid_bridge";
-
-/**
- * Deterministic fake face analyzer for scripted-scenario E2E runs. Exported
- * only behind the `@smileid/usesmileid/testing` subpath so it cannot leak into
- * partner production bundles.
- *
- * Per-frame detection runs in the provider's native frame-processor plugin
- * (pixels never cross into JS), so `frameProcessorPluginName` points at a
- * plugin that does not exist — the capture screen surfaces that as its
- * camera-unavailable state. This fake covers the DSL registration seam and the
- * capture-free flows; capture progression is driven via `onResult` instead.
- */
-export interface ScriptedScenarioStep {
-  readonly emit: string;
-  readonly holdFrames?: number;
-}
-
-export interface ScriptedScenario {
-  readonly name: string;
-  readonly captureType: string;
-  readonly steps: readonly ScriptedScenarioStep[];
-}
-
-export class FakeFaceAnalyzer implements FaceAnalyzer {
-  readonly kind = "face" as const;
-  readonly key: AnalyzerFactoryKey = AnalyzerFactoryKey.MLKitFace;
-  readonly frameProcessorPluginName = "e2e-fake-face";
-
-  configureCallCount = 0;
-  resetCallCount = 0;
-  flushCallCount = 0;
-  closeCallCount = 0;
-
-  private stepIndex = 0;
-  private framesLeftInStep: number;
-
-  constructor(private readonly scenario: ScriptedScenario) {
-    this.framesLeftInStep = scenario.steps[0]?.holdFrames ?? 1;
-  }
-
-  /** Frame-by-frame cursor; the final step repeats indefinitely. */
-  nextEmit(): string {
-    const steps = this.scenario.steps;
-    const step = steps[this.stepIndex];
-    if (step === undefined) return "noFace";
-    if (this.stepIndex === steps.length - 1) return step.emit;
-    this.framesLeftInStep -= 1;
-    if (this.framesLeftInStep <= 0) {
-      this.stepIndex += 1;
-      this.framesLeftInStep = steps[this.stepIndex]?.holdFrames ?? 1;
-    }
-    return step.emit;
-  }
-
-  configure(): Promise<void> {
-    this.configureCallCount += 1;
-    return Promise.resolve();
-  }
-
-  reset(): Promise<void> {
-    this.resetCallCount += 1;
-    return Promise.resolve();
-  }
-
-  flush(): Promise<void> {
-    this.flushCallCount += 1;
-    return Promise.resolve();
-  }
-
-  close(): Promise<void> {
-    this.closeCallCount += 1;
-    return Promise.resolve();
-  }
-}
-
-export function makeFakeFaceAnalyzer(
-  scenario: ScriptedScenario,
-): FakeFaceAnalyzer {
-  return new FakeFaceAnalyzer(scenario);
-}

package/src/testing/index.ts

@@ -1,15 +0,0 @@
-// Test-support entry — exported behind the `@smileid/usesmileid/testing`
-// subpath only. Nothing here may be re-exported from the main index.
-export {
-  FakeFaceAnalyzer,
-  makeFakeFaceAnalyzer,
-  type ScriptedScenario,
-  type ScriptedScenarioStep,
-} from "./fake_face_analyzer";
-export { scriptedFaceScanResults } from "./scripted_scan_results";
-export { parseScriptedScenario } from "./scenario_loader";
-export {
-  type ScenarioExpectations,
-  parseScenarioExpectations,
-  expectSubsetInOrder,
-} from "./scenario_expectations";

package/src/testing/scenario_expectations.ts

@@ -1,87 +0,0 @@
-/**
- * Capture-scoped expectations from the shared `e2e-scenarios` schema's `expected`
- * block (screen + analytics-event names, terminal state). Framework-agnostic (no
- * vitest/jest import) so a partner app's own e2e runner can reuse it.
- */
-export interface ScenarioExpectations {
-  /** Ordered `screen_viewed` sequence for the canonical consent-first flow. */
-  readonly screens: readonly string[];
-  /** Ordered analytics event types that must fire (subset-in-order). */
-  readonly events: readonly string[];
-  /** How the capture session ends. */
-  readonly terminal?: "submitted" | "timeout" | "unsatisfied";
-}
-
-const TERMINALS: ReadonlySet<string> = new Set([
-  "submitted",
-  "timeout",
-  "unsatisfied",
-]);
-
-/**
- * Extracts and validates the `expected` block from an already-parsed shared
- * scenario JSON object. Returns empty screen/event arrays when the block is
- * absent (older scenarios), and throws on a malformed block so drift fails
- * loudly rather than silently weakening the contract.
- */
-export function parseScenarioExpectations(raw: unknown): ScenarioExpectations {
-  if (typeof raw !== "object" || raw === null) {
-    throw new Error("scenario must be a JSON object");
-  }
-  const expected = (raw as Record<string, unknown>).expected;
-  if (expected === undefined) {
-    return { screens: [], events: [] };
-  }
-  if (typeof expected !== "object" || expected === null) {
-    throw new Error("scenario.expected must be an object when present");
-  }
-  const record = expected as Record<string, unknown>;
-  const screens = readStringArray(record.screens, "scenario.expected.screens");
-  const events = readStringArray(record.events, "scenario.expected.events");
-  const terminal = record.terminal;
-  if (terminal === undefined) {
-    return { screens, events };
-  }
-  if (typeof terminal !== "string" || !TERMINALS.has(terminal)) {
-    throw new Error(
-      `scenario.expected.terminal must be one of ${[...TERMINALS].join(", ")}, got ${String(terminal)}`,
-    );
-  }
-  return {
-    screens,
-    events,
-    terminal: terminal as "submitted" | "timeout" | "unsatisfied",
-  };
-}
-
-function readStringArray(value: unknown, label: string): readonly string[] {
-  if (value === undefined) return [];
-  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
-    throw new Error(`${label} must be an array of strings`);
-  }
-  return value as string[];
-}
-
-/**
- * Asserts that every element of [expected] appears in [recorded] in the same
- * relative order (a minimal ordered-subset match — unlisted items may
- * interleave, exact-match is deliberately NOT required). Throws a descriptive
- * Error on failure so it works under any test runner.
- */
-export function expectSubsetInOrder(
-  recorded: readonly string[],
-  expected: readonly string[],
-  label = "sequence",
-): void {
-  let cursor = 0;
-  for (const item of recorded) {
-    if (cursor < expected.length && item === expected[cursor]) cursor += 1;
-  }
-  if (cursor !== expected.length) {
-    throw new Error(
-      `${label}: expected [${expected
-        .slice(cursor)
-        .join(", ")}] to appear in order within [${recorded.join(", ")}]`,
-    );
-  }
-}

package/src/testing/scenario_loader.ts

@@ -1,83 +0,0 @@
-import type {
-  ScriptedScenario,
-  ScriptedScenarioStep,
-} from "./fake_face_analyzer";
-
-/**
- * Emission vocabulary of the shared `e2e-scenarios` schema (`schema.json` in
- * every repo's scenario folder). A step whose `emit` is outside this set is a
- * drift bug — the loader rejects it rather than letting the fake silently treat
- * it as "no detection".
- */
-const KNOWN_EMITS: ReadonlySet<string> = new Set([
-  "noFace",
-  "faceTooFar",
-  "faceCentered",
-  "headTurnLeft",
-  "headTurnRight",
-  "headTurnUp",
-  "satisfied",
-  "noDocument",
-  "documentFound",
-  "documentUnstable",
-]);
-
-const CAPTURE_TYPES: ReadonlySet<string> = new Set(["selfie", "document"]);
-
-/**
- * Validates a parsed shared-scenario JSON object and returns the typed
- * [ScriptedScenario]. Kept I/O-free (takes an already-parsed object) so the
- * `@smileid/usesmileid/testing` subpath stays environment-agnostic — the caller
- * owns how the JSON is read. Throws with a specific message on any shape drift
- * so a malformed or vocabulary-drifted script fails loudly at load time instead
- * of producing a misleading capture sequence.
- */
-export function parseScriptedScenario(raw: unknown): ScriptedScenario {
-  if (typeof raw !== "object" || raw === null) {
-    throw new Error("scenario must be a JSON object");
-  }
-  const record = raw as Record<string, unknown>;
-
-  const name = record.name;
-  if (typeof name !== "string" || name.length === 0) {
-    throw new Error("scenario.name must be a non-empty string");
-  }
-
-  const captureType = record.captureType;
-  if (typeof captureType !== "string" || !CAPTURE_TYPES.has(captureType)) {
-    throw new Error(
-      `scenario.captureType must be one of ${[...CAPTURE_TYPES].join(", ")}, got ${String(captureType)}`,
-    );
-  }
-
-  if (!Array.isArray(record.steps) || record.steps.length === 0) {
-    throw new Error(`scenario.steps must be a non-empty array in ${name}`);
-  }
-
-  const steps: ScriptedScenarioStep[] = record.steps.map((step, index) => {
-    if (typeof step !== "object" || step === null) {
-      throw new Error(`scenario.steps[${index}] must be an object in ${name}`);
-    }
-    const stepRecord = step as Record<string, unknown>;
-    const emit = stepRecord.emit;
-    if (typeof emit !== "string" || !KNOWN_EMITS.has(emit)) {
-      throw new Error(
-        `scenario.steps[${index}].emit "${String(emit)}" is not a known emission in ${name}`,
-      );
-    }
-    const holdFrames = stepRecord.holdFrames;
-    if (
-      holdFrames !== undefined &&
-      (typeof holdFrames !== "number" ||
-        !Number.isInteger(holdFrames) ||
-        holdFrames < 1)
-    ) {
-      throw new Error(
-        `scenario.steps[${index}].holdFrames must be a positive integer in ${name}`,
-      );
-    }
-    return holdFrames === undefined ? { emit } : { emit, holdFrames };
-  });
-
-  return { name, captureType, steps };
-}

package/src/testing/scripted_scan_results.ts

@@ -1,66 +0,0 @@
-import {
-  CaptureReadyEventKind,
-  UseSmileIDScanStateType,
-} from "@smileid/usesmileid_bridge";
-import type {
-  CaptureReadyEvent,
-  FaceScanResult,
-} from "@smileid/usesmileid_bridge";
-import type { ScriptedScenario } from "./fake_face_analyzer";
-
-/**
- * Turns a shared E2E scenario into the `FaceScanResult` sequence a capture
- * screen receives frame-by-frame, so a headless test can replay the shared
- * script through the frame stream's `onResult` seam (per-frame detection is a
- * native frame-processor concern; pixels never reach JS).
- *
- * `noFace` → `initial`; `faceTooFar` / `faceCentered` → `found`; the terminal
- * `satisfied` → one `finished` result carrying a `selfie` event plus
- * [livenessCount] `liveness` events at opaque `file://` URLs the screen never
- * reads. Exported only behind the `@smileid/usesmileid/testing` subpath.
- */
-export function scriptedFaceScanResults(
-  scenario: ScriptedScenario,
-  options: { readonly livenessCount?: number } = {},
-): FaceScanResult[] {
-  const livenessCount = options.livenessCount ?? 2;
-  const output: FaceScanResult["output"] = { faces: [], brightness: 128 };
-  const results: FaceScanResult[] = [];
-
-  for (const step of scenario.steps) {
-    if (step.emit === "satisfied") {
-      results.push({
-        output,
-        state: { type: UseSmileIDScanStateType.Finished },
-        capturedEvents: captureEvents(livenessCount),
-      });
-      return results;
-    }
-    const type =
-      step.emit === "noFace"
-        ? UseSmileIDScanStateType.Initial
-        : UseSmileIDScanStateType.Found;
-    for (let frame = 0; frame < (step.holdFrames ?? 1); frame++) {
-      results.push({ output, state: { type }, capturedEvents: [] });
-    }
-  }
-  return results;
-}
-
-function captureEvents(livenessCount: number): CaptureReadyEvent[] {
-  const events: CaptureReadyEvent[] = [
-    {
-      kind: CaptureReadyEventKind.Selfie,
-      captureIndex: 0,
-      url: "file://selfie-0.jpg",
-    },
-  ];
-  for (let index = 1; index <= livenessCount; index++) {
-    events.push({
-      kind: CaptureReadyEventKind.Liveness,
-      captureIndex: index,
-      url: `file://liveness-${index}.jpg`,
-    });
-  }
-  return events;
-}