Lesson 9: TypeError: raffle.getLastTimeStamp is not a function

[cah311]

Trying to do unit tests and getting this:

  Raffle Unit Tests
    constructor
      ✔ initializes the raffle correctly
    enterRaffle
      ✔ reverts when you dont pay enough (79ms)
      ✔ records players when they enter (46ms)
      ✔ emits event on enter (61ms)
      ✔ doesnt allow entrance when raffle is calculating (171ms)
    checkUpkeep
      ✔ returns false if people havent sent any ETH
      ✔ returns false if raffle isnt open (119ms)
      ✔ returns false if enough time hasn't passed (55ms)
      ✔ returns true if enough time has passed, has players, eth, and is open (46ms)
    performUpkeep
      ✔ it can only run if checkUpkeep is true (82ms)
      ✔ reverts when checkUpkeep is false (64ms)
      ✔ updates the raffle state and emits a requestId (123ms)
    fulfillRandomWords
      ✔ can only be called after performupkeep (73ms)
      1) picks a winner, resets, and sends money


  13 passing (4s)
  1 failing

  1) Raffle Unit Tests
       fulfillRandomWords
         picks a winner, resets, and sends money:
     TypeError: raffle.getLastTimeStamp is not a function
      at Context.<anonymous> (test/unit/Raffle.test.js:144:58)
      at processTicksAndRejections (node:internal/process/task_queues:96:5)
      at runNextTicks (node:internal/process/task_queues:65:3)
      at listOnTimeout (node:internal/timers:528:9)
      at processTimers (node:internal/timers:502:7)
``

Everything works except this. I even am past this and have the staging test work but that set this off. Here is my raffle.test.js 

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

!developmentChains.includes(network.name)
? describe.skip
: describe("Raffle Unit Tests", function () {
let raffle, raffleContract, 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 just 1 assert per "it"
              const raffleState = await raffle.getRaffleState()

              assert.equal(raffleState.toString(), "0")
              assert.equal(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 () => {
              await raffle.enterRaffle({ value: raffleEntranceFee })
              // for a documentation of the methods below, go here: https://hardhat.org/hardhat-network/reference
              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([]) // changes the state to calculating for our comparison below
              await expect(raffle.enterRaffle({ value: raffleEntranceFee })).to.be.revertedWith(
                  // is reverted as raffle is calculating
                  "Raffle__NotOpen"
              )
          })
      })
      describe("checkUpkeep", function () {
          it("returns false if people havent sent 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 isnt 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() - 1])
              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 can 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([])).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.request({ method: "evm_mine", params: [] })
              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
          })
      })
      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) // reverts if not fulfilled
              ).to.be.revertedWith("nonexistent request")
              await expect(
                  vrfCoordinatorV2Mock.fulfillRandomWords(1, raffle.address) // reverts if not fulfilled
              ).to.be.revertedWith("nonexistent request")
          })
          // This test is too big...
          it("picks a winner, resets, and sends money", async () => {
              const additionalEntrances = 3 // to test
              const startingIndex = 2
              accounts = await ethers.getSigners()
              for (let i = startingIndex; i < startingIndex + additionalEntrances; i++) {
                  // i = 2; i < 5; i=i+1
                  //   raffle = raffleContract.connect(accounts[i]) // Returns a new instance of the Raffle contract connected to player
                  //   await raffle.enterRaffle({ value: raffleEntranceFee })
                  const accountConnectedRaffle = raffle.connect(accounts[i])
                  await accountConnectedRaffle.enterRaffle({ value: raffleEntranceFee })
              }
              const startingTimeStamp = await raffle.getLastTimeStamp() // 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!")
                      // assert throws an error if it fails, so we need to wrap
                      // it in a try/catch so that the promise returns event
                      // if it fails.
                      try {
                          // Now lets get the ending values...
                          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
                          // Comparisons to check if our ending values are correct:
                          assert.equal(recentWinner.toString(), accounts[2].address)
                          assert.equal(raffleState, 0)
                          assert.equal(
                              winnerBalance.toString(),
                              startingBalance // startingBalance + ( (raffleEntranceFee * additionalEntrances) + raffleEntranceFee )
                                  .add(
                                      raffleEntranceFee
                                          .mul(additionalEntrances)
                                          .add(raffleEntranceFee)
                                  )
                                  .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
                  )
              })
          })
      })
  })

``

here is my repo
https://github.com/cah311/hardhat-lottery-fcc

[othaime-en]

Try and replace getLastTimeStamp() with getLatestTimeStamp() and see if it works

[krakxn]

@cah311 I am assuming you do not have a getter function in the Raffle contract as so:

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

Note: Make sure you have the s_lastTimeStamp -- if not, you are not following along properly