Lesson 9: Error: Timeout of 200000ms exceeded. For async tests...

[Tosinkoa]

I am getting this error whenever I run my test. This happens for the big it test with the name "picks a winner, resets, and sends money" @PatrickAlphaC wrote for Raffle.sol.

Here is the error:
Error: Timeout of 200000ms exceeded. For async tests and hooks, ensure "done()" is called; if returning a Promise, ensure it resolves. (C:\Users\NEW\Desktop\Blockchain-dev-practice\smart-contract-lottery\raffle-smart-contract\test\unit\Raffle.test.js)

I tried increasing the time to 4mins, it still doesn't work. I also added a compiler of version 0.8.15 in my hardhat.config.js, it didn't stop the error. I also copied Patrick test, but the error still persist.

Here is the code snippet for the area.

it("picks a winner, resets, and sends money", async () => {
            const additionalEntrances = 3
            const startingIndex = 2
            const accounts = await ethers.getSigners()
            for (let i = startingIndex; i < startingIndex + additionalEntrances; i++) {
                raffle = raffle.connect(accounts[i])
                await raffle.enterRaffle({ value: raffleEntranceFee })
            }
            const startingTimeStamp = await raffle.getLatestTimeStamp()
            await new Promise(async (resolve, reject) => {
                raffle.once("WinnerPicked", async () => {
                    console.log("WinnerPicked event fired!")
                    try {
                        const recentWinner = await raffle.getRecentWinner()
                        const raffleState = await raffle.getRaffleState()
                        const winnerBalance = await accounts[2].getBalance()
                        const endingTimeStamp = await raffle.getLatestTimeStamp()
                        await expect(raffle.getPlayer(0)).to.be.reverted
                        assert.equal(recentWinner.toString(), accounts[2].address)
                        assert.equal(raffleState, 0)
                        assert.equal(
                            winnerBalance.toString(),
                            startingBalance
                                .add(
                                    raffleEntranceFee
                                        .mul(additionalEntrances)
                                        .add(raffleEntranceFee)
                                )
                                .toString()
                        )
                        assert(endingTimeStamp > startingTimeStamp)
                        resolve()
                    } catch (e) {
                        reject(e)
                    }
                })

                const tx = await raffle.performUpkeep("0x")
                const txReceipt = await tx.wait(1)
                const startingBalance = await accounts[2].getBalance()
                await vrfCoordinatorV2Mock.fulfillRandomWords(
                    txReceipt.events[1].args.requestId,
                    raffle.address
                )
            })
        })

[MuhammadLuqman-99]

park i have the same problem to

[Tosinkoa]

Pls can you help us look into this, it's an uncommon issue that no one seems to find an answer to. @PatrickAlphaC

[ZahraaHawie]

I got the same problem too!

[Tosinkoa]

I was able to solve the unit test timeout error by rewriting the code. But I'm facing the error in my staging test

[popelev]

Hello. Should this test works in hardhat network? or in real testnet only?

[PatrickAlphaC]

This is due to chainlink vrf or keepers code not formatted correctly.

Can you follow the troubleshooting here: https://github.com/smartcontractkit/full-blockchain-solidity-course-js/blob/main/chronological-updates.md#keepers-not-kicking-off-troubleshooting

[Tosinkoa]

Thank you so much for your help. Your answer solve my problem

[ZahraaHawie]

@Tosinkoa Hello, Please can I know which part did you fix in your code?

[popelev]

@PatrickAlphaC Hello. Sorry for disturbing. Should this test work in local hardhat network? i have same issue

After troubleshooting:

1. subscriptionId = 1 when look in debug

const txResponse = await vrgCoordinatorV2Mock.createSubscription()
const txReceipt = await txResponse.wait()
subscriptionId = txReceipt.events[0].args.subId

2. LINK does not needed for Mock in hardhat network?

3-4. If i do this:

const tx1 = await raffleDeployer.callStatic.checkUpkeep([])
const tx2 = await raffle.performUpkeep("0x")
const tx3 = await raffleDeployer.callStatic.checkUpkeep([])

i recieve this:
tx1. unkeepNeeded = true
tx3. unkeepNeeded = false
tx2:

What do you think the problem might be? thank you in advance

[ZahraaHawie]

Anyone know why I'm getting this error when running: yarn hardhat test

Here is my code:

Raffle.staging.test.js

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

