Lesson 9 <==> Error: Timeout of 40000ms exceeded. For async tests and hooks, ensure "done()" is called; if returning a Promise, ensure it resolves

[Ebenezary]

I give getting timeout error each time I run the unit test for the lottery smart contract

Below is the raffle.test.js :

const { deployments, ethers, getNamedAccounts, network } = require("hardhat")
const { developmentChains, networkConfig } = require("../../helper-hardhat-config")
const { assert, expect } = require("chai")
const BigNumber = require("bignumber.js")
const { time, helpers } = require("@nomicfoundation/hardhat-network-helpers")

!developmentChains.includes(network.name)
    ? describe.skip
    : describe("Raffle Unit Tests", function () {
          let raffle,
              vrfCoordinatorV2Mock,
              vrfCoordinatorV2MockContractAddress,
              raffleContractAddress,
              chainId,
              raffleEntranceFee,
              deployer,
              interval
          beforeEach(async function () {
              deployer = (await getNamedAccounts()).deployer
              await deployments.fixture(["all"])
              raffleContractAddress = (await deployments.get("Raffle")).address
              vrfCoordinatorV2MockContractAddress = (await deployments.get("VRFCoordinatorV2Mock"))
                  .address
              raffle = await ethers.getContractAt("Raffle", raffleContractAddress)
              vrfCoordinatorV2Mock = await ethers.getContractAt(
                  "VRFCoordinatorV2Mock",
                  raffleContractAddress,
              )
              raffleEntranceFee = await raffle.getEntranceFee()
              interval = await raffle.getInterval()
          })
          describe("constructor", function () {
              it("It initializes the raffle correctly", async function () {
                  //Ideally we make our test have just 1 assert per it
                  const raffleState = await raffle.getRaffleState()
                  chainId = network.config.chainId
                  assert.equal(raffleState, 0)
                  assert.equal(interval, networkConfig[chainId]["interval"])
              })
          })
          describe("Enter Raffle", function () {
              it("reverts raffle when you do not pay enough", async function () {
                  await expect(raffle.enterRaffle()).to.be.revertedWithCustomError(
                      raffle,
                      "Raffle__NotEnoughETHEntered",
                  )
              })
              it("records player when they enter", async function () {
                  await raffle.enterRaffle({ value: raffleEntranceFee })
                  const playerFromContract = await raffle.getPlayer(0)
                  assert.equal(playerFromContract, deployer)
              })
              it("emit event on enter", async function () {
                  await expect(raffle.enterRaffle({ value: raffleEntranceFee })).to.emit(
                      raffle,
                      "RaffleEnter",
                  )
              })
              it("doesnt allow entrance when raffle is calculating", async function () {
                  //   let intervalString = interval.toString()
                  //   let intervalBigNumber = new BigNumber(intervalString)
                  //   console.log(typeof intervalBigNumber.toNumber())
                  //   console.log(typeof 1)
                  //   console.log(intervalBigNumber.toNumber() + 1)
                  //   console.log(typeof intervalBigNumber.toNumber())
                  //   const sevenDays = 7 * 24 * 60 * 60
                  await raffle.enterRaffle({ value: raffleEntranceFee })
                  await network.provider.send("evm_increaseTime", [Number(interval) + 1])
                  await network.provider.send("evm_mine", [])
                  console.log(typeof Number(interval))
                  //we pretend to be a chainlink keeper
                  await raffle.performUpkeep("0x")
                  console.log("I see you")
                  await expect(
                      raffle.enterRaffle({ value: raffleEntranceFee }),
                  ).to.be.revertedWithCustomError(raffle, "RaffleState__NotOpen")
              })
          })
          describe("checkupkeep", function () {
              it("returns false if people have not sent any ETH", async function () {
                  await network.provider.send("evm_increaseTime", [Number(interval) + 1])
                  await network.provider.send("evm_mine", [])
                  const { upkeepNeeded } = await raffle.checkUpkeep.staticCall("0x")
                  console.log(upkeepNeeded)
                  assert(!upkeepNeeded)
              })
              it("returns false if raffle isn't open", async function () {
                  await raffle.enterRaffle({ value: raffleEntranceFee })
                  await network.provider.send("evm_increaseTime", [Number(interval) + 1])
                  await network.provider.send("evm_mine", [])
                  await raffle.performUpkeep("0x")
                  const raffleState = await raffle.getRaffleState()
                  const { upkeepNeeded } = await raffle.checkUpkeep.staticCall("0x")
                  console.log(raffleState)
                  assert.equal(raffleState, 1)
                  assert.equal(upkeepNeeded, false)
              })
              it("returns false if enough time has not been passed", async function () {
                  await raffle.enterRaffle({ value: raffleEntranceFee })
                  await network.provider.send("evm_increaseTime", [Number(interval) - 2])
                  await network.provider.request({ method: "evm_mine", params: [] })
                  const { upkeepNeeded } = await raffle.checkUpkeep.staticCall("0x")
                  console.log(upkeepNeeded)
                  assert(!upkeepNeeded)
              })
              it("returns true if enough time has been passed, has players, ETH, and it is Open", async function () {
                  await raffle.enterRaffle({ value: raffleEntranceFee })
                  await network.provider.send("evm_increaseTime", [Number(interval) + 1])
                  await network.provider.request({ method: "evm_mine", params: [] })
                  const { upkeepNeeded } = await raffle.checkUpkeep.staticCall("0x")
                  assert(upkeepNeeded)
              })
          })
          describe("performUpkeep", function () {
              it("it can only run if checkUpkeep is true", async function () {
                  await raffle.enterRaffle({ value: raffleEntranceFee })
                  await network.provider.send("evm_increaseTime", [Number(interval) + 1])
                  await network.provider.send("evm_mine", [])
                  const tx = await raffle.performUpkeep("0x")
                  //   console.log(tx)
                  assert(tx)
              })
              it("reverts when checkupkeep is false", async function () {
                  await expect(raffle.performUpkeep("0x")).to.be.revertedWithCustomError(
                      raffle,
                      "Raffle_UpKeepNotNeeded",
                  )
              })
              it("updates the raffle state, emits and event, and calls the vrf coordinator", async function () {
                  await raffle.enterRaffle({ value: raffleEntranceFee })
                  await network.provider.send("evm_increaseTime", [Number(interval) + 1])
                  await network.provider.send("evm_mine", [])
                  const txRes = await raffle.performUpkeep("0x")
                  const txReceipt = await txRes.wait(1)
                  //   console.log(txReceipt)
                  const raffleState = await raffle.getRaffleState()
                  const requestId = await txReceipt.logs[1].args.requestId
                  assert(requestId > 0)
                  console.log(raffleState)
                  assert(raffleState == 1)
              })
          })
          describe("fulfillRandomwords", function () {
              beforeEach(async function () {
                  await raffle.enterRaffle({ value: raffleEntranceFee })
                  await network.provider.send("evm_increaseTime", [Number(interval) + 1])
                  await network.provider.send("evm_mine", [])
              })
              it("can only be called after performUpkeep", async function () {
                  console.log("Hello")
                  await expect(
                      vrfCoordinatorV2Mock.fulfillRandomWords(0, raffle.target),
                  ).to.be.revertedWithoutReason("nonexistent request")
                  console.log("Hi")
                  await expect(
                      vrfCoordinatorV2Mock.fulfillRandomWords(1, raffle.target),
                  ).to.be.revertedWithoutReason("nonexistent request")
              })
              it("picks a winner, reset the lottery, and sends the money", async function () {
                  const additionalEntrants = 3
                  const startingAccountIndex = 2
                  const accounts = await ethers.getSigners()
                  for (
                      let i = startingAccountIndex;
                      i < additionalEntrants + startingAccountIndex;
                      i++
                  ) {
                      const accountConnectedRaffle = raffle.connect(accounts[i])
                      await accountConnectedRaffle.enterRaffle({ value: raffleEntranceFee })
                  }
                  const startingTimeStamp = await raffle.getLatestTimeStamp()
                  //performUpkeep (mock being chainink keeper)
                  //fulfillRandomWords(mock being chainlink VRF)
                  //We will have to wait for the fulfillRandomwords to be called
                  console.log("starting")
                  await new Promise(async (resolve, reject) => {
                      console.log("I see you")
                      raffle.once("WinnerPicked", async () => {
                          console.log("Found the event")
                          try {
                              console.log(accounts[0])
                              console.log(accounts[1])
                              console.log(accounts[2])
                              console.log(accounts[3])
                              const recentWinner = await raffle.getRecentWinner()
                              console.log(recentWinner)
                              const raffleState = await raffle.getRaffleState()
                              const endingTimeStamp = await raffle.getLatestTimeStamp()
                              const numOfPlayers = await raffle.getNumOfPlayers()
                              assert.equal(numOfPlayers, 0)
                              assert.equal(raffleState, 0)
                              assert.equal(endingTimeStamp > startingTimeStamp)
                          } catch (e) {
                              reject(e)
                          }
                          resolve()
                      })
                      //setting up the listening
                      //below, we will fire up the event, and the listener will pick it up, and resolve
                      const tx = await raffle.performUpkeep("0x")
                      const txReceipt = await tx.wait(1)
                      await vrfCoordinatorV2Mock.fulfillRandomWords(
                          txReceipt.logs[1].args.requestId,
                          raffle.target,
                      )
                  })
              })
          })
      })

