Lesson 14: Unit-testing 'emit Minted()' not working, also txReceipt-issue

[ManuWeb3]

Hi all,

2 questions:

1). I'm trying to Unit test the Minted event in BasicNft.sol under "Testing MintNft()" the way we did event testing in ``Raffle.sol``` but it's not getting through.

Seems I'm missing something that may have been in place while testing events in Raffle.sol but not able to spot it here, tried many tweaks, however Testing constructor works fine.

BasicNft.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.7;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract BasicNft is ERC721 {

    event Minted(address indexed owner, uint256 indexed tokenId);

    uint256 private s_tokenCounter;

   string public constant TOKEN_URI = "ipfs://bafybeig37ioir76s7mg5oobetncojcm3c3hxasyd4rvid4jqhy4gkaheg4/?filename=0-PUG.json";

    constructor () ERC721 ("Doggie", "DOG") {
        s_tokenCounter = 0;                             
    }

    function mintNft() public {       
        _safeMint(msg.sender, s_tokenCounter);          
        emit Minted(msg.sender, s_tokenCounter);
        s_tokenCounter++;
        //  return s_tokenCounter;                      //  not serving any purpose, can be removed
    }

    function tokenURI(uint256 tokenId) public view override returns (string memory) {        
        return TOKEN_URI;        
    }

    function getTokenCounter() public view returns(uint256) {
        return s_tokenCounter;        
    }
}

====================

BasicNft-test.js

const { assert, expect } = require("chai")
const { deployments, getNamedAccounts, ethers, network } = require("hardhat")
const { developmentChains, networkConfig } = require("../../helper-hardhat-config")

!developmentChains.includes(network.name) ? describe.skip : describe("BasicNft Unit Tests", function () {
    let basicNft, deployer, tokenCounter                           
    beforeEach(async function () {
        console.log("BasicNft.sol deploying...")
        deployer = (await getNamedAccounts()).deployer
        await deployments.fixture(["all"])

        basicNft = await ethers.getContract("BasicNft", deployer)
        console.log("BasicNft.sol deployed!!")
    })

    describe("Testing Constructor", function () {
        
        it ("Should assign correct values to 'Name', 'Symbol', and 'TokenId'", async function () {
           
            const name = await basicNft.name()
            const symbol = await basicNft.symbol()
            tokenCounter = await basicNft.getTokenCounter()

            assert.equal(name, "Doggie")
            assert.equal(symbol, "DOG")
            assert.equal(tokenCounter.toString(), "0")
        })
    })

    describe("Testing MintNft()", function() {
       
            it("Should emit Minted event", async function() {
            
            tokenCounter = await basicNft.getTokenCounter()
            console.log(`Deployer: ${deployer}`)
            console.log(`Token Counter: ${tokenCounter}`)
            await expect(await basicNft.mintNft().to.emit(basicNft, "Minted").withArgs(deployer, tokenCounter))
        })

            it("Updated 2 mappings: _balances[] and _owners[] & incremented tokenCounter", async function() {
           
            tokenCounter = await basicNft.getTokenCounter()
            const txResponse = await basicNft.mintNft()                 
            const txReceipt = await txResponse.wait(1)
            console.log(`Transaction Receipt: ${txReceipt}`)

            const tokenBalance = await basicNft.balanceOf(deployer)     
            const tokenOwner = await basicNft.ownerOf(tokenCounter)     
            //  checking 2 private mappings
            assert.equal(tokenBalance.toString(), "1")
            assert.equal(tokenOwner.toString(), deployer)  
            //  checking whether tokenCounter incremented by 1
            tokenCounter = await basicNft.getTokenCounter()
            assert.equal(tokenCounter.toString(), "1")

            })    
      })
})

It is outputting the correct values of deployer and the s_tokenCounter, still expect fails.

Not sure what is undefined here:

============================

2). I'm also trying to print Transaction Receipt at console.log(`Transaction Receipt: ${txReceipt}`) in second it("Updated 2 mappings: _balances[] and _owners[] & incremented tokenCounter", async function() { but it's returning an unresolved Promise kind of output when, I believe, it is resolved by then.

P.S: I know we do not need to perform second it test as it's well tested already but just trying to get better at writing tests:

Not sure the issue here either:

[adityabhattad2021]

This line

await expect(await basicNft.mintNft().to.emit(basicNft, "Minted").withArgs(deployer, tokenCounter))

should be

await expect(await basicNft.mintNft().to.emit("Minted").withArgs(deployer, tokenCounter))

[ManuWeb3]

Thanks @adityabhattad2021 for checking this out.

I believe emit(basicNft, "Minted") is also correct as I also checked the way we unit tested events in Raffle.sol and also the syntax on official page of Chai Matchers

