@smileid/usesmileid 12.0.0-beta01

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

@@ -0,0 +1,704 @@
+import { describe, expect, it, vi } from "vitest";
+import type {
+  FaceAnalyzer,
+  DocumentAnalyzer,
+} from "@smileid/usesmileid_platform_interface";
+import { AnalyzerFactoryKey } from "@smileid/usesmileid_bridge";
+import { collectJobTypeIssues } from "../job_type_validator";
+import type { JobTypeValidatorInput } from "../job_type_validator";
+import type { ValidationIssue } from "../validation_state";
+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,
+  ConsentConfigBuilder,
+  PreviewConfigBuilder,
+} from "../../dsl/builder/screens_builder";
+import { InvalidJobTypeScreenConfigException } from "../../../../core/exception/job_validation_exceptions";
+import {
+  InvalidScreenOrderException,
+  MissingCaptureForPreviewException,
+} from "../../../../core/exception/screen_config_validation_exceptions";
+
+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. These
+  // tests target the job-type / ordering rules, so default to a generic
+  // document and let the dedicated config tests cover 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 consentStep() {
+  return { kind: "consent" as const, config: new ConsentConfigBuilder() };
+}
+
+function previewStep() {
+  return { kind: "preview" as const, config: new PreviewConfigBuilder() };
+}
+
+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",
+};
+
+const validDocumentParams = { country: "KE", idType: "NATIONAL_ID" } as const;
+const validEnhancedDocumentParams = {
+  country: "KE",
+  idType: "NATIONAL_ID",
+} as const;
+
+function run(input: JobTypeValidatorInput): ValidationIssue[] {
+  const issues: ValidationIssue[] = [];
+  collectJobTypeIssues(input, issues);
+  return issues;
+}
+
+describe("JobTypeValidator — userDetails-required rule", () => {
+  it("emits userDetails-required issue when a selfie job omits userDetails", () => {
+    const issues = run({
+      steps: [consentStep(), captureStep(CaptureType.selfie), processingStep()],
+      network: validNetwork(JobType.smartSelfieEnrollment),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes(
+            "userDetails is required for SmartSelfieEnrollment jobs",
+          ),
+      ),
+    ).toBe(true);
+  });
+
+  it("does not emit userDetails issue when present", () => {
+    const issues = run({
+      steps: [consentStep(), captureStep(CaptureType.selfie), processingStep()],
+      network: validNetwork(JobType.smartSelfieEnrollment),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes("userDetails is required"),
+      ),
+    ).toBe(false);
+  });
+
+  it("requires userDetails for documentVerification too", () => {
+    const issues = run({
+      steps: [
+        consentStep(),
+        captureStep(CaptureType.selfie),
+        captureStep(CaptureType.document),
+        processingStep(),
+      ],
+      network: validNetwork(JobType.documentVerification),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      documentVerificationParams: validDocumentParams,
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes(
+            "userDetails is required for DocumentVerification jobs",
+          ),
+      ),
+    ).toBe(true);
+  });
+});
+
+describe("JobTypeValidator — analyzer-per-capture-type rule", () => {
+  it("flags a selfie job whose ml block registers only a document analyzer", () => {
+    const ml: MLConfig = { analyzers: { document: stubDocumentAnalyzer() } };
+    const issues = run({
+      steps: [consentStep(), captureStep(CaptureType.selfie), processingStep()],
+      network: validNetwork(JobType.biometricKyc),
+      ml,
+      biometricKYCParams: {
+        idType: "NATIONAL_ID",
+        idNumber: "1",
+        country: "KE",
+        useEnrolledImage: false,
+      },
+      userDetails: validUserDetails,
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes(
+            "ml { } block must register analyzers for CaptureType.SELFIE",
+          ),
+      ),
+    ).toBe(true);
+  });
+
+  it("flags a selfie job that wrongly registers a document analyzer", () => {
+    const ml: MLConfig = {
+      analyzers: {
+        selfie: stubFaceAnalyzer(),
+        document: stubDocumentAnalyzer(),
+      },
+    };
+    const issues = run({
+      steps: [consentStep(), captureStep(CaptureType.selfie), processingStep()],
+      network: validNetwork(JobType.smartSelfieAuthentication),
+      ml,
+      userDetails: validUserDetails,
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes(
+            "must not register analyzers for CaptureType.DOCUMENT",
+          ),
+      ),
+    ).toBe(true);
+  });
+});
+
+describe("JobTypeValidator — non-capture job rules", () => {
+  it("rejects capture screens for enhancedKyc and requires enhancedKYCParams + userDetails", () => {
+    const issues = run({
+      steps: [consentStep(), captureStep(CaptureType.selfie), processingStep()],
+      network: validNetwork(JobType.enhancedKyc),
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes(
+            "must only contain consent and processing screens, but found: capture",
+          ),
+      ),
+    ).toBe(true);
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes("enhancedKYCParams is required for EnhancedKyc"),
+      ),
+    ).toBe(true);
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes("userDetails is required for EnhancedKyc"),
+      ),
+    ).toBe(true);
+  });
+
+  it("requires a consent screen or pre-supplied consentInformation for bvn", () => {
+    const issues = run({
+      steps: [processingStep()],
+      network: validNetwork(JobType.bvn),
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes(
+            "Invalid configuration for BVN: must include either a Consent screen or a pre-supplied consentInformation",
+          ),
+      ),
+    ).toBe(true);
+  });
+
+  it("accepts a consent + processing bvn flow", () => {
+    const issues = run({
+      steps: [consentStep(), processingStep()],
+      network: validNetwork(JobType.bvn),
+    });
+    expect(
+      issues.some((i) => i instanceof InvalidJobTypeScreenConfigException),
+    ).toBe(false);
+  });
+});
+
+describe("JobTypeValidator — preview placement rule", () => {
+  it("allows two Preview screens for a document flow, each after a capture", () => {
+    const issues = run({
+      steps: [
+        captureStep(CaptureType.selfie),
+        previewStep(),
+        captureStep(CaptureType.document),
+        previewStep(),
+        processingStep(),
+      ],
+      network: validNetwork(JobType.documentVerification),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+    });
+    expect(
+      issues.some((i) => i instanceof MissingCaptureForPreviewException),
+    ).toBe(false);
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidScreenOrderException &&
+          i.message.includes("exceeds the maximum"),
+      ),
+    ).toBe(false);
+  });
+
+  it("rejects a third Preview screen for a document flow", () => {
+    const issues = run({
+      steps: [
+        captureStep(CaptureType.selfie),
+        previewStep(),
+        captureStep(CaptureType.document),
+        previewStep(),
+        previewStep(),
+        processingStep(),
+      ],
+      network: validNetwork(JobType.documentVerification),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidScreenOrderException &&
+          i.message.includes(
+            "exceeds the maximum of 2 preview screen(s) allowed for this flow",
+          ),
+      ),
+    ).toBe(true);
+  });
+
+  it("rejects a second Preview screen for a selfie flow and a preview without a capture", () => {
+    const tooManyPreviews = run({
+      steps: [
+        captureStep(CaptureType.selfie),
+        previewStep(),
+        previewStep(),
+        processingStep(),
+      ],
+      network: validNetwork(JobType.smartSelfieEnrollment),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+    });
+    expect(
+      tooManyPreviews.some(
+        (i) =>
+          i instanceof InvalidScreenOrderException &&
+          i.message.includes(
+            "exceeds the maximum of 1 preview screen(s) allowed for this flow",
+          ),
+      ),
+    ).toBe(true);
+
+    const previewWithoutCapture = run({
+      steps: [previewStep(), captureStep(CaptureType.selfie), processingStep()],
+      network: validNetwork(JobType.smartSelfieEnrollment),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+    });
+    expect(
+      previewWithoutCapture.some(
+        (i) =>
+          i instanceof MissingCaptureForPreviewException &&
+          i.message.includes("index 0"),
+      ),
+    ).toBe(true);
+  });
+});
+
+const validBiometricParams = {
+  idType: "NATIONAL_ID",
+  idNumber: "1",
+  country: "KE",
+  useEnrolledImage: false,
+} as const;
+
+describe("SelfieJobTypeValidator — Android-parity rules", () => {
+  it("requires exactly one SELFIE capture (none present)", () => {
+    const issues = run({
+      steps: [consentStep(), processingStep()],
+      network: validNetwork(JobType.smartSelfieEnrollment),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes(
+            "must include exactly one Capture screen with captureType = SELFIE",
+          ),
+      ),
+    ).toBe(true);
+  });
+
+  it("rejects more than one SELFIE capture with a count", () => {
+    const issues = run({
+      steps: [
+        consentStep(),
+        captureStep(CaptureType.selfie),
+        captureStep(CaptureType.selfie),
+        processingStep(),
+      ],
+      network: validNetwork(JobType.smartSelfieEnrollment),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes(
+            "must include exactly one Capture screen with captureType = SELFIE, but found 2",
+          ),
+      ),
+    ).toBe(true);
+  });
+
+  it("rejects a Document capture screen in a selfie flow", () => {
+    const issues = run({
+      steps: [
+        consentStep(),
+        captureStep(CaptureType.selfie),
+        captureStep(CaptureType.document),
+        processingStep(),
+      ],
+      network: validNetwork(JobType.smartSelfieEnrollment),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes("must not include a Document capture screen"),
+      ),
+    ).toBe(true);
+  });
+
+  it("requires a Processing screen", () => {
+    const issues = run({
+      steps: [consentStep(), captureStep(CaptureType.selfie)],
+      network: validNetwork(JobType.smartSelfieEnrollment),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes("must include a Processing screen"),
+      ),
+    ).toBe(true);
+  });
+
+  it("requires consent (none present)", () => {
+    const issues = run({
+      steps: [captureStep(CaptureType.selfie), processingStep()],
+      network: validNetwork(JobType.smartSelfieEnrollment),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes(
+            "must include either a Consent screen or a pre-supplied consentInformation",
+          ),
+      ),
+    ).toBe(true);
+  });
+
+  it("rejects both a Consent screen and pre-supplied consentInformation", () => {
+    const issues = run({
+      steps: [consentStep(), captureStep(CaptureType.selfie), processingStep()],
+      network: validNetwork(JobType.smartSelfieEnrollment),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+      consentInformation: {
+        granted: true,
+        grantedAt: "2024-01-01T00:00:00.000Z",
+        noticeLanguage: "EN",
+        noticePrivacyPolicyUrl: "https://example.com",
+      },
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes(
+            "must not include both a Consent screen and a pre-supplied consentInformation",
+          ),
+      ),
+    ).toBe(true);
+  });
+
+  it("requires biometricKYCParams for BiometricKyc", () => {
+    const issues = run({
+      steps: [consentStep(), captureStep(CaptureType.selfie), processingStep()],
+      network: validNetwork(JobType.biometricKyc),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes(
+            "biometricKYCParams is required for BiometricKyc jobs",
+          ),
+      ),
+    ).toBe(true);
+  });
+
+  it("passes a fully-configured BiometricKyc flow", () => {
+    const issues = run({
+      steps: [consentStep(), captureStep(CaptureType.selfie), processingStep()],
+      network: validNetwork(JobType.biometricKyc),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+      biometricKYCParams: validBiometricParams,
+    });
+    expect(
+      issues.some((i) => i instanceof InvalidJobTypeScreenConfigException),
+    ).toBe(false);
+  });
+});
+
+describe("DocumentJobTypeValidator — Android-parity rules", () => {
+  it("requires exactly one DOCUMENT capture (none present)", () => {
+    const issues = run({
+      steps: [consentStep(), captureStep(CaptureType.selfie), processingStep()],
+      network: validNetwork(JobType.documentVerification),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes(
+            "must include exactly one Capture screen with captureType = DOCUMENT",
+          ),
+      ),
+    ).toBe(true);
+  });
+
+  it("rejects more than one DOCUMENT capture with a count", () => {
+    const issues = run({
+      steps: [
+        consentStep(),
+        captureStep(CaptureType.selfie),
+        captureStep(CaptureType.document),
+        captureStep(CaptureType.document),
+        processingStep(),
+      ],
+      network: validNetwork(JobType.documentVerification),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes(
+            "must include exactly one Capture screen with captureType = DOCUMENT, but found 2",
+          ),
+      ),
+    ).toBe(true);
+  });
+
+  it("requires a selfie analyzer (document noop by default)", () => {
+    const issues = run({
+      steps: [
+        consentStep(),
+        captureStep(CaptureType.selfie),
+        captureStep(CaptureType.document),
+        processingStep(),
+      ],
+      network: validNetwork(JobType.documentVerification),
+      ml: { analyzers: { document: stubDocumentAnalyzer() } },
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes(
+            "ml { } block must register analyzers for CaptureType.SELFIE",
+          ),
+      ),
+    ).toBe(true);
+  });
+
+  it("requires documentVerificationParams for DocumentVerification", () => {
+    const issues = run({
+      steps: [
+        consentStep(),
+        captureStep(CaptureType.selfie),
+        captureStep(CaptureType.document),
+        processingStep(),
+      ],
+      network: validNetwork(JobType.documentVerification),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes(
+            "documentVerificationParams is required for DocumentVerification jobs",
+          ),
+      ),
+    ).toBe(true);
+  });
+
+  it("requires enhancedDocumentVerificationParams for EnhancedDocumentVerification", () => {
+    const issues = run({
+      steps: [
+        consentStep(),
+        captureStep(CaptureType.selfie),
+        captureStep(CaptureType.document),
+        processingStep(),
+      ],
+      network: validNetwork(JobType.enhancedDocumentVerification),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes(
+            "enhancedDocumentVerificationParams is required for EnhancedDocumentVerification jobs",
+          ),
+      ),
+    ).toBe(true);
+  });
+
+  it("passes a fully-configured DocumentVerification flow", () => {
+    const issues = run({
+      steps: [
+        consentStep(),
+        captureStep(CaptureType.selfie),
+        captureStep(CaptureType.document),
+        processingStep(),
+      ],
+      network: validNetwork(JobType.documentVerification),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+      documentVerificationParams: validDocumentParams,
+    });
+    expect(
+      issues.some((i) => i instanceof InvalidJobTypeScreenConfigException),
+    ).toBe(false);
+  });
+
+  it("passes a fully-configured EnhancedDocumentVerification flow", () => {
+    const issues = run({
+      steps: [
+        consentStep(),
+        captureStep(CaptureType.selfie),
+        captureStep(CaptureType.document),
+        processingStep(),
+      ],
+      network: validNetwork(JobType.enhancedDocumentVerification),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+      enhancedDocumentVerificationParams: validEnhancedDocumentParams,
+    });
+    expect(
+      issues.some((i) => i instanceof InvalidJobTypeScreenConfigException),
+    ).toBe(false);
+  });
+});
+
+describe("NonCaptureJobTypeValidator — Android-parity rules", () => {
+  it("passes a fully-configured EnhancedKyc flow", () => {
+    const issues = run({
+      steps: [consentStep(), processingStep()],
+      network: validNetwork(JobType.enhancedKyc),
+      enhancedKYCParams: {
+        idType: "NATIONAL_ID",
+        idNumber: "1",
+        country: "KE",
+      },
+      userDetails: validUserDetails,
+    });
+    expect(
+      issues.some((i) => i instanceof InvalidJobTypeScreenConfigException),
+    ).toBe(false);
+  });
+
+  it("rejects a preview screen for a non-capture flow", () => {
+    const issues = run({
+      steps: [consentStep(), previewStep(), processingStep()],
+      network: validNetwork(JobType.bvn),
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes(
+            "must only contain consent and processing screens, but found: preview",
+          ),
+      ),
+    ).toBe(true);
+  });
+});