Lesson ) fulfillrandomWords - How to run test for more 3 extra entrants?

[Leonardll]

Hi guys, I need some help with the implementation of the test for a variation of the raffle. The raffle is now starting with only if there is x number of participant, when i test this it run into an infinite loop somehow. I have already increase the timeout limit to 1000000 but still nothing work. Can someone help me please?

it("picks a winner, resets the lottery, and sends money", async function () {
                  const additionalEntrants = 497
                  const startingAccountIndex = 2
                  const accounts = await ethers.getSigners()
                  for (
                      let i = startingAccountIndex;
                      i < startingAccountIndex + additionalEntrants;
                      i++
                  ) {
                      const accountConnectedRaffle = raffle.connect(accounts[i])
                      await accountConnectedRaffle.enterRaffle({ value: raffleEntranceFee })
                  }
                  const startingTimeStamp = await raffle.getLastTimeStamp()
                  // performUpkeep (mokc being chainlink keeper)
                  // fulfillRandomWords (mock being chainlink vrf coordinator)
                  // wait for fulfillRandomWords to be called
                  await new Promise(async (resolve, reject) => {
                      raffle.once("WinnerPicked", async () => {
                          console.log("Found Event!")

                          try {
                              const recentWinner = await raffle.getRecentWinner()
                              console.log(recentWinner)
                              console.log(accounts[2].address)
                              console.log(accounts[0].address)
                              console.log(accounts[1].address)
                              console.log(accounts[3].address)
                              console.log(accounts[108].address)

                              const raffleState = await raffle.getRaffleState()
                              const endingTimeStamp = await raffle.getLastTimeStamp()
                              const numPlayers = await raffle.getNumberOfPlayers()
                              const winnerEndingBalance = await accounts[2].getBalance()
                              assert.equal(numPlayers.toString(), "0")
                              assert.equal(raffleState.toString(), "0")
                              assert(endingTimeStamp > startingTimeStamp)
                              assert.equal(
                                  winnerEndingBalance.toString(),
                                  winnerStartingBalance
                                      .add(
                                          raffleEntranceFee
                                              .mul(additionalEntrants)
                                              .add(raffleEntranceFee)
                                      )
                                      .toString()
                              )
                              resolve()
                          } catch (e) {
                              reject(e)
                          }
                      })
                      const tx = await raffle.performUpkeep("0x")
                      const txReceipt = await tx.wait(1)
                      const winnerStartingBalance = await accounts[2].getBalance()
                      await vrfCoordinatorV2Mock.fulfillRandomWords(
                          txReceipt.events[1].args.requestId,
                          raffle.address
                      )
                  })
              })

[pacelliv]

What you could try is wrapping the entire test inside a for-loop and the code of the promise inside an IF-statement. Then at each iteration you should verify if the number of players is equal to the target. If it is, then you pretend to be a Chainlink node and call performUpkeep.

Now, Hardhat offers aprox 20 accounts, and the deployer is already using one, so I don't think you can add that amount of new players for testing purposes.

[Leonardll]

Hi @pacelliv , thanks for your suggestions. That is correct that hardhat offers only 20 accounts but this can be changed in hardhat config as per below

  hardhat: {
            chainId: 31337,
            blockConfirmations: 1,
            blockGasLimit: 12500000,
            gas: 12500000,
            accounts: {
                mnemonic: "test test test test test test test test test test test junk",
                path: "m/44'/60'/0'/0",
                initialIndex: 0,
                count: 500,
                balance: "10000000000000000000000",
                passphrase: "",
            }

Thus I don't understand why changing the value caused the test to run infinite loop.

[pacelliv]

I think the problem it's how you're mimicking being a Chainlink Node. Nodes are calling checkUpkeep at every block. Everytime a new player enters the Raffle you should verify if the number of players hit your target, by doing this you will now when to call performUpkeep.

It's not pretty but this is how I made it work:

it("picks a winner, resets the lottery and sends the prize", async () => {
                  console.log("Setting up test...")
                  for (let i = 2; i < 18; i++) {
                      const accounts = await ethers.getSigners()
                      const accountConnectedRaffle = raffle.connect(accounts[i])
                      await accountConnectedRaffle.enterRaffle({ value: entranceFee })
                      const startingTimeStamp = await raffle.getLatestTimeStamp()
                      if ((await raffle.getNumberOfPlayers()).toString() === "15") {
                          await new Promise(async (resolve, reject) => {
                              const { upkeepNeeded } = await raffle.checkUpkeep([])
                              console.log(`upkeepNeed is ${upkeepNeeded}`) // check if upkeepNeed is true
                              raffle.once("WinnerPicked", async () => {
                                  // setting up the listener
                                  console.log("winnerPicked event fired!")
                                  try {
                                      const recentWinner = await raffle.getRecentWinner()
                                      console.log(`The winner is ${recentWinner}`) 
                                      console.log(accounts[0].address)
                                      console.log(accounts[1].address)
                                      console.log(accounts[12].address) // the winner is in account of index 12
                                      const raffleState = await raffle.getRaffleState()
                                      const endingTimeStamp = await raffle.getLatestTimeStamp()
                                      const numPlayers = await raffle.getNumberOfPlayers()
                                      const winnerEndingBalance = await accounts[12].getBalance()
                                      console.log(
                                          `Winner ending balance: ${ethers.utils.formatEther(
                                              winnerEndingBalance.toString()
                                          )} ETH`
                                      )
                                      assert.equal(numPlayers.toString(), "0")
                                      assert.equal(raffleState.toString(), "0")
                                      assert(endingTimeStamp > startingTimeStamp)

                                      assert.equal(
                                          winnerEndingBalance.toString(),
                                          winnerStartingBalance
                                              .add(entranceFee.mul(14).add(entranceFee))
                                              .toString()
                                      )
                                      resolve()
                                  } catch (e) {
                                      reject(e)
                                  }
                              })

                              console.log("Entering Raffle...") // enter raffle
                              const tx = await raffle.performUpkeep([])
                              const txReceipt = await tx.wait(1)
                              console.log("Time to wait...")
                              const winnerStartingBalance = await accounts[12].getBalance()
                              console.log(
                                  `Winner initial balance: ${ethers.utils.formatEther(
                                      winnerStartingBalance.toString()
                                  )} ETH`
                              )
                              // check inside VRFCoordinatorV2Mock to find fulfillRandomWords parameters
                              await vrfCoordinatorV2Mock.fulfillRandomWords(
                                  txReceipt.events[1].args.requestId,
                                  raffle.address
                              )
                              // this code won't complete until the listener finishes listening
                          })
                      }
                  }
              })

In checkUpkeep I modified the hasPlayers condition to:

bool hasPlayers = (s_players.length >= 15);

Result in the console:

Btw, thanks for the information, I did not know that we can increment the number of accounts in hardhat.