Lesson 09 : Hardhat Smart Contract Lottery fulfillRandomWords() Promise is not resolving and also getting error

[sutarrohit]

I am trying to run the last and big test of the Raffle(Lottery contract), The promise is not resolving and also getting error:

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

Unit test file:

 describe("fulfillRandomWords", function () {
        beforeEach(async () => {
          await raffle.enterRaffle({ value: entranceFee })
          await network.provider.send("evm_increaseTime", [interval + 1])
          await network.provider.request({ method: "evm_mine", params: [] })
        })


        //Testing fulfillRandomWords function

        it("picks a winner, resets, and sends money", async () => {
          const additionalEntrances = 3 // to test
          const startingIndex = 2
          const accounts = await ethers.getSigners()
          for (let i = startingIndex; i < startingIndex + additionalEntrances; i++) {
            // i = 2; i < 5; i=i+1
            const accoutConnect = raffle.connect(accounts[i]) // Returns a new instance of the Raffle contract connected to player
            await accoutConnect.enterRaffle({ value: entranceFee })
          }
          const startingTimeStamp = await raffle.getLatestTimeStamp() // stores starting timestamp (before we fire our event)

          // This will be more important for our staging tests...
          await new Promise(async (resolve, reject) => {
            raffle.once("WinnerPicked", async () => {
              // event listener for WinnerPicked
              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(raffleState, 0)
                assert.equal(
                  winnerBalance.toString(),
                  startingBalance 
                    .add(entranceFee.mul(additionalEntrances).add(entranceFee))
                    .toString()
                )
                assert(endingTimeStamp > startingTimeStamp)
                resolve() // if try passes, resolves the promise
              } catch (e) {
                reject(e) // if try fails, rejects the promise
              }
            })

            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)
          })
        })
      })

Smart Contract :

//SPDX-License-Identifier:MIT

pragma solidity 0.8.9;

import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/KeeperCompatible.sol";

/**Errors */
error Raffle_NotEnoughETHEntered();
error Raffle_TransactionFailed();
error Raffle_NotOpen();
error Raffle_upKeepNotNeeded(uint256 currentBalance, uint256 numPlayers, uint256 currentSate);

/**
 * @title A Sample Lottery contract
 * @author Rohit Sutar
 * @notice This contract is a untemprable lottery contract
 * @dev This contract implements chainlink VRF V2 & chainlink Keepers
 */

