@smileid/usesmileid 12.0.2 → 12.1.0

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

@@ -1,616 +0,0 @@
-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,
-  MissingJobTypeException,
-  MissingMLConfigurationBlockException,
-} from "../../../../core/exception/job_validation_exceptions";
-import {
-  AgentModeWithEnhancedLivenessException,
-  InvalidDocumentCaptureConfigException,
-} from "../../../../core/exception/capture_validation_exceptions";
-import {
-  runConsentValidation,
-  runDocumentVerificationParamsValidation,
-  runEnhancedDocumentVerificationParamsValidation,
-  runUserDetailsValidation,
-} from "../flow_validator";
-import { InvalidConsentInformationException } from "../../../../core/exception/consent_validation_exceptions";
-import type { TokenPayload } from "../../../../data/model/token_payload";
-
-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 — selfie capture config", () => {
-  function selfieCaptureIssues(
-    configure: (s: {
-      allowAgentMode: boolean;
-      enableEnhancedLiveness: boolean;
-    }) => void,
-  ) {
-    const config = new CaptureConfigBuilder();
-    config.captureType = CaptureType.selfie;
-    config.selfie(configure);
-    return runFlowValidation({
-      steps: [{ kind: "capture" as const, config }, processingStep()],
-    });
-  }
-
-  function agentModeIssues(
-    configure: (s: {
-      allowAgentMode: boolean;
-      enableEnhancedLiveness: boolean;
-    }) => void,
-  ): AgentModeWithEnhancedLivenessException[] {
-    return selfieCaptureIssues(configure).filter(
-      (i): i is AgentModeWithEnhancedLivenessException =>
-        i instanceof AgentModeWithEnhancedLivenessException,
-    );
-  }
-
-  const rejectsAgentModePair = (
-    configure: Parameters<typeof agentModeIssues>[0],
-  ): boolean => agentModeIssues(configure).length > 0;
-
-  it("rejects agent mode combined with enhanced liveness", () => {
-    const issues = agentModeIssues((s) => {
-      s.allowAgentMode = true;
-      s.enableEnhancedLiveness = true;
-    });
-    expect(issues).toHaveLength(1);
-    // Wire string partner tooling pivots on — a rename is a breaking change.
-    expect(issues[0]?.errorCode).toBe(
-      "BUILDER_AGENT_MODE_WITH_ENHANCED_LIVENESS",
-    );
-  });
-
-  it("accepts agent mode and enhanced liveness on their own", () => {
-    expect(
-      rejectsAgentModePair((s) => {
-        s.allowAgentMode = true;
-      }),
-    ).toBe(false);
-    expect(
-      rejectsAgentModePair((s) => {
-        s.enableEnhancedLiveness = true;
-      }),
-    ).toBe(false);
-  });
-});
-
-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);
-  });
-});
-
-describe("FlowValidator — jobType recognition", () => {
-  const ml: MLConfig = { analyzers: { selfie: stubFaceAnalyzer() } };
-
-  function jobTypeIssue(jobType: JobType) {
-    const issues = runFlowValidation({
-      steps: [captureStep(CaptureType.selfie), processingStep()],
-      ml,
-      network: validNetwork(jobType),
-      userDetails: validUserDetails,
-    });
-    return issues.find(
-      (i): i is MissingJobTypeException => i instanceof MissingJobTypeException,
-    );
-  }
-
-  it("rejects a jobType that is not one of the SDK's job types", () => {
-    expect(jobTypeIssue(99 as JobType)).toBeInstanceOf(MissingJobTypeException);
-  });
-
-  it("still rejects the unknown sentinel", () => {
-    expect(jobTypeIssue(JobType.unknown)).toBeInstanceOf(
-      MissingJobTypeException,
-    );
-  });
-
-  it("accepts every job type the SDK submits", () => {
-    for (const jobType of Object.values(JobType)) {
-      if (jobType === JobType.unknown) continue;
-      expect(jobTypeIssue(jobType)).toBeUndefined();
-    }
-  });
-});
-
-describe("FlowValidator — token-provided user details (field-level relaxation)", () => {
-  function tokenPayload(overrides: Partial<TokenPayload> = {}): TokenPayload {
-    return {
-      hasGivenNames: false,
-      hasLastName: false,
-      hasEmail: false,
-      hasPhoneNumber: false,
-      ...overrides,
-    };
-  }
-
-  it("accepts contact-only userDetails when the token binds both names", () => {
-    const issues = runUserDetailsValidation(
-      { givenNames: "", lastName: "", email: "ada@example.com" },
-      tokenPayload({ hasGivenNames: true, hasLastName: true }),
-    );
-    expect(issues).toHaveLength(0);
-  });
-
-  it("accepts names-only userDetails when the token binds a contact field", () => {
-    const emailBound = runUserDetailsValidation(
-      { givenNames: "Ada", lastName: "Lovelace" },
-      tokenPayload({ hasEmail: true }),
-    );
-    expect(emailBound).toHaveLength(0);
-
-    const phoneBound = runUserDetailsValidation(
-      { givenNames: "Ada", lastName: "Lovelace" },
-      tokenPayload({ hasPhoneNumber: true }),
-    );
-    expect(phoneBound).toHaveLength(0);
-  });
-
-  it("relaxes per-field — a name the token does not bind still errors with today's message", () => {
-    const issues = runUserDetailsValidation(
-      { givenNames: "", lastName: "", email: "ada@example.com" },
-      tokenPayload({ hasGivenNames: true }),
-    );
-    expect(issues).toHaveLength(1);
-    expect(issues[0]).toBeInstanceOf(InvalidFieldValueException);
-    expect(issues[0]?.message).toContain("userDetails.lastName");
-  });
-
-  it("regression: without a token payload every existing rule fires unchanged", () => {
-    const issues = runUserDetailsValidation({ givenNames: "", lastName: "" });
-    expect(issues).toHaveLength(3);
-    const messages = issues.map((i) => i.message).join("\n");
-    expect(messages).toContain("userDetails.givenNames");
-    expect(messages).toContain("userDetails.lastName");
-    expect(messages).toContain(
-      "at least one of email or phoneNumber must be non blank",
-    );
-  });
-
-  it("threads tokenPayload through runFlowValidation to the field rules", () => {
-    const issues = runFlowValidation({
-      steps: [captureStep(CaptureType.selfie), processingStep()],
-      network: validNetwork(JobType.smartSelfieEnrollment),
-      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
-      userDetails: { givenNames: "", lastName: "", email: "ada@example.com" },
-      consentInformation: {
-        granted: true,
-        grantedAt: "2026-01-01T00:00:00.000Z",
-        noticeLanguage: "EN",
-        noticePrivacyPolicyUrl: "https://example.com",
-      },
-      tokenPayload: tokenPayload({ hasGivenNames: true, hasLastName: true }),
-    });
-    expect(issues.some((i) => i instanceof InvalidFieldValueException)).toBe(
-      false,
-    );
-  });
-
-  it("a complete token consent skips content validation of the ignored preset", () => {
-    // Token data always wins: the preset is never sent, so its
-    // contents raise no issue even when they would fail on their own.
-    const issues = runFlowValidation({
-      steps: [captureStep(CaptureType.selfie), processingStep()],
-      network: validNetwork(JobType.smartSelfieEnrollment),
-      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
-      userDetails: validUserDetails,
-      consentInformation: {
-        granted: false,
-        grantedAt: "",
-        noticeLanguage: "",
-        noticePrivacyPolicyUrl: "",
-      },
-      tokenPayload: {
-        ...tokenPayload(),
-        consent: {
-          granted: true,
-          grantedAt: "2026-01-01T09:00:00.000Z",
-          noticeLanguage: "EN",
-          noticePrivacyPolicyUrl: "https://partner.test/privacy",
-        },
-      },
-    });
-    expect(
-      issues.some((i) => i instanceof InvalidConsentInformationException),
-    ).toBe(false);
-  });
-
-  it("the standalone pre-flight validator stays strict (no token context)", () => {
-    // `b.validateUserDetails(payload)` has no token context by design —
-    // partners pre-flight the payload they would assign, and blank
-    // names still fail there.
-    expect(
-      runUserDetailsValidation({ givenNames: "", lastName: "Lovelace" }),
-    ).not.toHaveLength(0);
-    expect(
-      runConsentValidation({
-        granted: false,
-        grantedAt: "",
-        noticeLanguage: "",
-        noticePrivacyPolicyUrl: "",
-      }),
-    ).not.toHaveLength(0);
-  });
-});