hardhat-config.js :

require("@nomicfoundation/hardhat-toolbox")
require("hardhat-gas-reporter")
require("dotenv").config()
require("solidity-coverage")
require("hardhat-deploy")
require("@nomicfoundation/hardhat-verify")
require("hardhat-contract-sizer")
require("@atixlabs/hardhat-time-n-mine")

const SEPOLIA_RPC_URL = process.env.SEPOLIA_RPC_URL || "https://eth-sepolia/example"
const PRIVATE_KEY = process.env.PRIVATE_KEY || "0xkey"
const ETHERSCAN_API_KEY = process.env.ETHERSCAN_API_KEY || "key"
const COINMARKETCAP_API_KEY = process.env.COINMARKETCAP_API_KEY || "key"

// /** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
    defaultNetwork: "hardhat",
    networks: {
        sepolia: {
            url: SEPOLIA_RPC_URL,
            accounts: [PRIVATE_KEY],
            chainId: 11155111,
            blockConfirmations: 6,
        },
        localhost: {
            url: "http://127.0.0.1:8545/",
            chainId: 31337,
        },
    },
    gasReporter: {
        enabled: true,
        outputFile: "gas-report.txt",
        noColors: true,
        currency: "USD",
        // coinmarketcap: COINMARKETCAP_API_KEY,
        token: "ETH",
    },
    solidity: "0.8.7",
    namedAccounts: {
        deployer: {
            default: 0, // here this will by default take the first account as deployer
            1: 0, // similarly on mainnet it will take the first account as deployer. Note though that depending on how hardhat network are configured, the account 0 on one network can be different than on another
        },
        player: {
            default: 1,
        },
    },
    mocha: {
        setTimeout: 500000, // 500 seconds max
    },
}