contract Raffle is VRFConsumerBaseV2, KeeperCompatibleInterface {
  /**Type declarations */
  enum RaffleState {
    OPEN,
    CALCULATING
  }

  /*State Variables */
  uint256 private immutable i_enteranceFee;
  address payable[] private s_players;
  bytes32 private immutable i_gasLane;
  uint64 private immutable i_subscriptionId;
  uint16 private constant REQUEST_CONFORMATION = 3;
  uint32 private immutable i_callbackGasLimit;
  uint32 private constant NUM_WORDS = 1;
  uint256 test1;

  /**Lottery Variables */
  address private s_recentWinner;
  RaffleState private s_RaffleState;
  uint256 private s_lastTimeStamp;
  uint256 private s_interval;

  /** VRF Coordinator contract varibles */
  VRFCoordinatorV2Interface private immutable i_vrfCoordinator;

  /*Events*/
  event RaffleEnter(address indexed player);
  event RequestRaffleWinner(uint256 indexed requestId);
  event WinnerPicked(address indexed winner);

  /**Constructor*/
  constructor(
    address vrfcoordinatorV2,
    uint256 enteranceFee,
    bytes32 gasLane,
    uint64 subscriptionId,
    uint32 callbackGasLimit,
    uint256 interval
  ) VRFConsumerBaseV2(vrfcoordinatorV2) {
    i_enteranceFee = enteranceFee;
    i_vrfCoordinator = VRFCoordinatorV2Interface(vrfcoordinatorV2);
    i_gasLane = gasLane;
    i_subscriptionId = subscriptionId;
    i_callbackGasLimit = callbackGasLimit;
    s_RaffleState = RaffleState.OPEN;
    s_lastTimeStamp = block.timestamp;
    s_interval = interval;
  }

  /**Function to Get Eth from palyers */

  function enterRaffle() public payable {
    // require(msg.value < i_enteranceFee, "Send Enough ETH");
    if (msg.value < i_enteranceFee) revert Raffle_NotEnoughETHEntered();

    if (s_RaffleState != RaffleState.OPEN) revert Raffle_NotOpen();

    s_players.push(payable(msg.sender));
    emit RaffleEnter(msg.sender);
  }

  /**Chainlink Keepers */

  /**
   * @dev This is the function that the chainlink nodes look nodes call
   * they look for the upkeepNeeded to true
   * The following should be true in order to return true
   * 1. Our time interval should be passed .
   * 2. The lottery shoud have at least 1 player and some ETH.
   * 3. out subscription is funded wtih Link token
   * 4. The lottery shoud be in open state.
   */

  /** Chainlink VRF functions */

  function checkUpkeep(
    bytes memory /*checkData*/
  )
    public
    override
    returns (
      bool upkeepNeeded,
      bytes memory /*performData*/
    )
  {
    bool isOpen = RaffleState.OPEN == s_RaffleState;
    bool timePassed = ((block.timestamp - s_lastTimeStamp) > s_interval);
    bool hasPlayer = s_players.length > 0;
    bool hasBalance = address(this).balance > 0;

    upkeepNeeded = (isOpen && timePassed && hasPlayer && hasBalance);
    return (upkeepNeeded, "0x0");
  }

  /**Function to get request id by sending all required information, with the help requestId we can call randomWords function */

  function performUpkeep(
    bytes calldata /*performData*/
  ) external override {
    // (bool upkeepNeeded, ) = checkUpkeep("");
    // if (!upkeepNeeded) revert Raffle_upKeepNotNeeded(address(this).balance, s_players.length, uint256(s_RaffleState));

    //Request some random numbers
    //Once received it, do something with
    s_RaffleState = RaffleState.CALCULATING;
    uint256 requestId = i_vrfCoordinator.requestRandomWords(i_gasLane, i_subscriptionId, REQUEST_CONFORMATION, i_callbackGasLimit, NUM_WORDS);
    emit RequestRaffleWinner(requestId);
  }

  /**function to get random words. After getting random word calculate the winner and sent all ETH to thier addresss */

  function fulfillRandomWords(
    uint256, /*requestId*/
    uint256[] memory randomWords
  ) internal override {
    //Use modulo function to get random winner
    uint256 indexOfWinner = randomWords[0] % s_players.length;
    address payable recentWinner = s_players[indexOfWinner];
    s_recentWinner = recentWinner;
    s_players = new address payable[](0);

    s_RaffleState = RaffleState.OPEN;
    s_lastTimeStamp = block.timestamp;

    //Send ETH to the winners's account
    (bool success, ) = recentWinner.call{value: address(this).balance}("");
    if (!success) {
      revert Raffle_TransactionFailed();
    }
    //Store winner history in event

    emit WinnerPicked(recentWinner);
  }

  /** View & Pure Getter functions */
  function getEntranceFee() public view returns (uint256) {
    return i_enteranceFee;
  }

  function getPlyers(uint256 _index) public view returns (address) {
    return s_players[_index];
  }

  function getRecentWinner() public view returns (address) {
    return s_recentWinner;
  }

  function getRaffleState() public view returns (RaffleState) {
    return s_RaffleState;
  }

  function getNum() public pure returns (uint256) {
    return NUM_WORDS;
  }

  function getNumberOfPlayers() public view returns (uint256) {
    return s_players.length;
  }

  function getLatestTimeStamp() public view returns (uint256) {
    return s_lastTimeStamp;
  }

  function getRequestConfirmations() public pure returns (uint256) {
    return REQUEST_CONFORMATION;
  }

  function getInterval() public view returns (uint256) {
    return s_interval;
  }
}