However, I still tried it with emit("Minted") and it failed with the same error as earlier.

I wrote all the latest details in my reply to @abossofmyself below.

It's something that's not getting read and test is failing.

Too weird!!

[RoboCrypter]

@ManuWeb3 : There are couple of things I wanna correct :

1. In your mintNft function in your BasicNft contract, You were updating the token counter after minting the NFT, which is incorrect.
   Always update your token counter before minting the NFT is the best practice and preferable way, and also will not create any problems for you later on!

   It should be like this :

    function mintNft() public {
        s_tokenCounter++;
        _safeMint(msg.sender, s_tokenCounter);
        emit Minted(msg.sender, s_tokenCounter);
        //  return s_tokenCounter;                      //  not serving any purpose, can be removed
    }

And, yes return s_tokenCounter; is not needed.

2. In your basicNft.test.js : Testing your mintNft You were doing this,

• await expect(await basicNft.mintNft().to.emit(basicNft, "Minted").withArgs(deployer, tokenCounter))

• which should be :

  await expect(basicNft.mintNft()).to.emit(basicNft, "Minted").withArgs(deployer, tokenCounter + 1)

  Because when you were emiting an event you were not updating the token counter accordingly, because when you mint an NFT, the token counter will increase by 1 so, you will have to tell that in your expect statement for it to be true and pass the test.

  And In await expect(), you don't need to do await again inside the statement, because it is already doing it.

3. And also in your it statement Updated 2 mappings: _balances[] and _owners[] & incremented tokenCounter You were doing this,

            tokenCounter = await basicNft.getTokenCounter()
            const txResponse = await basicNft.mintNft()   

• which should be :

            const txResponse = await basicNft.mintNft()
            tokenCounter = await basicNft.getTokenCounter()

Because you should always check the token counter after minting an NFT for it to update, because you were checking deployer
token Balance
and it will not update to 1 , because you were checking it before minting an NFT, so it will still be 0 .

4. And in that same it statement you don't need to check your token counter down here :

   // checking whether tokenCounter incremented by 1
tokenCounter = await basicNft.getTokenCounter() --> This line is not required because in my above point it is already been updated!
   assert.equal(tokenCounter.toString(), "1")

Your updated above it statement will look like this :

  it("Updated 2 mappings: _balances[] and _owners[] & incremented tokenCounter", async function() {
             
              const txResponse = await basicNft.mintNft()
              tokenCounter = await basicNft.getTokenCounter()                 
              const txReceipt = await txResponse.wait(1)
              console.log(`Transaction Receipt: ${txReceipt}`)
  
              const tokenBalance = await basicNft.balanceOf(deployer)     
              const tokenOwner = await basicNft.ownerOf(tokenCounter)     
              //  checking 2 private mappings
              assert.equal(tokenBalance.toString(), "1")
              assert.equal(tokenOwner.toString(), deployer)  
              //  checking whether tokenCounter incremented by 1
              assert.equal(tokenCounter.toString(), "1")
  
              }) 

And Your Promise is resolved, It is just not being console.logged properly :

Change your console.log() line from this : Transaction Receipt: ${txReceipt}

To : Transaction Receipt: ${JSON.stringify(txReceipt)}

[ManuWeb3]

Oh my goodness!!
It worked, passed.

While re-writing it, I saw that I misplaced the closing bracket of expect.

Should have been:
await expect(basicNft.mintNft()).to.emit(basicNft, "Minted").withArgs(deployer, tokenCounter+1)

Is that what you also spotted ?
Or something else ?

[RoboCrypter]

@ManuWeb3 : Yes Exactly! Thats why I said, because I knew you will correct it by yourself.

In my above reply see, I did corrected that mistake but you did not copy paste it So yeah no problem!

Kindly mark the answer as answered! ThankYou

Have a good one!

[ManuWeb3]

Wow!!
You won't believe how much time got spent (if not wasted) on this petty miss that I did.

I had been checking every detail of the syntax and logic except just the brackets.

But, yes, thanks to you, had you not asked me to re-write, god knows, when I'd spot it :)

[ManuWeb3]

@abossofmyself , just last quick question:

Why is it a good practice to increment the tokenCounter before _safeMint() is called inside mintNft() ?
Like , what kind of issue can it cause in Production if it gets incremented after _safeMint() returns ?

Is it that assigning a 0 tokenId to any user does not make practical sense ?

I don't remember whether Patrick explained this in the course and I missed it.

[RoboCrypter]

@ManuWeb3 : Don't worry Patrick will explain this when he will be doing "Random IPFS Nft" or maybe in "Dynamic Svg Nft" contract, in the course.

He will say to you that you should always update token counter before _safeMint().

And secondly, We already initialized token counter in our constructor to 0 so, when the first user mints Nft,
He will have a token Id of 1 .