My staging test and unit tests are exceeding timeouts

[anooj1]

Whenever I try to pass my staging tests, its exceeding the timeout of 500000ms. Same is for my unit test "picks a winner , resest the lottery , and sends money:" test. I am pasting my code for both the tests below:

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

!developmentChains.includes(network.name)
    ? describe.skip
    : describe("Raffle Unit Tests", function () {
          let raffle, vrfCoordinatorV2Mock, raffleEntranceFee, deployer, interval
          const chainId = network.config.chainId

          beforeEach(async function () {
              deployer = (await getNamedAccounts()).deployer
              await deployments.fixture(["all"])
              raffle = await ethers.getContract("Raffle", deployer)
              vrfCoordinatorV2Mock = await ethers.getContract("VRFCoordinatorV2Mock", deployer)
              raffleEntranceFee = await raffle.getEntranceFee()
              interval = await raffle.getInterval()
          })

          describe("constructor", function () {
              it("initializes the raffle correctly", async function () {
                  // ideally we make our tests have 1 assert per "it"
                  const raffleState = await raffle.getRaffleState()
                  assert.equal(raffleState.toString(), "0")
                  assert.notStrictEqual(interval.toString(), networkConfig[chainId]["interval"])
              })
          })
          describe("enterRaffle", function () {
              it("reverts when you dont pay enough", async function () {
                  await expect(raffle.enterRaffle()).to.be.revertedWith(
                      "Raffle__NotEnoughETHEntered()"
                  )
              })
              it("records players when they enter", async function () {
                  await raffle.enterRaffle({ value: raffleEntranceFee })
                  const playerFromContract = await raffle.getPlayer(0)
                  assert.equal(playerFromContract, deployer)
              })
              it("emits 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 () {
                  await raffle.enterRaffle({ value: raffleEntranceFee })
                  await network.provider.send("evm_increaseTime", [interval.toNumber() + 1])
                  await network.provider.send("evm_mine", [])
                  // we pretend to be chainlink keeper
                  await raffle.performUpkeep([])
                  await expect(raffle.enterRaffle({ value: raffleEntranceFee })).to.be.revertedWith(
                      "Raffle__NotOpen()"
                  )
              })
          })
          describe("checkUpkeep", function () {
              it("returns falseif people havent send any ETH", async function () {
                  await network.provider.send("evm_increaseTime", [interval.toNumber() + 1])
                  await network.provider.send("evm_mine", [])
                  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.send("evm_mine", [])
                  await raffle.performUpkeep([]) // changes the state to calculating
                  const raffleState = await raffle.getRaffleState() // stores the new state
                  const { upkeepNeeded } = await raffle.callStatic.checkUpkeep("0x") // upkeepNeeded = (timePassed && isOpen && hasBalance && hasPlayers)
                  assert.equal(raffleState.toString() == "0", upkeepNeeded == true)
              })
              it("returns false if enough time hasn't passed", async () => {
                  await raffle.enterRaffle({ value: raffleEntranceFee })
                  await network.provider.send("evm_increaseTime", [interval.toNumber() - 5]) // use a higher number here if this test fails
                  await network.provider.request({ method: "evm_mine", params: [] })
                  const { upkeepNeeded } = await raffle.callStatic.checkUpkeep("0x") // upkeepNeeded = (timePassed && isOpen && hasBalance && hasPlayers)
                  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") // upkeepNeeded = (timePassed && isOpen && hasBalance && hasPlayers)
                  assert(!upkeepNeeded)
              })
          })
          describe("performUpkeep", function () {
              it("it casn only run if checkUpkeep is true", async function () {
                  await raffle.enterRaffle({ value: raffleEntranceFee })
                  await network.provider.send("evm_increaseTime", [interval.toNumber() + 1])
                  await network.provider.send("evm_mine", [])
                  const tx = await raffle.performUpkeep([])
                  assert(tx)
              })
              it("reverts when checkUpkeep is false", async function () {
                  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.send("evm_mine", [])
                  const txResponse = await raffle.performUpkeep("0x") // emits requestId
                  const txReceipt = await txResponse.wait(1) // waits 1 block
                  const raffleState = await raffle.getRaffleState() // updates state
                  const requestId = txReceipt.events[1].args.requestId
                  assert(requestId.toNumber() > 0)
                  assert(raffleState == 1) // 0 = open, 1 = calculating
              })
          })

          beforeEach(async function () {
              await raffle.enterRaffle({ value: raffleEntranceFee })
              await network.provider.send("evm_increaseTime", [interval.toNumber() + 1])
              await network.provider.send("evm_mine", [])
          })
          it("can only be called after performUpkeep", async function () {
              await expect(
                  vrfCoordinatorV2Mock.fulfillRandomWords(0, raffle.address)
              ).to.be.revertedWith("nonexistent request")
              await expect(
                  vrfCoordinatorV2Mock.fulfillRandomWords(1, raffle.address)
              ).to.be.revertedWith("nonexistent request")
          })
          // WAY TOO BIG
          it("picks a winner , resest the lottery , and sends money", async () => {
              const additonalEnternace = 3
              const startingAccountIndex = 2 // deployer = 0
              const accounts = await ethers.getSigners()

              // connecting 3 extra people to the rafffle , not including the deployer which makes it 4
              for (
                  let i = startingAccountIndex;
                  i < startingAccountIndex + additonalEnternace;
                  i++
              ) {
                  const accountConnectedRaffle = raffle.connect(accounts[i])
                  await accountConnectedRaffle.enterRaffle({ value: raffleEntranceFee })
              }
              const startingTimeStamp = await raffle.getLatestTimeStamp()

              // performUpKeep {mock being chainLink keepers}
              // fullfillRandomWords {mock being the chainLink VRF}
              // IF WE ON TESTNET : we have to wait for the fullfillRandomWords
              await new Promise(async (resolve, reject) => {
                  // Listening for the winnerPicked Event
                  raffle.once("WinnerPicked", async () => {
                      console.log("Found the event")

                      try {
                          const recentWinner = await raffle.getRecentWinner()
                          console.log(`the Last winner was : ${recentWinner}`)

                          console.log(
                              "------------------------All Accounts------------------------"
                          )
                          console.log(accounts[0].address)
                          console.log(accounts[1].address)
                          console.log(accounts[2].address)
                          console.log(accounts[3].address)

                          const raffleState = await raffle.getRaffleState()
                          const endingTimeStamp = await raffle.getLatestTimeStamp()
                          const numPlayers = await raffle.getNumberOfPlayers()
                          const winnerEndingBalance = await accounts[2].getBalance()

                          // asserts
                          assert.equal(numPlayers.toString(), "0")
                          assert.equal(raffleState.toString(), "0")
                          assert(endingTimeStamp > startingTimeStamp)

                          // doing the math to make sure the winner gets the right amount

                          assert.equal(
                              winnerEndingBalance.toString(),
                              winnerStartingBalace
                                  .add(
                                      raffleEntranceFee
                                          .mul(additonalEnternace)
                                          .add(raffleEntranceFee)
                                  )
                                  .toString()
                          )
                      } catch (error) {
                          reject(error)
                      }
                      resolve()
                  })
                  // setting up a listener

                  // below , we will fire the event , and the listner will pick it up , and resolve
                  const tx = await raffle.performUpkeep([])
                  const txReceipt = await tx.wait(1)
                  const winnerStartingBalace = await accounts[2].getBalance()
                  await vrfCoordinatorV2Mock.fulfillRandomWords(
                      txReceipt.events[1].args.requestId,
                      raffle.address
                  )
              })
          })
      })