//If we are on a development chain network like Rinkeby.. procceed if not skip
developmentChains.includes(network.name)
    ? describe.skip
    : describe("Raffle Unit Tests", function () {
          let raffle, raffleEntranceFee, deployer; //no need for mocks we are on actual test net

          beforeEach(async function () {
              deployer = (await getNamedAccounts()).deployer;
              raffle = await ethers.getContract("Raffle", deployer);
              raffleEntranceFee = await raffle.getEntranceFee();
          });

          describe("fulfillRandomWords", function () {
              it("works with live Chainlink Keepers and Chainlink VRF, we get a random winner", async function () {
                  // enter the raffle
                  console.log("Setting up test...");
                  const startingTimeStamp = await raffle.getLastTimeStamp();
                  const accounts = await ethers.getSigners();

                  console.log("Setting up Listener...");
                  await new Promise(async (resolve, reject) => {
                      // setup listener before we enter the raffle
                      // Just in case the blockchain moves REALLY fast
                      raffle.once("WinnerPicked", async () => {
                          console.log("WinnerPicked event fired!");
                          try {
                              // add our asserts here
                              const recentWinner = await raffle.getRecentWinner();
                              const raffleState = await raffle.getRaffleState();
                              const winnerEndingBalance = await accounts[0].getBalance();
                              const endingTimeStamp = await raffle.getLastTimeStamp();

                              await expect(raffle.getPlayer(0)).to.be.reverted;
                              assert.equal(recentWinner.toString(), accounts[0].address);
                              assert.equal(raffleState, 0);
                              assert.equal(
                                  winnerEndingBalance.toString(),
                                  winnerStartingBalance.add(raffleEntranceFee).toString()
                              );
                              assert(endingTimeStamp > startingTimeStamp);
                              resolve();
                          } catch (error) {
                              console.log(error);
                              reject(e);
                          }
                      });
                      // Then entering the raffle
                      console.log("Entering Raffle...");
                      const tx = await raffle.enterRaffle({ value: raffleEntranceFee });
                      const txReceipt = await tx.wait(1);
                      console.log("Ok, time to wait...");
                      const winnerStartingBalance = await accounts[0].getBalance();

                      // and this code WONT complete until our listener has finished listening!
                  });
              });
          });
      });

Raffle.test.js

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

