self/contracts/test/unit/CircuitAttributeHandler.test.ts

import { expect } from "chai";
import { ethers } from "hardhat";
import { TestCircuitAttributeHandler } from "../../typechain-types";
import { CircuitAttributeHandler } from "../utils/formatter";

describe("CircuitAttributeHandler", function () {
  let testHandler: TestCircuitAttributeHandler;

  before(async function () {
    const TestHandlerFactory = await ethers.getContractFactory("TestCircuitAttributeHandler");
    testHandler = await TestHandlerFactory.deploy();
    await testHandler.waitForDeployment();
  });

  const mrz = ethers.toUtf8Bytes(
    "P<UTOERIKSSON<<ANNA<MARIA<<<<<<<<<<<<<<<<<<<" + "L898902C36UTO7408122F1204159ZE184226B<<<<<1018",
  );
  const sampleMRZ = new Uint8Array([...mrz, 1, 1, 1]);

  describe("getIssuingState", function () {
    it("should match contract and ts implementation", async function () {
      const contractResult = await testHandler.testGetIssuingState(sampleMRZ);
      const tsResult = CircuitAttributeHandler.getIssuingState(sampleMRZ);
      expect(contractResult).to.equal(tsResult);
      expect(contractResult).to.equal("UTO");
    });
  });

  describe("getName", function () {
    it("should match contract and ts implementation", async function () {
      const contractResult = await testHandler.testGetName(sampleMRZ);
      const tsResult = CircuitAttributeHandler.getName(sampleMRZ);
      expect(contractResult[0]).to.equal(tsResult[0]);
      expect(contractResult[1]).to.equal(tsResult[1]);
      expect(contractResult[0]).to.equal("ANNA MARIA");
      expect(contractResult[1]).to.equal("ERIKSSON");
    });
  });

  describe("getPassportNumber", function () {
    it("should match contract and ts implementation", async function () {
      const contractResult = await testHandler.testGetPassportNumber(sampleMRZ);
      const tsResult = CircuitAttributeHandler.getPassportNumber(sampleMRZ);
      expect(contractResult).to.equal(tsResult);
      expect(contractResult).to.equal("L898902C3");
    });
  });

  describe("getNationality", function () {
    it("should match contract and ts implementation", async function () {
      const contractResult = await testHandler.testGetNationality(sampleMRZ);
      const tsResult = CircuitAttributeHandler.getNationality(sampleMRZ);
      expect(contractResult).to.equal(tsResult);
      expect(contractResult).to.equal("UTO");
    });
  });

  describe("getDateOfBirth", function () {
    it("should match contract and ts implementation", async function () {
      const contractResult = await testHandler.testGetDateOfBirth(sampleMRZ);
      const tsResult = CircuitAttributeHandler.getDateOfBirth(sampleMRZ);
      expect(contractResult).to.equal(tsResult);
      expect(contractResult).to.equal("12-08-74");
    });
  });

  describe("getGender", function () {
    it("should match contract and ts implementation", async function () {
      const contractResult = await testHandler.testGetGender(sampleMRZ);
      const tsResult = CircuitAttributeHandler.getGender(sampleMRZ);
      expect(contractResult).to.equal(tsResult);
      expect(contractResult).to.equal("F");
    });
  });

  describe("getExpiryDate", function () {
    it("should match contract and ts implementation", async function () {
      const contractResult = await testHandler.testGetExpiryDate(sampleMRZ);
      const tsResult = CircuitAttributeHandler.getExpiryDate(sampleMRZ);
      expect(contractResult).to.equal(tsResult);
      expect(contractResult).to.equal("15-04-12");
    });
  });

  describe("getOlderThan and compareOlderThan", function () {
    it("should match contract and ts implementation for getOlderThan", async function () {
      const contractResult = await testHandler.testGetOlderThan(sampleMRZ);
      const tsResult = CircuitAttributeHandler.getOlderThan(sampleMRZ);
      expect(contractResult).to.equal(tsResult);
      expect(contractResult).to.equal(18);
    });

    it("should match contract and ts implementation for compareOlderThan", async function () {
      const contractResult = await testHandler.testCompareOlderThan(sampleMRZ, 18);
      const tsResult = CircuitAttributeHandler.compareOlderThan(sampleMRZ, 18);
      expect(contractResult).to.equal(tsResult);
      expect(contractResult).to.be.true;

      const contractResultFalse = await testHandler.testCompareOlderThan(sampleMRZ, 19);
      const tsResultFalse = CircuitAttributeHandler.compareOlderThan(sampleMRZ, 19);
      expect(contractResultFalse).to.equal(tsResultFalse);
      expect(contractResultFalse).to.be.false;
    });
  });

  describe("getPassportNoOfac, getNameAndDobOfac, getNameAndYobOfac and compareOfac", function () {
    it("should match contract and ts implementation for getPassportNoOfac, getNameAndDobOfac, getNameAndYobOfac", async function () {
      const contractResult = await testHandler.testGetPassportNoOfac(sampleMRZ);
      const tsResult = CircuitAttributeHandler.getPassportNoOfac(sampleMRZ);
      expect(contractResult).to.equal(tsResult);
      expect(contractResult).to.equal(1);

      const contractResult2 = await testHandler.testGetNameAndDobOfac(sampleMRZ);
      const tsResult2 = CircuitAttributeHandler.getNameAndDobOfac(sampleMRZ);
      expect(contractResult2).to.equal(tsResult2);
      expect(contractResult2).to.equal(1);

      const contractResult3 = await testHandler.testGetNameAndYobOfac(sampleMRZ);
      const tsResult3 = CircuitAttributeHandler.getNameAndYobOfac(sampleMRZ);
      expect(contractResult3).to.equal(tsResult3);
      expect(contractResult3).to.equal(1);
    });

    it("should match contract and ts implementation for individual OFAC checks using flags", async function () {
      // Test passport number check
      const contractPassportNo = await testHandler.testCompareOfac(sampleMRZ, true, false, false);
      const tsPassportNo = CircuitAttributeHandler.compareOfac(sampleMRZ, true, false, false);
      expect(contractPassportNo).to.equal(tsPassportNo);
      expect(contractPassportNo).to.be.true;

      // Test name and DOB check
      const contractNameDob = await testHandler.testCompareOfac(sampleMRZ, false, true, false);
      const tsNameDob = CircuitAttributeHandler.compareOfac(sampleMRZ, false, true, false);
      expect(contractNameDob).to.equal(tsNameDob);
      expect(contractNameDob).to.be.true;

      // Test name and YOB check
      const contractNameYob = await testHandler.testCompareOfac(sampleMRZ, false, false, true);
      const tsNameYob = CircuitAttributeHandler.compareOfac(sampleMRZ, false, false, true);
      expect(contractNameYob).to.equal(tsNameYob);
      expect(contractNameYob).to.be.true;
    });

    it("should match contract and ts implementation for compareOfac", async function () {
      // Test with all flags true
      const contractAllTrue = await testHandler.testCompareOfac(sampleMRZ, true, true, true);
      const tsAllTrue = CircuitAttributeHandler.compareOfac(sampleMRZ, true, true, true);
      expect(contractAllTrue).to.equal(tsAllTrue);
      expect(contractAllTrue).to.be.true;

      // Test with some flags false
      const contractSomeTrue = await testHandler.testCompareOfac(sampleMRZ, true, false, true);
      const tsSomeTrue = CircuitAttributeHandler.compareOfac(sampleMRZ, true, false, true);
      expect(contractSomeTrue).to.equal(tsSomeTrue);
      expect(contractSomeTrue).to.be.true;
    });
  });

  describe("extractStringAttribute", function () {
    it("should match contract and ts implementation for different positions", async function () {
      const testCases = [
        { start: 2, end: 4, expected: "UTO" },
        { start: 44, end: 52, expected: "L898902C3" },
        { start: 54, end: 56, expected: "UTO" },
        { start: 64, end: 64, expected: "F" },
      ];

      for (const testCase of testCases) {
        const contractResult = await testHandler.testExtractStringAttribute(sampleMRZ, testCase.start, testCase.end);
        const tsResult = CircuitAttributeHandler.extractStringAttribute(sampleMRZ, testCase.start, testCase.end);
        expect(contractResult).to.equal(tsResult);
        expect(contractResult).to.equal(testCase.expected);
      }
    });

    it("should handle errors consistently between contract and ts", async function () {
      const shortMRZ = ethers.toUtf8Bytes("ABC");
      await expect(testHandler.testExtractStringAttribute(shortMRZ, 0, 5)).to.be.revertedWithCustomError(
        testHandler,
        "INSUFFICIENT_CHARCODE_LEN",
      );

      expect(() => CircuitAttributeHandler.extractStringAttribute(shortMRZ, 0, 5)).to.throw(
        "INSUFFICIENT_CHARCODE_LEN",
      );
    });

    it("should match contract and ts implementation for empty range", async function () {
      const contractResult = await testHandler.testExtractStringAttribute(sampleMRZ, 2, 2);
      const tsResult = CircuitAttributeHandler.extractStringAttribute(sampleMRZ, 2, 2);
      expect(contractResult).to.equal(tsResult);
      expect(contractResult).to.equal("U");
    });
  });
});