Error: Timeout of 5000ms exceeded. For async tests and hooks, ensure "done()" is called; if returning a Promise, ensure it resolves

[mmuaaz]

const { developmentChains, networkConfig } = require("../../helper-hardhat-config")
const { assert, expect } = require("chai")
const { getNamedAccounts, network, deployments, ethers } = require("hardhat")
!developmentChains.includes(network.name)
    ? describe.skip
    : describe("Raffle Unit Tests", function () {
          let raffle, raffleContract, vrfCoordinatorV2Mock, raffleEntranceFee, interval, deployer 
          const chainId = network.config.chainId
          beforeEach(async () => {
              deployer = (await getNamedAccounts()).deployer
              await deployments.fixture(["all"])
              raffle = await ethers.getContract("Raffle", deployer)
              vrfCoordinatorV2Mock = await ethers.getContract("VRFCoordinatorV2Mock", deployer)
              raffleContract = await ethers.getContract("Raffle")
              raffleEntranceFee = await raffle.getEntranceFee()
              interval = await raffle.getInterval()
              
          })
          describe("constructor", function () {
              it("intitiallizes the raffle correctly", async () => {
                
                  const raffleState = await raffle.getRaffleState()
            
                  assert.equal(raffleState, "0")
                  assert.equal(interval.toString(), networkConfig[chainId]["interval"])

              })
          })
          describe("enterRaffle", () => {
              it("reverts when you don't pay enough", async () => {
                  await expect(raffle.enterRaffle()).to.be.revertedWith(
                      "Raffle__NotEnoughETHEntered()"
                  )
                  
              })
              it("records players when they enter", async () => {
                  await raffle.enterRaffle({ value: raffleEntranceFee })
                  const contractPlayer = await raffle.getPlayer(0)
                  assert.equal(contractPlayer, deployer)
              })
              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 })
                
                  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.send("evm_mine", [])
                  ;/"checkUpkeep is a public function, if u call it, it will send a tx, but we want to simulate a tx and see what "upKeepNeeded" returns/
                  // We would use a "CALLSTATIC
                  const { upkeepNeeded } = await raffle.callStatic.checkUpkeep([]) 
            
                  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("0x") 
                  const raffleState = await raffle.getRaffleState()
                  const { upkeepNeeded } = await raffle.callStatic.checkUpkeep("0x") 
                  assert.equal(raffleState.toString(), "1")
                  assert(!upkeepNeeded) 
              })
              it("returns false if enough time hasn't passed", async () => {
                  await raffle.enterRaffle({ value: raffleEntranceFee })
                  await network.provider.send("evm_increaseTime", [interval.toNumber() - 5])  
                  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", () => {
              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 () => {
                  
                  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.toString() == "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")
              })
             
              it("picks a winner, resets, and sends money", async () => {
                  const additionalEntrances = 3 
                  const startingIndex = 1 
                  const accounts = await ethers.getSigners()
                  for (let i = startingIndex; i < startingIndex + additionalEntrances; i++) {
                      
                      raffle = raffleContract.connect(accounts[i]) 
                      await raffle.enterRaffle({ value: raffleEntranceFee })
                  }
                  const startingTimeStamp = await raffle.getLastTimeStamp() 
                  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.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)
                          }
                      })

                     
                      const tx = await raffle.performUpkeep([]) 
                      const txReceipt = tx.wait(1)
                      await vrfCoordinatorV2Mock.fulfillRandomWords(
                          txReceipt.events[1].args.requestId,
                          lottery.address
                      ) 
                  })
              })
          })
      })

I am getting error
Error: Timeout of 5000ms exceeded. For async tests and hooks, ensure "done()" is called; if returning a Promise, ensure it resolves

I have tried almost everything which are mentioned in other people's issues, but not getting passed this, can anybody help? I have run the keeprs troubleshoot as well, I think with the mocks I dont need a subscriptionId as we have configured that part of subscriptionId in the deploy "mocks" script, I have ran other test successfully

it("reverts if checkup is false", async () => { await expect(raffle.performUpkeep("0x")).to.be.revertedWith( "Raffle__UpkeepNotNeeded" )
This test ran successfully which means checkUpkeep is working fine, also I modified this test to check if its working as it should be by modifying the code:
`` it("reverts if checkup is false", async () => {
await raffle.enterRaffle({ value: raffleEntranceFee })
await network.provider.send("evm_increaseTime", [interval.toNumber() + 1])

              await network.provider.send("evm_mine", [])

              await expect(raffle.performUpkeep("0x")).to.be.revertedWith(
                  "Raffle__UpkeepNotNeeded"
              )``

it failed, I think it should have, also performUpKeep test is also passing, all the other test are passing so I dont know what am I doing wrong

[othaime-en]

Hey @mmuaaz please format your code appropriately with three backticks.(```)
Push your code to github and leave a link here.

[mmuaaz]

Ok so I have done that formatting hope its okay, my repo is https://github.com/mmuaaz/SolidityCourse-Lottery-Raffle

[RoboCrypter]

@mmuaaz : Your unit tests are are all passing perfectly, I'm using your contract and your Raffe.test.js
and also your helper-hardhat-config.js file!

Look at that :

[mmuaaz]

i dont have an idea hows your passing and mine doesnt,

[RoboCrypter]

@mmuaaz : Hmmm!

[RoboCrypter]

@mmuaaz : I am going to make a PR in your repo, Just merge it, It will be a updated package.json file

@mmuaaz : After merging copy & paste the merged package.json file in your project you are working on as well,

And run the command : yarn to install those dependencies.

[krakxn]

I cannot seem to find any issues whatsoever.

Please verify there are no whitespaces in your .env file and also verify if the credentials are correct (also verify whether you have sufficient funds in your subscriptionId i.e. LINK and ETH).

If the above does not work, try re-installing your dependencies after cleaning artifacts and cache.

[mmuaaz]

yeah that explains why some are able to run the same test with my codes while I can't,

[RoboCrypter]

@mmuaaz Yes!

[mmuaaz]

can you guys tell me which dependencies I should be reinstalling?

[RoboCrypter]

@mmuaaz : I am going to make a PR in your repo, Just merge it, It will be a updated package.json file

[krakxn]

Using the versions--as specified--from the package.json in the course's repo is recommended.

[mmuaaz]

@abossofmyself yeah your PR merged, it added another package file with name "package-lock.json", my package.json is still there, so now I delete my pacakge.json file and rename yours to use as the default one? will it be enough? I mean doesn't installing take more than just adding them to package.json?

[RoboCrypter]

@mmuaaz : Follow the steps exactly :

1. Delete package-lock.json file from your repo
2. Then copy the dependencies inside package.json from your github repo,
3. then inside your repo in your pc go to package.json,
4. Select all and paste it in there!

After that in your terminal run : yarn

It will install all the new dependencies you copied in your project!

[mmuaaz]

Yeah I did that, still the error stays the same,