Implement review suggestions

Author: RenanSouza2

packages/hardhat-chai-matchers/src/internal/utils.ts

@@ -55,7 +55,7 @@ export function assertArgsArraysEqual(
   ssfi: Ssfi
 ) {
   try {
-    assertArgsArraysEqualNested(
+    innerAssertArgsArraysEqual(
       Assertion,
       expectedArgs,
       actualArgs,
@@ -69,79 +69,28 @@ export function assertArgsArraysEqual(
   }
 }
 
-export function assertArgsArraysEqualNested(
+export function innerAssertArgsArraysEqual(
   Assertion: Chai.AssertionStatic,
   expectedArgs: any[],
   actualArgs: any[],
   assertionType: "event" | "error",
   assert: AssertWithSsfi,
   ssfi: Ssfi
 ) {
-  const ethers = require("ethers") as typeof EthersT;
   assert(
     actualArgs.length === expectedArgs.length,
     `Expected arguments array to have length ${expectedArgs.length}, but it has ${actualArgs.length}`
   );
   for (const [index, expectedArg] of expectedArgs.entries()) {
-    const actualArg = actualArgs[index];
     try {
-      if (typeof expectedArg === "function") {
-        try {
-          if (expectedArg(actualArg) === true) continue;
-        } catch (e: any) {
-          assert(
-            false,
-            `The predicate threw when called: ${e.message}`
-            // no need for a negated message, since we disallow mixing .not. with
-            // .withArgs
-          );
-        }
-        assert(
-          false,
-          `The predicate did not return true`
-          // no need for a negated message, since we disallow mixing .not. with
-          // .withArgs
-        );
-      } else if (expectedArg instanceof Uint8Array) {
-        new Assertion(actualArg, undefined, ssfi, true).equal(
-          ethers.hexlify(expectedArg)
-        );
-      } else if (
-        expectedArg?.length !== undefined &&
-        typeof expectedArg !== "string"
-      ) {
-        assertArgsArraysEqualNested(
-          Assertion,
-          expectedArg,
-          actualArg,
-          assertionType,
-          assert,
-          ssfi
-        );
-      } else {
-        if (actualArg.hash !== undefined && actualArg._isIndexed === true) {
-          if (assertionType !== "event")
-            assert(
-              false,
-              "Should not get here. Please open an issue about that"
-            );
-
-          new Assertion(actualArg.hash, undefined, ssfi, true).to.not.equal(
-            expectedArg,
-            "The actual value was an indexed and hashed value of the event argument. The expected value provided to the assertion should be the actual event argument (the pre-image of the hash). You provided the hash itself. Please supply the actual event argument (the pre-image of the hash) instead."
-          );
-          const expectedArgBytes = ethers.isHexString(expectedArg)
-            ? ethers.getBytes(expectedArg)
-            : ethers.toUtf8Bytes(expectedArg);
-          const expectedHash = ethers.keccak256(expectedArgBytes);
-          new Assertion(actualArg.hash, undefined, ssfi, true).to.equal(
-            expectedHash,
-            `The actual value was an indexed and hashed value of the event argument. The expected value provided to the assertion was hashed to produce ${expectedHash}. The actual hash and the expected hash ${actualArg.hash} did not match`
-          );
-        } else {
-          new Assertion(actualArg, undefined, ssfi, true).equal(expectedArg);
-        }
-      }
+      innerAssertArgEqual(
+        Assertion,
+        expectedArg,
+        actualArgs[index],
+        assertionType,
+        assert,
+        ssfi
+      );
     } catch (err: any) {
       const ordinal = require("ordinal") as typeof OrdinalT;
       err.message = `Error in the ${ordinal(index + 1)} argument assertion: ${
@@ -151,3 +100,68 @@ export function assertArgsArraysEqualNested(
     }
   }
 }
+
+function innerAssertArgEqual(
+  Assertion: Chai.AssertionStatic,
+  expectedArg: any,
+  actualArg: any,
+  assertionType: "event" | "error",
+  assert: AssertWithSsfi,
+  ssfi: Ssfi
+) {
+  const ethers = require("ethers") as typeof EthersT;
+  if (typeof expectedArg === "function") {
+    try {
+      if (expectedArg(actualArg) === true) return;
+    } catch (e: any) {
+      assert(
+        false,
+        `The predicate threw when called: ${e.message}`
+        // no need for a negated message, since we disallow mixing .not. with
+        // .withArgs
+      );
+    }
+    assert(
+      false,
+      `The predicate did not return true`
+      // no need for a negated message, since we disallow mixing .not. with
+      // .withArgs
+    );
+  } else if (expectedArg instanceof Uint8Array) {
+    new Assertion(actualArg, undefined, ssfi, true).equal(
+      ethers.hexlify(expectedArg)
+    );
+  } else if (
+    expectedArg?.length !== undefined &&
+    typeof expectedArg !== "string"
+  ) {
+    innerAssertArgsArraysEqual(
+      Assertion,
+      expectedArg,
+      actualArg,
+      assertionType,
+      assert,
+      ssfi
+    );
+  } else {
+    if (actualArg.hash !== undefined && actualArg._isIndexed === true) {
+      if (assertionType !== "event")
+        assert(false, "Should not get here. Please open an issue about that");
+
+      new Assertion(actualArg.hash, undefined, ssfi, true).to.not.equal(
+        expectedArg,
+        "The actual value was an indexed and hashed value of the event argument. The expected value provided to the assertion should be the actual event argument (the pre-image of the hash). You provided the hash itself. Please supply the actual event argument (the pre-image of the hash) instead."
+      );
+      const expectedArgBytes = ethers.isHexString(expectedArg)
+        ? ethers.getBytes(expectedArg)
+        : ethers.toUtf8Bytes(expectedArg);
+      const expectedHash = ethers.keccak256(expectedArgBytes);
+      new Assertion(actualArg.hash, undefined, ssfi, true).to.equal(
+        expectedHash,
+        `The actual value was an indexed and hashed value of the event argument. The expected value provided to the assertion was hashed to produce ${expectedHash}. The actual hash and the expected hash ${actualArg.hash} did not match`
+      );
+    } else {
+      new Assertion(actualArg, undefined, ssfi, true).equal(expectedArg);
+    }
+  }
+}

packages/hardhat-chai-matchers/test/events.ts

@@ -133,7 +133,7 @@ describe(".to.emit (contract events)", () => {
               .withArgs(2)
           ).to.be.eventually.rejectedWith(
             AssertionError,
-            'Error in "WithUintArg" event: Error in the 1st argument assertion: expected 1 to equal 2. The numerical values of the given "bigint" and "number" inputs were compared, and they differed'
+            'Error in "WithUintArg" event: Error in the 1st argument assertion: expected 1 to equal 2.'
           );
         });
 
@@ -391,7 +391,7 @@ describe(".to.emit (contract events)", () => {
               .withArgs([3, 4])
           ).to.be.eventually.rejectedWith(
             AssertionError,
-            `Error in "WithUintArray" event: Error in the 1st argument assertion: Error in the 1st argument assertion: expected 1 to equal 3. The numerical values of the given "bigint" and "number" inputs were compared, and they differed`
+            `Error in "WithUintArray" event: Error in the 1st argument assertion: Error in the 1st argument assertion: expected 1 to equal 3.`
           );
         });
 
@@ -495,7 +495,7 @@ describe(".to.emit (contract events)", () => {
               .withArgs([3, 4])
           ).to.be.eventually.rejectedWith(
             AssertionError,
-            'Error in "WithStructArg" event: Error in the 1st argument assertion: Error in the 1st argument assertion: expected 1 to equal 3. The numerical values of the given "bigint" and "number" inputs were compared, and they differed'
+            'Error in "WithStructArg" event: Error in the 1st argument assertion: Error in the 1st argument assertion: expected 1 to equal 3.'
           );
         });
       });
@@ -514,7 +514,7 @@ describe(".to.emit (contract events)", () => {
               .withArgs(2, 2)
           ).to.be.eventually.rejectedWith(
             AssertionError,
-            'Error in "WithTwoUintArgs" event: Error in the 1st argument assertion: expected 1 to equal 2. The numerical values of the given "bigint" and "number" inputs were compared, and they differed'
+            'Error in "WithTwoUintArgs" event: Error in the 1st argument assertion: expected 1 to equal 2'
           );
         });
 
@@ -525,7 +525,7 @@ describe(".to.emit (contract events)", () => {
               .withArgs(1, 1)
           ).to.be.eventually.rejectedWith(
             AssertionError,
-            'Error in "WithTwoUintArgs" event: Error in the 2nd argument assertion: expected 2 to equal 1. The numerical values of the given "bigint" and "number" inputs were compared, and they differed'
+            'Error in "WithTwoUintArgs" event: Error in the 2nd argument assertion: expected 2 to equal 1.'
           );
         });
 
@@ -684,7 +684,7 @@ describe(".to.emit (contract events)", () => {
                 .and.to.emit(contract, "WithStringArg")
             ).to.be.eventually.rejectedWith(
               AssertionError,
-              'Error in "WithUintArg" event: Error in the 1st argument assertion: expected 1 to equal 2. The numerical values of the given "bigint" and "number" inputs were compared, and they differed'
+              'Error in "WithUintArg" event: Error in the 1st argument assertion: expected 1 to equal 2.'
             );
           });
 

packages/hardhat-chai-matchers/test/reverted/revertedWithCustomError.ts

@@ -16,7 +16,7 @@ import { anyUint, anyValue } from "../../src/withArgs";
 import { MatchersContract } from "../contracts";
 
 describe("INTEGRATION: Reverted with custom error", function () {
-  describe.skip("with the in-process hardhat network", function () {
+  describe("with the in-process hardhat network", function () {
     useEnvironment("hardhat-project");
 
     runTests();
@@ -237,7 +237,7 @@ describe("INTEGRATION: Reverted with custom error", function () {
               .withArgs(2)
           ).to.be.rejectedWith(
             AssertionError,
-            'Error in "CustomErrorWithUint" custom error: Error in the 1st argument assertion: expected 1 to equal 2. The numerical values of the given "bigint" and "number" inputs were compared, and they differed'
+            'Error in "CustomErrorWithUint" custom error: Error in the 1st argument assertion: expected 1 to equal 2.'
           );
         });
       });
@@ -264,7 +264,7 @@ describe("INTEGRATION: Reverted with custom error", function () {
               .withArgs(2, "foo")
           ).to.be.rejectedWith(
             AssertionError,
-            'Error in "CustomErrorWithUintAndString" custom error: Error in the 1st argument assertion: expected 1 to equal 2. The numerical values of the given "bigint" and "number" inputs were compared, and they differed'
+            'Error in "CustomErrorWithUintAndString" custom error: Error in the 1st argument assertion: expected 1 to equal 2.'
           );
         });
 
@@ -282,7 +282,7 @@ describe("INTEGRATION: Reverted with custom error", function () {
           );
         });
 
-        it("Should if first prefdicate fails", async function () {
+        it("Should fail if first predicate throws", async function () {
           await expect(
             expect(matchers.revertWithCustomErrorWithUintAndString(1, "foo"))
               .to.be.revertedWithCustomError(
@@ -300,7 +300,7 @@ describe("INTEGRATION: Reverted with custom error", function () {
       });
 
       describe("different number of arguments", function () {
-        it("Should reject if expected less arguments", async function () {
+        it("Should reject if expected fewer arguments", async function () {
           await expect(
             expect(matchers.revertWithCustomErrorWithUintAndString(1, "s"))
               .to.be.revertedWithCustomError(
@@ -343,7 +343,7 @@ describe("INTEGRATION: Reverted with custom error", function () {
               .withArgs([3, 2])
           ).to.be.rejectedWith(
             AssertionError,
-            'Error in "CustomErrorWithPair" custom error: Error in the 1st argument assertion: Error in the 1st argument assertion: expected 1 to equal 3. The numerical values of the given "bigint" and "number" inputs were compared, and they differed'
+            'Error in "CustomErrorWithPair" custom error: Error in the 1st argument assertion: Error in the 1st argument assertion: expected 1 to equal 3.'
           );
         });
       });