Remove test dependency on expectRevert (chiru-labs#14)

Fixed tests in GitHub actions

Author: cygaar

.eslintrc

@@ -11,5 +11,13 @@
   },
   "globals": {
     "ethers": "readonly"
+  },
+  "rules": {
+    "max-len": [
+      "error",
+      {
+        "code": 120
+      }
+    ]
   }
 }

.github/workflows/run_tests.yml

@@ -24,5 +24,5 @@ jobs:
         run: npm ci
       - name: Run linter
         run: npm run lint
-      # - name: Run tests
-      #  run: npm test
+      - name: Run tests
+        run: npm test

README.md

@@ -56,7 +56,6 @@ contract Azuki is ERC721A {
 
 ## Roadmap
 
-- [] Setup CI pipeline to run tests on every PR
 - [] Add burn function
 - [] Add flexibility for the first token id to not start at 0
 - [] Move `_setOwnersExplicit` to an extension

test/ERC721A.test.js

@@ -1,5 +1,5 @@
 const { expect } = require('chai');
-const { constants, expectRevert } = require('@openzeppelin/test-helpers');
+const { constants } = require('@openzeppelin/test-helpers');
 const { ZERO_ADDRESS } = constants;
 
 const RECEIVER_MAGIC_VALUE = '0x150b7a02';
@@ -10,7 +10,7 @@ describe('ERC721A', function () {
   beforeEach(async function () {
     this.ERC721A = await ethers.getContractFactory('ERC721AMock');
     this.ERC721Receiver = await ethers.getContractFactory('ERC721ReceiverMock');
-    this.erc721a = await this.ERC721A.deploy("Azuki", "AZUKI", 5);
+    this.erc721a = await this.ERC721A.deploy('Azuki', 'AZUKI', 5);
     await this.erc721a.deployed();
   });
 
@@ -36,7 +36,7 @@ describe('ERC721A', function () {
     describe('exists', async function () {
       it('verifies valid tokens', async function () {
         for (let tokenId = 0; tokenId < 6; tokenId++) {
-          let exists = await this.erc721a.exists(tokenId);
+          const exists = await this.erc721a.exists(tokenId);
           expect(exists).to.be.true;
         }
       });
@@ -56,9 +56,9 @@ describe('ERC721A', function () {
       });
 
       it('throws an exception for the 0 address', async function () {
-        await expectRevert(
-          this.erc721a.balanceOf(ZERO_ADDRESS), 'ERC721A: balance query for the zero address',
-        );
+        await expect(
+          this.erc721a.balanceOf(ZERO_ADDRESS)
+        ).to.be.revertedWith('ERC721A: balance query for the zero address');
       });
     });
 
@@ -79,9 +79,7 @@ describe('ERC721A', function () {
       });
 
       it('reverts for an invalid token', async function () {
-        await expectRevert(
-          this.erc721a.ownerOf(10), 'ERC721A: owner query for nonexistent token',
-        );
+        await expect(this.erc721a.ownerOf(10)).to.be.revertedWith('ERC721A: owner query for nonexistent token');
       });
     });
 
@@ -96,38 +94,35 @@ describe('ERC721A', function () {
       });
 
       it('rejects an invalid token owner', async function () {
-        await expectRevert(
-          this.erc721a.connect(this.addr1).approve(this.addr2.address, tokenId2), 'ERC721A: approval to current owner'
-        );
+        await expect(
+          this.erc721a.connect(this.addr1).approve(this.addr2.address, tokenId2)
+        ).to.be.revertedWith('ERC721A: approval to current owner');
       });
 
       it('rejects an unapproved caller', async function () {
-        await expectRevert(
-          this.erc721a.approve(this.addr2.address, tokenId), 'ERC721A: approve caller is not owner nor approved for all'
-        );
+        await expect(
+          this.erc721a.approve(this.addr2.address, tokenId)
+        ).to.be.revertedWith('ERC721A: approve caller is not owner nor approved for all');
       });
 
       it('does not get approved for invalid tokens', async function () {
-        await expectRevert(
-          this.erc721a.getApproved(10), 'ERC721A: approved query for nonexistent token'
-        );
+        await expect(this.erc721a.getApproved(10)).to.be.revertedWith('ERC721A: approved query for nonexistent token');
       });
     });
 
     describe('setApprovalForAll', async function () {
       it('sets approval for all properly', async function () {
         const approvalTx = await this.erc721a.setApprovalForAll(this.addr1.address, true);
         await expect(approvalTx)
-          .to.emit(this.erc721a, "ApprovalForAll")
+          .to.emit(this.erc721a, 'ApprovalForAll')
           .withArgs(this.owner.address, this.addr1.address, true);
         expect(await this.erc721a.isApprovedForAll(this.owner.address, this.addr1.address)).to.be.true;
       });
 
       it('sets rejects approvals for non msg senders', async function () {
-        await expectRevert(
-          this.erc721a.connect(this.addr1).setApprovalForAll(this.addr1.address, true),
-          'ERC721A: approve to caller'
-        );
+        await expect(
+          this.erc721a.connect(this.addr1).setApprovalForAll(this.addr1.address, true)
+        ).to.be.revertedWith('ERC721A: approve to caller');
       });
     });
 
@@ -152,7 +147,7 @@ describe('ERC721A', function () {
 
         it('emits a Transfer event', async function () {
           await expect(this.transferTx)
-            .to.emit(this.erc721a, "Transfer")
+            .to.emit(this.erc721a, 'Transfer')
             .withArgs(from, to, tokenId);
         });
 
@@ -162,7 +157,7 @@ describe('ERC721A', function () {
 
         it('emits an Approval event', async function () {
           await expect(this.transferTx)
-            .to.emit(this.erc721a, "Approval")
+            .to.emit(this.erc721a, 'Approval')
             .withArgs(from, ZERO_ADDRESS, tokenId);
         });
 
@@ -180,30 +175,27 @@ describe('ERC721A', function () {
         const tokenId = 1;
 
         it('rejects unapproved transfer', async function () {
-          await expectRevert(
-            this.erc721a.connect(this.addr1)[transferFn](this.addr2.address, this.addr1.address, tokenId),
-            'ERC721A: transfer caller is not owner nor approved',
-          )
+          await expect(
+            this.erc721a.connect(this.addr1)[transferFn](this.addr2.address, this.addr1.address, tokenId)
+          ).to.be.revertedWith('ERC721A: transfer caller is not owner nor approved');
         });
 
         it('rejects transfer from incorrect owner', async function () {
           await this.erc721a.connect(this.addr2).setApprovalForAll(this.addr1.address, true);
-          await expectRevert(
-            this.erc721a.connect(this.addr1)[transferFn](this.addr3.address, this.addr1.address, tokenId),
-            'ERC721A: transfer from incorrect owner',
-          )
+          await expect(
+            this.erc721a.connect(this.addr1)[transferFn](this.addr3.address, this.addr1.address, tokenId)
+          ).to.be.revertedWith('ERC721A: transfer from incorrect owner');
         });
 
         it('rejects transfer to zero address', async function () {
           await this.erc721a.connect(this.addr2).setApprovalForAll(this.addr1.address, true);
-          await expectRevert(
-            this.erc721a.connect(this.addr1)[transferFn](this.addr2.address, ZERO_ADDRESS, tokenId),
-            'ERC721A: transfer to the zero address',
-          )
+          await expect(
+            this.erc721a.connect(this.addr1)[transferFn](this.addr2.address, ZERO_ADDRESS, tokenId)
+          ).to.be.revertedWith('ERC721A: transfer to the zero address');
         });
-      }
+      };
 
-      context("successful transfers", function () {
+      context('successful transfers', function () {
         describe('transferFrom', function () {
           testSuccessfulTransfer('transferFrom');
         });
@@ -213,13 +205,13 @@ describe('ERC721A', function () {
 
           it('validates ERC721Received', async function () {
             await expect(this.transferTx)
-              .to.emit(this.receiver, "Received")
-              .withArgs(this.addr2.address, this.addr2.address, 1, "0x", GAS_MAGIC_VALUE);
+              .to.emit(this.receiver, 'Received')
+              .withArgs(this.addr2.address, this.addr2.address, 1, '0x', GAS_MAGIC_VALUE);
           });
         });
       });
 
-      context("unsuccessful transfers", function () {
+      context('unsuccessful transfers', function () {
         describe('transferFrom', function () {
           testUnsuccessfulTransfer('transferFrom');
         });
@@ -240,42 +232,42 @@ describe('ERC721A', function () {
       this.receiver = await this.ERC721Receiver.deploy(RECEIVER_MAGIC_VALUE);
     });
 
-    describe("safeMint", function () {
+    describe('safeMint', function () {
       it('successfully mints a single token', async function () {
         const mintTx = await this.erc721a['safeMint(address,uint256)'](this.receiver.address, 1);
         await expect(mintTx)
-          .to.emit(this.erc721a, "Transfer")
+          .to.emit(this.erc721a, 'Transfer')
           .withArgs(ZERO_ADDRESS, this.receiver.address, 0);
         await expect(mintTx)
-          .to.emit(this.receiver, "Received")
-          .withArgs(this.owner.address, ZERO_ADDRESS, 0, "0x", GAS_MAGIC_VALUE);
+          .to.emit(this.receiver, 'Received')
+          .withArgs(this.owner.address, ZERO_ADDRESS, 0, '0x', GAS_MAGIC_VALUE);
         expect(await this.erc721a.ownerOf(0)).to.equal(this.receiver.address);
       });
 
       it('successfully mints multiple tokens', async function () {
         const mintTx = await this.erc721a['safeMint(address,uint256)'](this.receiver.address, 5);
         for (let tokenId = 0; tokenId < 5; tokenId++) {
           await expect(mintTx)
-            .to.emit(this.erc721a, "Transfer")
+            .to.emit(this.erc721a, 'Transfer')
             .withArgs(ZERO_ADDRESS, this.receiver.address, tokenId);
           await expect(mintTx)
-            .to.emit(this.receiver, "Received")
-            .withArgs(this.owner.address, ZERO_ADDRESS, 0, "0x", GAS_MAGIC_VALUE);
+            .to.emit(this.receiver, 'Received')
+            .withArgs(this.owner.address, ZERO_ADDRESS, 0, '0x', GAS_MAGIC_VALUE);
           expect(await this.erc721a.ownerOf(tokenId)).to.equal(this.receiver.address);
         }
       });
 
       it('rejects mints to the zero address', async function () {
-        await expectRevert(
-          this.erc721a['safeMint(address,uint256)'](ZERO_ADDRESS, 1), 'ERC721A: mint to the zero address'
-        );
+        await expect(
+          this.erc721a['safeMint(address,uint256)'](ZERO_ADDRESS, 1)
+        ).to.be.revertedWith('ERC721A: mint to the zero address');
       });
 
       it('rejects quantity > maxBatchSize', async function () {
-        await expectRevert(
-          this.erc721a['safeMint(address,uint256)'](this.receiver.address, 6), 'ERC721A: quantity to mint too high'
-        );
+        await expect(
+          this.erc721a['safeMint(address,uint256)'](this.receiver.address, 6)
+        ).to.be.revertedWith('ERC721A: quantity to mint too high');
       });
     });
   });
-});
+});