AssertionError: Expected transaction to be reverted with "nonexistant request"

[parishill25]

Hi got this error whan i tested my fulfillRandomWords
AssertionError: Expected transaction to be reverted with "nonexistant request", but other reason was found: "nonexistent request"

test code :
`const { getNamedAccounts, deployments, ethers, network } = require("hardhat")
const { developmentChains } = require("../../helper-hardhat-config.js")
const { assert, expect } = require("chai")
const { networkConfig } = require("../../helper-hardhat-config")
const { FunctionFragment } = require("ethers/lib/utils")

!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("initialize the constructor correctly", async function () {
              const raffleState = await raffle.getRaffleState()
              assert.equal(raffleState.toString(), "0")
              assert.equal(interval.toString(), networkConfig[chainId]["interval"])
          })
      })

      describe("enterRaffle", function () {
          it("reverted when we don't have enough ETH", async function () {
              await expect(raffle.enterRaffle()).to.be.revertedWith(
                  "Raffle_NOTENOUGHETHTOENTERRAFFLE"
              )
          })
          it("Record player when they enter", async function () {
              await raffle.enterRaffle({ value: raffleEntranceFee })
              const player = await raffle.getPlayer(0)
              assert.equal(player, deployer)
          })
          it("Emit enter event ", async function () {
              await expect(raffle.enterRaffle({ value: raffleEntranceFee })).to.emit(
                  raffle,
                  "RaffleEnter"
              )
          })
          it("don't allow entrance when raffle is calculating", async function () {
              await raffle.enterRaffle({ value: raffleEntranceFee })
              await ethers.provider.send("evm_increaseTime", [interval.toNumber() + 1])
              await network.provider.send("evm_mine", [])
              //await network.provider.request({ method: "evm_mine", params: [] })
              await raffle.performUpkeep([])
              await expect(raffle.enterRaffle({ value: raffleEntranceFee })).to.be.revertedWith(
                  "Raffle__LotteryNotOPEN"
              )
          })
      })
      describe("checkUpkeep", function () {
          it("it returns false if people doesn't send anny", 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 function () {
              await raffle.enterRaffle({ value: raffleEntranceFee })
              await network.provider.send("evm_increaseTime", [interval.toNumber() + 1])
              await network.provider.send("evm_mine", [])
              await raffle.performUpkeep([])
              const raffleState = await raffle.getRaffleState()
              const { upkeepNeeded } = await raffle.callStatic.checkUpkeep([])
              assert.equal(raffleState.toString(), "1")
              assert.equal(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() - 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", function () {
          it("it cann only be run if checkUpkeep is true", async function () {
              await raffle.enterRaffle({ value: raffleEntranceFee })
              await network.provider.send("evm_increaseTime", [interval.toNumber() + 1])
              await network.provider.request({ method: "evm_mine", params: [] })
              const tx = raffle.performUpkeep([])
              assert(tx)
          })
          it("reverts when checkUpkeep is false", async function () {
              await expect(raffle.performUpkeep([])).to.be.revertedWith(
                  "Raffle__NotUpKeepNeedeed"
              )
          })

          it("up the raffleStates,emits and events,and calls the vrf coordinator", async function () {
              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([])
              const txReceipt = await txResponse.wait(1)
              const requestId = txReceipt.events[1].args.requestId
              const raffleState = await raffle.getRaffleState()
              assert(requestId.toNumber() > 0)
              assert(raffleState.toString() == 1)
          })
      })

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

          it("it can only be called after performUpkeep", async function () {
              await expect(
                  vrfCoordinatorV2Mock.fulfillRandomWords(0, raffle.address)
              ).to.be.revertedWith("nonexistant request")
              await expect(
                  vrfCoordinatorV2Mock.fulfillRandomWords(1, raffle.address)
              ).to.be.revertedWith("nonexistant request")
          })
      })
  })

`