[Codensity30]

I also faced the same issue I think you haven't setTimeout for mocha earlier while testing in hardhat.config.js

 mocha: {
        setTimeout: 500000, // 500 seconds max
    }

Could you let me know now if you are seeing the same error? Cause for me it's resolved now, after setting this. But note - In Chainlink VRF send at least 5 Link cause 2 Link didn't work for me and the request for random words remained pending.

[Ebenezary]

Yes I am aware of that, it was a typo error. The main issue is yet to be solved.
Just in case you find a solution, kindly pass it here. Thank you.

[bobbywilliamajor]

Okay

[bobbywilliamajor]

The reason we were getting the 0x00000000000000 address for recent winner is because we didn't update our s_recentWinner state variable in our fulfillRandomWords function
'''
function fulfillRandomWords(
uint256 /requestId/,
uint256[] memory roundWords
) internal override {
uint256 indexOfWinner = roundWords[0] % s_players.length;
s_recentWinner = s_players[indexOfWinner]; // Add this line
address payable recenttWinner = s_players[indexOfWinner];
s_raffleState = RaffleState.OPEN;
s_players = new address payable;
s_lastTimestamp = block.timestamp;
(bool success, ) = recenttWinner.call{value: address(this).balance}("");
if (!success) {
revert Raffle_TransferFailed();
}
emit WinnerPicked(recenttWinner);
}

[Ebenezary]

function fulfillRandomWords(
uint256 /requestId/,
uint256[] memory roundWords
) internal override {
uint256 indexOfWinner = roundWords[0] % s_players.length;
s_recentWinner = s_players[indexOfWinner]; // Add this line
address payable recenttWinner = s_players[indexOfWinner];
s_raffleState = RaffleState.OPEN;
s_players = new address payable;
s_lastTimestamp = block.timestamp;
(bool success, ) = recenttWinner.call{value: address(this).balance}("");
if (!success) {
revert Raffle_TransferFailed();
}
emit WinnerPicked(recenttWinner);
}

[Ebenezary]

Actually I updated it on my code before deployment, check below you will find the lines from my raffle.sol code that shows the update :

address payable recentWinner = s_players[indexOfWinner];
        s_recentWinner = recentWinner;

[Ebenezary]

And this is still a unit test, not staging test.
The subscription ID was created within the deploy script, not through chainlink UI.

[Codensity30]

Okay, so this is a unit test, so subscriptionId is generated programmatically. Do one thing re-run the test and show what's is displayed on the console.

[Ebenezary]

Hello, I am currently on foundry, but soon I will switch to hardhat in order correct the errors.

[Gandouye]

Error: Timeout of 400000ms exceeded. For async tests and hooks, ensure "done()" is called; if returning a Promise, ensure it resolves.
It took me some time but I went step by step to fix it.
Finally, I saw it was an issue with the latest version of hardhat, ethers…
I am using the latest versions… "ethers": "^6.10.0», «hardhat": "^2.19.4", solidity ^0.8.19
The whole solution could be found at my repo: My Repo or directly at the raffle.staging.test.js @raffle.staging.test.js
Mainly changes in the latest versions… please note the main changes:

const raffleAddress = (await deployments.get("Raffle")).address
raffle = await ethers.getContractAt("Raffle", raffleAddress) //instead of getContract

setTimeout(resolve, 5000)                      
raffle.on("WinnerPicked", async () => { // instead of raffle.once

Hope this will help.

[Ebenezary]

Thank you, I will test this again.
Just I think I have used on instead of once as well, and I was still getting timeout error before switching to Foundry. But the timeout settings was on hardhat config on mocha sequentially set to 200,000 300,000 400,000 and 500,000, still I was getting timeout error

[Gandouye]

I also had it on Mocha config but... wasn't helping there...

…

On Sun, Jan 21, 2024 at 5:52 PM GEO ***@***.***> wrote: Thank you, I will test this again. Just I think I have used on instead of once as well, and I was still getting timeout error before switching to Foundry. But the timeout settings was on hardhat config on mocha sequentially set to 200,000 300,000 400,000 and 500,000, still I was getting timeout error — Reply to this email directly, view it on GitHub <#6393 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/A24LBGMKQWS4YWGEATVLCZTYPVIW7AVCNFSM6AAAAABBYDIBOGVHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4DEMBQGI3DS> . You are receiving this because you commented.Message ID: <smartcontractkit/full-blockchain-solidity-course-js/repo-discussions/6393/comments/8200269 @github.com>

[Ebenezary]

Alright, I'll try and it directly on my unit test. Thanks

[Ebenezary]

It works....Bravo
Thanks

[Ebenezary]

It resolved without checking the code inside the try function. I intentionally make the code to have an assert error, but it was instead passing the test.