!developmentChains.includes(network.name)
    ? describe.skip
    : describe("Raffle Unit Tests", function () {
          let raffle, raffleContract, vrfCoordinatorV2Mock, raffleEntranceFee, interval, player; // , deployer

          beforeEach(async () => {
              accounts = await ethers.getSigners(); // could also do with getNamedAccounts
              //   deployer = accounts[0]
              player = accounts[1];
              await deployments.fixture(["mocks", "raffle"]);
              vrfCoordinatorV2Mock = await ethers.getContract("VRFCoordinatorV2Mock");
              raffleContract = await ethers.getContract("Raffle");
              raffle = raffleContract.connect(player);
              raffleEntranceFee = await raffle.getEntranceFee();
              interval = await raffle.getInterval();
          });
          describe("constructor", function () {
              it("intitiallizes the raffle correctly", async () => {
                  // Ideally, we'd separate these out so that only 1 assert per "it" block
                  // And ideally, we'd make this check everything
                  const raffleState = (await raffle.getRaffleState()).toString();
                  assert.equal(raffleState, "0"); //0 is open , 1 CALCULATING
                  assert.equal(
                      interval.toString(),
                      networkConfig[network.config.chainId]["keepersUpdateInterval"]
                  );
                  //we can write more tests for the rest in the constructor
              });
          });
          describe("enterRaffle", function () {
              it("reverts when you don't pay enough", async () => {
                  await expect(raffle.enterRaffle()).to.be.revertedWith(
                      "Raffle__NotEnoughETHEntered"
                  );
              });
              it("records player when they enter", async () => {
                  await raffle.enterRaffle({ value: raffleEntranceFee });
                  const contractPlayer = await raffle.getPlayer(0);
                  assert.equal(player.address, contractPlayer);
              });
              it("emits event on enter", async () => {
                  await expect(raffle.enterRaffle({ value: raffleEntranceFee })).to.emit(
                      raffle,
                      "RaffleEnter"
                  );
              });
              it("doesn't allow entrance when raffle is calculating", async () => {
                  await raffle.enterRaffle({ value: raffleEntranceFee });
                  //to not wait until interval period pass..
                  await network.provider.send("evm_increaseTime", [interval.toNumber() + 1]);
                  await network.provider.request({ method: "evm_mine", params: [] });
                  // we pretend to be a keeper for a second
                  await raffle.performUpkeep([]);
                  await expect(raffle.enterRaffle({ value: raffleEntranceFee })).to.be.revertedWith(
                      "Raffle__RaffleNotOpen"
                  );
              });
              describe("checkUpkeep", function () {
                  it("returns false if people haven't sent any ETH", async () => {
                      await network.provider.send("evm_increaseTime", [interval.toNumber() + 1]);
                      await network.provider.request({ method: "evm_mine", params: [] });
                      const { upkeepNeeded } = await raffle.callStatic.checkUpkeep("0x");
                      assert(!upkeepNeeded);
                  });
                  it("returns false if raffle isn't open", async () => {
                      await raffle.enterRaffle({ value: raffleEntranceFee });
                      await network.provider.send("evm_increaseTime", [interval.toNumber() + 1]);
                      await network.provider.request({ method: "evm_mine", params: [] });
                      await raffle.performUpkeep([]);
                      const raffleState = await raffle.getRaffleState();
                      const { upkeepNeeded } = await raffle.callStatic.checkUpkeep("0x");
                      assert.equal(raffleState.toString() == "1", upkeepNeeded == false);
                  });
                  it("returns false if enough time hasn't passed", async () => {
                      await raffle.enterRaffle({ value: raffleEntranceFee });
                      await network.provider.send("evm_increaseTime", [interval.toNumber() - 1]);
                      await network.provider.request({ method: "evm_mine", params: [] });
                      const { upkeepNeeded } = await raffle.callStatic.checkUpkeep("0x");
                      assert(!upkeepNeeded);
                  });
                  it("returns true if enough time has passed, has players, eth, and is open", async () => {
                      await raffle.enterRaffle({ value: raffleEntranceFee });
                      await network.provider.send("evm_increaseTime", [interval.toNumber() + 1]);
                      await network.provider.request({ method: "evm_mine", params: [] });
                      const { upkeepNeeded } = await raffle.callStatic.checkUpkeep("0x");
                      assert(upkeepNeeded);
                  });
              });
              describe("performUpkeep", function () {
                  it("can only run if checkupkeep is true", async () => {
                      await raffle.enterRaffle({ value: raffleEntranceFee });
                      await network.provider.send("evm_increaseTime", [interval.toNumber() + 1]);
                      await network.provider.request({ method: "evm_mine", params: [] });
                      const tx = await raffle.performUpkeep("0x");
                      assert(tx);
                  });
                  it("reverts if checkup is false", async () => {
                      await expect(raffle.performUpkeep("0x")).to.be.revertedWith(
                          "Raffle__UpkeepNotNeeded"
                      );
                  });
                  it("updates the raffle state and emits a requestId", async () => {
                      // Too many asserts in this test!
                      await raffle.enterRaffle({ value: raffleEntranceFee });
                      await network.provider.send("evm_increaseTime", [interval.toNumber() + 1]);
                      await network.provider.request({ method: "evm_mine", params: [] });
                      const txResponse = await raffle.performUpkeep("0x");
                      const txReceipt = await txResponse.wait(1);
                      const raffleState = await raffle.getRaffleState();
                      const requestId = txReceipt.events[1].args.requestId;
                      assert(requestId.toNumber() > 0);
                      assert(raffleState == 1);
                  });
              });
              describe("fulfillRandomWords", function () {
                  beforeEach(async () => {
                      await raffle.enterRaffle({ value: raffleEntranceFee });
                      await network.provider.send("evm_increaseTime", [interval.toNumber() + 1]);
                      await network.provider.request({ method: "evm_mine", params: [] });
                  });
                  it("can only be called after performupkeep", async () => {
                      await expect(
                          vrfCoordinatorV2Mock.fulfillRandomWords(0, raffle.address)
                      ).to.be.revertedWith("nonexistent request");
                      await expect(
                          vrfCoordinatorV2Mock.fulfillRandomWords(1, raffle.address)
                      ).to.be.revertedWith("nonexistent request");
                  });
                  // This is for testing fullfillment function
                  it("picks a winner, resets, and sends money", async () => {
                      const additionalEntrances = 3;
                      const startingIndex = 1; //since deployer is 0
                      for (let i = startingIndex; i < startingIndex + additionalEntrances; i++) {
                          raffle = raffleContract.connect(accounts[i]);
                          await raffle.enterRaffle({ value: raffleEntranceFee });
                      }
                      const startingTimeStamp = await raffle.getLastTimeStamp();

                      // performUpKeep (mock being chainlink keepers)
                      //kick off fulfillRandomWords (mock being chainlink VRF)

                      await new Promise(async (resolve, reject) => {
                          raffle.once("WinnerPicked", async () => {
                              console.log("WinnerPicked event fired!");
                              // assert throws an error if it fails, so we need to wrap
                              // it in a try/catch so that the promise returns event
                              // if it fails.
                              try {
                                  // Now lets get the ending values...
                                  const recentWinner = await raffle.getRecentWinner();
                                  const raffleState = await raffle.getRaffleState();
                                  const winnerBalance = await accounts[2].getBalance();
                                  const endingTimeStamp = await raffle.getLastTimeStamp();
                                  await expect(raffle.getPlayer(0)).to.be.reverted;
                                  assert.equal(recentWinner.toString(), accounts[2].address);
                                  assert.equal(raffleState, 0);
                                  assert.equal(
                                      winnerBalance.toString(),
                                      startingBalance
                                          .add(
                                              raffleEntranceFee
                                                  .mul(additionalEntrances)
                                                  .add(raffleEntranceFee)
                                          )
                                          .toString()
                                  );
                                  assert(endingTimeStamp > startingTimeStamp);
                                  resolve();
                              } catch (e) {
                                  reject(e);
                              }
                          });
                          //setting up the listener
                          // below, we will fire the event, and the listener will pick it up, and resolve
                          const tx = await raffle.performUpkeep("0x");
                          const txReceipt = await tx.wait(1);
                          const startingBalance = await accounts[2].getBalance();
                          await vrfCoordinatorV2Mock.fulfillRandomWords(
                              txReceipt.events[1].args.requestId,
                              raffle.address
                          );
                      });
                  });
              });
          });
      });