1. Raffle Unit Tests
   picks a winner , resest the lottery , and sends money:
   Error: Timeout of 500000ms exceeded. For async tests and hooks, ensure "done()" is called; if returning a Promise, ensure it resolves. (/home/anooj-patnaik/hardhat-raffle-lottery/test/unit/Raffle.test.js)

staging test:

developmentChains.includes(network.name)
    ? describe.skip
    : describe("Raffle Staging Tests", function () {
          let raffle, raffleEntranceFee, deployer

          beforeEach(async function () {
              const factoryRaffle = await ethers.getContractFactory("Raffle")
              raffle = await factoryRaffle.deploy(
                  (arg1 = "0x2Ca8E0C643bDe4C2E08ab1fA0da3401AdAD7734D"),
                  (arg2 = ethers.utils.parseEther("0.01")),
                  (arg3 = "0xd89b2bf150e3b9e13446986e571fb9cab24b13cea0a43ea20a6049a85cc807cc"),
                  (arg4 = "588"),
                  (arg5 = "50000"),
                  (arg6 = "50")
              )
              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.getLatestTimeStamp()
                  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(error)
                          }
                      })
                      // Then entering the raffle
                      console.log("Entering Raffle...")
                      const tx = await raffle.enterRaffle({ value: raffleEntranceFee })
                      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!
                  })
              })
          })
      })

1. Raffle Staging Tests
   fulfillRandomWords
   works with live Chainlink Keepers and Chainlink VRF, we get a random winner:
   Error: Timeout of 500000ms exceeded. For async tests and hooks, ensure "done()" is called; if returning a Promise, ensure it resolves. (/home/anooj-patnaik/hardhat-raffle-lottery/test/staging/Raffle.staging.test.js)

can anyone tell me what's wrong here?

[rajanlagah]

@anooj1 can you check if performUpKeep is ever called in the keepers history? Also, adding your interval will help as it seems chainlink keepers never called the contract.
Please check this and let me know how you are integrating this.
In the new UI i am giving performUpkeep as callback fn but its never being called. can you help?