solidity code:
`// SPDX-License-Identifier: MIT

// Pragma
pragma solidity ^0.8.7;

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

error Raffle_NOTENOUGHETHTOENTERRAFFLE();
error Raffle_TRANSFERfailed();
error Raffle__LotteryNotOPEN();
error Raffle__NotUpKeepNeedeed(uint256 currentBalance, uint256 numPlayers, uint256 raffleState);

/**@title A sample of Raffle Contract

• @author ......
• @notice this contract is for creating an untamperable decentralized smart contract.
• @dev this implements chainnlink VRF v2 ad chainlink Keepers

*/

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

/*State variable*/
uint256 private immutable i_entranceFee;
address payable[] private s_players;
VRFCoordinatorV2Interface private immutable i_vrfCoordinator;
bytes32 private immutable i_gasLane;
uint64 private immutable i_subscriptionId;
uint32 private immutable i_callbackGasLimit;
uint32 private immutable NUM_WORDS = 1;
uint16 private constant REQUEST_CONFIRMATIONS = 3;

// Lottery Varaibale

address private s_winner;
RaffleState private s_raffleState;
uint256 private s_lastTimeStamp;
uint256 private immutable i_interval;

/*Events*/

event RaffleEnter(address indexed player);
event RequestRaffleWinner(uint256 indexed requestId);
event RaffleWinners(address indexed winners);

// Functions:

constructor(
    address vrfCoordinnatorV2,
    uint256 entranceFee,
    bytes32 gasLane,
    uint64 subscriptionId,
    uint32 callbackGasLimit,
    uint256 interval
) VRFConsumerBaseV2(vrfCoordinnatorV2) {
    i_entranceFee = entranceFee;
    i_vrfCoordinator = VRFCoordinatorV2Interface(vrfCoordinnatorV2);
    i_gasLane = gasLane;
    i_subscriptionId = subscriptionId;
    i_callbackGasLimit = callbackGasLimit;
    s_raffleState = RaffleState.OPEN;
    s_lastTimeStamp = block.timestamp;
    i_interval = interval;
}

function enterRaffle() public payable {
    if (msg.value < i_entranceFee) {
        revert Raffle_NOTENOUGHETHTOENTERRAFFLE();
    }
    if (s_raffleState != RaffleState.OPEN) {
        revert Raffle__LotteryNotOPEN();
    }

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

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

function performUpkeep(bytes calldata /*performData*/) external override {
    (bool upkeepNeeded, ) = checkUpkeep("");
    if (!upkeepNeeded) {
        revert Raffle__NotUpKeepNeedeed(
            address(this).balance,
            s_players.length,
            uint256(s_raffleState)
        );
    }
    s_raffleState = RaffleState.CALCULATING;
    uint256 requestId = i_vrfCoordinator.requestRandomWords(
        i_gasLane,
        i_subscriptionId,
        REQUEST_CONFIRMATIONS,
        i_callbackGasLimit,
        NUM_WORDS
    );
    emit RequestRaffleWinner(requestId);
}

function fulfillRandomWords(
    uint256 /*requestId*/,
    uint256[] memory randomWords
) internal override {
    uint256 indexOfWinner = randomWords[0] % s_players.length;
    address payable winner = s_players[indexOfWinner];
    s_winner = winner;
    s_raffleState = RaffleState.OPEN;
    s_players = new address payable[](0);
    s_lastTimeStamp = block.timestamp;
    (bool success, ) = winner.call{value: address(this).balance}("");
    //require(success,"Money Transfer Failed");
    if (!success) {
        revert Raffle_TRANSFERfailed();
    }
    emit RaffleWinners(winner);
}

// View and Pure functions:
function getEntranceFee() public view returns (uint256) {
    return i_entranceFee;
}

function getPlayer(uint256 index) public view returns (address) {
    return s_players[index];
}

function getWinner() public view returns (address) {
    return s_winner;
}

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

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

function getPlayersNumber() 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_CONFIRMATIONS;
}

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

}
`

[parishill25]

@alymurtazamemon