helper.config.js :

const { ethers } = require("hardhat");

const networkConfig = {
    default: {
        name: "hardhat",
        keepersUpdateInterval: "30",
    },
    31337: {
        //no vrfCoordinatorV2 because we gonna deploy it as mocks
        name: "localhost",
        //doesn't care about gasLane
        gasLane: "0xd89b2bf150e3b9e13446986e571fb9cab24b13cea0a43ea20a6049a85cc807cc", // 30 gwei
        keepersUpdateInterval: "30",
        raffleEntranceFee: "100000000", // 0.1 ETH
        callbackGasLimit: "500000", // 500,000 gas
    },
    4: {
        name: "rinkeby",
        subscriptionId: "7515",

        gasLane: "0xd89b2bf150e3b9e13446986e571fb9cab24b13cea0a43ea20a6049a85cc807cc", // 30 gwei
        keepersUpdateInterval: "30",
        raffleEntranceFee: "100000000000000000", // 0.1 ETH
        callbackGasLimit: "500000", // 500,000 gas
        vrfCoordinatorV2: "0x6168499c0cFfCaCD319c818142124B7A15E857ab",
    },
    1: {
        name: "mainnet",
        keepersUpdateInterval: "30",
    },
};

const developmentChains = ["hardhat", "localhost"];
const VERIFICATION_BLOCK_CONFIRMATIONS = 6;
const frontEndContractsFile =
    "../nextjs-smartcontract-lottery-fcc/constants/contractAddresses.json";
const frontEndAbiFile = "../nextjs-smartcontract-lottery-fcc/constants/abi.json";

module.exports = {
    networkConfig,
    developmentChains,
    VERIFICATION_BLOCK_CONFIRMATIONS,
    frontEndContractsFile,
    frontEndAbiFile,
};

Anyone could help? Thanks

[blockchainbull]

your unit test is not running and you're posting staging test file
can you please elaborate your concern?

[ZahraaHawie]

Yes I forget to add the unit test code. Updated above.

[blockchainbull]

I faced a similar problem and what I concluded is that the player connect is not working properly so I had to clone the repo from gitHub and it worked. IDK what's wrong because I also tried doing a lot of stuff to help me fix the problem but I couldn't solve the issue.

player = accounts[1];
raffle = raffleContract.connect(player);

I'm really not sure if these lines are the reason behind the error. so I'm sorry if I cannot fully resolve your issue.

[sanjayojha]

Facing the same problem.
@PatrickAlphaC told to do following

-Double check the subscription ID in your contract
-Double check the subscription is funded with enough LINK
-Is checkUpkeep returning true?
-Can you call performUpkeep yourself? (If you can't the keeper can't!)

Not sure, how to checkUpkeep returning true? Should we write test in staging for it?

[sanjayojha]

#729
Just created another post with more details for the same issue.