@smileid/usesmileid 12.0.0-beta01

package/src/presentation/flow/validation/__tests__/flow_validator.test.ts

@@ -0,0 +1,398 @@
+import { describe, expect, it, vi } from "vitest";
+import type {
+  FaceAnalyzer,
+  DocumentAnalyzer,
+} from "@smileid/usesmileid_platform_interface";
+import { AnalyzerFactoryKey } from "@smileid/usesmileid_bridge";
+import { runFlowValidation } from "../flow_validator";
+import { JobType } from "../../../../core/models/job_type";
+import { DocumentType } from "../../../../core/models/document_type";
+import type { MLConfig } from "../../../../core/models/ml_config";
+import type { NetworkConfig } from "../../../../core/models/network_config";
+import type { UserDetails } from "../../../../core/models/params";
+import {
+  CaptureConfigBuilder,
+  CaptureType,
+  ProcessingConfigBuilder,
+} from "../../dsl/builder/screens_builder";
+import {
+  InvalidFieldValueException,
+  InvalidJobTypeScreenConfigException,
+  MissingMLConfigurationBlockException,
+} from "../../../../core/exception/job_validation_exceptions";
+import { InvalidDocumentCaptureConfigException } from "../../../../core/exception/capture_validation_exceptions";
+import {
+  runDocumentVerificationParamsValidation,
+  runEnhancedDocumentVerificationParamsValidation,
+} from "../flow_validator";
+
+function stubFaceAnalyzer(): FaceAnalyzer {
+  return {
+    kind: "face",
+    key: AnalyzerFactoryKey.VisionFace,
+    frameProcessorPluginName: "UseSmileIDVisionFaceFrameProcessor",
+    configure: vi.fn(),
+    reset: vi.fn(),
+    flush: vi.fn(),
+    close: vi.fn(),
+  };
+}
+
+function stubDocumentAnalyzer(): DocumentAnalyzer {
+  return {
+    kind: "document",
+    frameProcessorPluginName: "UseSmileIDVisionDocumentFrameProcessor",
+    configure: vi.fn(),
+    reset: vi.fn(),
+    flush: vi.fn(),
+    close: vi.fn(),
+  };
+}
+
+function captureStep(captureType: CaptureType) {
+  const config = new CaptureConfigBuilder();
+  config.captureType = captureType;
+  // A document capture requires a documentType to pass validation. Tests
+  // here target other rules, so default to a generic document; the
+  // dedicated config describe-block covers the missing-type path.
+  if (captureType === CaptureType.document) {
+    config.document((d) => {
+      d.documentType = DocumentType.GenericDocument();
+    });
+  }
+  return { kind: "capture" as const, config };
+}
+
+function processingStep() {
+  return {
+    kind: "processing" as const,
+    config: new ProcessingConfigBuilder(),
+  };
+}
+
+function validNetwork(jobType: JobType): NetworkConfig {
+  return {
+    config: {
+      jobType,
+      token: "t",
+      partnerConfig: {
+        partnerId: "p",
+        callbackUrl: "",
+        useSandbox: true,
+      },
+    },
+  };
+}
+
+const validUserDetails: UserDetails = {
+  givenNames: "Ada",
+  lastName: "Lovelace",
+  email: "ada@example.com",
+};
+
+// Selfie-flavoured job types share the same selfie-analyzer
+// requirement. Capture-time enhanced liveness is governed by the
+// screen-level flag, not a distinct job type.
+const SELFIE_JOB_TYPES: ReadonlyArray<{ name: string; value: JobType }> = [
+  { name: "biometricKyc", value: JobType.biometricKyc },
+  {
+    name: "smartSelfieAuthentication",
+    value: JobType.smartSelfieAuthentication,
+  },
+  { name: "smartSelfieEnrollment", value: JobType.smartSelfieEnrollment },
+];
+
+// Document flows also need a selfie analyzer because they include a
+// selfie capture for biometric matching against the document
+// portrait. The document analyzer itself is OPTIONAL.
+const DOCUMENT_JOB_TYPES: ReadonlyArray<{ name: string; value: JobType }> = [
+  { name: "documentVerification", value: JobType.documentVerification },
+  {
+    name: "enhancedDocumentVerification",
+    value: JobType.enhancedDocumentVerification,
+  },
+];
+
+describe("FlowValidator — document capture config", () => {
+  // A document capture step with an optional document { } block. `configure`
+  // mutates the document config when supplied; omitting it leaves the block
+  // unconfigured (no document { } call at all).
+  function documentCaptureStep(
+    configure?: (d: {
+      documentType?: DocumentType;
+      knownIdAspectRatio?: number;
+    }) => void,
+  ) {
+    const config = new CaptureConfigBuilder();
+    config.captureType = CaptureType.document;
+    if (configure) {
+      config.document(configure);
+    }
+    return { kind: "capture" as const, config };
+  }
+
+  function firstDocumentIssue(steps: ReturnType<typeof documentCaptureStep>[]) {
+    const issues = runFlowValidation({ steps: [...steps, processingStep()] });
+    return issues.find(
+      (i): i is InvalidDocumentCaptureConfigException =>
+        i instanceof InvalidDocumentCaptureConfigException,
+    );
+  }
+
+  it("requires a document { } block when captureType is document", () => {
+    const issue = firstDocumentIssue([documentCaptureStep()]);
+    expect(issue?.message).toContain(
+      "document is required when mode is Document",
+    );
+  });
+
+  it("requires a documentType inside the document block", () => {
+    const issue = firstDocumentIssue([
+      documentCaptureStep((d) => {
+        d.knownIdAspectRatio = 1.586;
+      }),
+    ]);
+    expect(issue?.message).toContain(
+      "documentType is required for document capture",
+    );
+  });
+
+  it("rejects a non-positive knownIdAspectRatio once a documentType is set", () => {
+    const issue = firstDocumentIssue([
+      documentCaptureStep((d) => {
+        d.documentType = DocumentType.SouthAfricaGreenBook;
+        d.knownIdAspectRatio = 0;
+      }),
+    ]);
+    expect(issue?.message).toContain("knownIdAspectRatio must be > 0");
+  });
+
+  it("accepts a positive knownIdAspectRatio with a documentType", () => {
+    expect(
+      firstDocumentIssue([
+        documentCaptureStep((d) => {
+          d.documentType = DocumentType.SouthAfricaGreenBook;
+          d.knownIdAspectRatio = 1.586;
+        }),
+      ]),
+    ).toBeUndefined();
+  });
+
+  it("accepts a documentType with an omitted knownIdAspectRatio", () => {
+    expect(
+      firstDocumentIssue([
+        documentCaptureStep((d) => {
+          d.documentType = DocumentType.GenericDocument();
+        }),
+      ]),
+    ).toBeUndefined();
+  });
+});
+
+describe("FlowValidator — analyzer-per-capture-type", () => {
+  for (const { name, value: jobType } of SELFIE_JOB_TYPES) {
+    it(`${name}: missing ml block emits "is required" + MissingMLConfigurationBlockException`, () => {
+      // Partner never opened the ml { } block. Validator emits BOTH a
+      // warning-severity MissingMLConfigurationBlockException AND an
+      // error-severity InvalidJobTypeScreenConfigException with the
+      // "is required" wording — same dual-emit pattern as the native
+      // SDKs.
+      const issues = runFlowValidation({
+        steps: [captureStep(CaptureType.selfie), processingStep()],
+        network: validNetwork(jobType),
+        userDetails: validUserDetails,
+      });
+
+      expect(
+        issues.some((i) => i instanceof MissingMLConfigurationBlockException),
+      ).toBe(true);
+      expect(
+        issues.some(
+          (i) =>
+            i instanceof InvalidJobTypeScreenConfigException &&
+            i.message.includes(
+              "ml { } block is required and must register analyzers for CaptureType.SELFIE",
+            ),
+        ),
+      ).toBe(true);
+    });
+
+    it(`${name}: ml block present but no selfie analyzer emits "must register" message`, () => {
+      const ml: MLConfig = { analyzers: { document: stubDocumentAnalyzer() } };
+
+      const issues = runFlowValidation({
+        steps: [captureStep(CaptureType.selfie), processingStep()],
+        network: validNetwork(jobType),
+        ml,
+        userDetails: validUserDetails,
+      });
+
+      expect(
+        issues.some(
+          (i) =>
+            i instanceof InvalidJobTypeScreenConfigException &&
+            !i.message.includes("is required") &&
+            i.message.includes(
+              "ml { } block must register analyzers for CaptureType.SELFIE",
+            ),
+        ),
+      ).toBe(true);
+    });
+
+    it(`${name}: registering a document analyzer emits "must not register" message`, () => {
+      const ml: MLConfig = {
+        analyzers: {
+          selfie: stubFaceAnalyzer(),
+          document: stubDocumentAnalyzer(),
+        },
+      };
+
+      const issues = runFlowValidation({
+        steps: [captureStep(CaptureType.selfie), processingStep()],
+        network: validNetwork(jobType),
+        ml,
+        userDetails: validUserDetails,
+      });
+
+      expect(
+        issues.some(
+          (i) =>
+            i instanceof InvalidJobTypeScreenConfigException &&
+            i.message.includes(
+              "must not register analyzers for CaptureType.DOCUMENT",
+            ),
+        ),
+      ).toBe(true);
+    });
+  }
+
+  for (const { name, value: jobType } of DOCUMENT_JOB_TYPES) {
+    it(`${name}: missing selfie analyzer emits "must register" message`, () => {
+      const ml: MLConfig = { analyzers: { document: stubDocumentAnalyzer() } };
+
+      const issues = runFlowValidation({
+        steps: [
+          captureStep(CaptureType.selfie),
+          captureStep(CaptureType.document),
+          processingStep(),
+        ],
+        network: validNetwork(jobType),
+        ml,
+      });
+
+      expect(
+        issues.some(
+          (i) =>
+            i instanceof InvalidJobTypeScreenConfigException &&
+            i.message.includes(
+              "ml { } block must register analyzers for CaptureType.SELFIE",
+            ),
+        ),
+      ).toBe(true);
+    });
+
+    it(`${name}: only selfie analyzer registered passes analyzer-per-type rule`, () => {
+      // Document analyzer is OPTIONAL — platform falls back to noop.
+      const ml: MLConfig = { analyzers: { selfie: stubFaceAnalyzer() } };
+
+      const issues = runFlowValidation({
+        steps: [
+          captureStep(CaptureType.selfie),
+          captureStep(CaptureType.document),
+          processingStep(),
+        ],
+        network: validNetwork(jobType),
+        ml,
+      });
+
+      expect(
+        issues.some(
+          (i) =>
+            i instanceof InvalidJobTypeScreenConfigException &&
+            i.message.includes("CaptureType"),
+        ),
+      ).toBe(false);
+    });
+
+    it(`${name}: selfie+document analyzers registered passes analyzer-per-type rule`, () => {
+      const ml: MLConfig = {
+        analyzers: {
+          selfie: stubFaceAnalyzer(),
+          document: stubDocumentAnalyzer(),
+        },
+      };
+
+      const issues = runFlowValidation({
+        steps: [
+          captureStep(CaptureType.selfie),
+          captureStep(CaptureType.document),
+          processingStep(),
+        ],
+        network: validNetwork(jobType),
+        ml,
+      });
+
+      expect(
+        issues.some(
+          (i) =>
+            i instanceof InvalidJobTypeScreenConfigException &&
+            i.message.includes(
+              "must not register analyzers for CaptureType.DOCUMENT",
+            ),
+        ),
+      ).toBe(false);
+    });
+  }
+});
+
+describe("FlowValidator — document verification params", () => {
+  it("accepts DocumentVerificationParams with only a country (idType optional)", () => {
+    expect(
+      runDocumentVerificationParamsValidation({ country: "KE" }),
+    ).toHaveLength(0);
+  });
+
+  it("rejects a blank country on DocumentVerificationParams", () => {
+    const issues = runDocumentVerificationParamsValidation({ country: "  " });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidFieldValueException &&
+          i.message.includes("country"),
+      ),
+    ).toBe(true);
+  });
+
+  it("rejects a present-but-blank idType on DocumentVerificationParams", () => {
+    const issues = runDocumentVerificationParamsValidation({
+      country: "KE",
+      idType: "  ",
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidFieldValueException &&
+          i.message.includes("idType"),
+      ),
+    ).toBe(true);
+  });
+
+  it("requires both country and idType on EnhancedDocumentVerificationParams", () => {
+    const issues = runEnhancedDocumentVerificationParamsValidation({
+      country: "",
+      idType: "",
+    });
+    expect(
+      issues.filter((i) => i instanceof InvalidFieldValueException),
+    ).toHaveLength(2);
+  });
+
+  it("accepts a fully-populated EnhancedDocumentVerificationParams", () => {
+    expect(
+      runEnhancedDocumentVerificationParamsValidation({
+        country: "KE",
+        idType: "NATIONAL_ID",
+      }),
+    ).toHaveLength(0);
+  });
+});