How to write hardhat test for fallback and receive functions

[muhammet72]

I tried to write test for fallback and receive functions but i got error and I don't know how to write correctly i couldn't find any example can you help me about it

pragma solidity ^0.8.20;

contract Fallback {
  event Log(string func, address sender, uint value, bytes data, uint gas);

  // Fallback function must be declared as external.
  fallback() external payable {
    // send / transfer (forwards 2300 gas to this fallback function)
    // call (forwards all of the gas)
    emit Log("fallback", msg.sender, msg.value, msg.data, gasleft());
  }

  // Receive is a variant of fallback that is triggered when msg.data is empty
  receive() external payable {
    emit Log("receive", msg.sender, msg.value, "", gasleft());
  }

  // Helper function to check the balance of this contract
  function getBalance() public view returns (uint) {
    return address(this).balance;
  }
}

test.js

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

describe("Fallback", async () => {
  let fallback
  let accounts = []
  const valueToSend = ethers.utils.parseEther("1")

  beforeEach(async () => {
    deployer = (await getNamedAccounts()).deployer
    await deployments.fixture(["all"])
    fallback = await ethers.getContract("Fallback", deployer)
  })

  describe("fallback", async () => {
    it("should emit the correct log when fallback function is called", async function () {
      const fallbackTx = await deployer.sendTransaction({
        to: fallback.address,
        value: valueToSend,
      })

      await fallbackTx.wait()

      const fallbackEvent = fallbackTx.events.find((event) => event.event === "Log")

      expect(fallbackEvent.args.func).to.equal("fallback")
      expect(fallbackEvent.args.sender).to.equal(deployer.address)
      expect(fallbackEvent.args.value).to.equal(valueToSend)
      expect(fallbackEvent.args.data).to.equal("0x")
      expect(fallbackEvent.args.gas).to.be.a("number")
    })
  })

  describe("receive", async () => {
    it("should emit the correct log when receive function is called", async function () {
      const receiveTx = await deployer.sendTransaction({
        to: fallback.address,
        value: valueToSend,
        data: "0x",
      })

      await receiveTx.wait()

      const receiveEvent = receiveTx.events.find((event) => event.event === "Log")

      expect(receiveEvent.args.func).to.equal("receive")
      expect(receiveEvent.args.sender).to.equal(deployer.address)
      expect(receiveEvent.args.value).to.equal(valueToSend)
      expect(receiveEvent.args.data).to.equal("")
      expect(receiveEvent.args.gas).to.be.a("number")
    })
  })

  describe("get balance", async () => {
    it("should return the correct balance", async function () {
      const balance = await fallback.getBalance()
      expect(balance).to.equal(0)
    })
  })
})

Error

 
Fallback
    fallback
      1) should emit the correct log when fallback function is called
    receive
      2) should emit the correct log when receive function is called
    get balance
      ✔ should return the correct balance


  1 passing (11s)
  2 failing

  1) Fallback
       fallback
         should emit the correct log when fallback function is called:
     TypeError: deployer.sendTransaction is not a function
      at Context.<anonymous> (test/fallback.js:18:41)
      at processImmediate (node:internal/timers:466:21)

  2) Fallback
       receive
         should emit the correct log when receive function is called:
     TypeError: deployer.sendTransaction is not a function
      at Context.<anonymous> (test/fallback.js:37:40)
      at processImmediate (node:internal/timers:466:21)

can you help me about it and explain what I'm doing wrong?
Thank you for your help

[muhammet72]

it worked this is the updated test.js for falback

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

describe("Fallback", async () => {
  let fallback
  let accounts = []
  let sender

  beforeEach(async () => {
    ;[deployer, sender] = await ethers.getSigners()
    deployer = (await getNamedAccounts()).deployer
    await deployments.fixture(["all"])
    fallback = await ethers.getContract("Fallback", deployer)
  })

  describe("fallback", async () => {
    it("should receive Ether using fallback function", async function () {
      const initialBalance = await ethers.provider.getBalance(fallback.address)

      // Send Ether to the contract using a simple Ether transfer
      const amountToSend = ethers.utils.parseEther("1")
      await sender.sendTransaction({ to: fallback.address, value: amountToSend })

      // Check if the contract's balance increased by the sent amount
      const finalBalance = await ethers.provider.getBalance(fallback.address)
      expect(finalBalance).to.equal(initialBalance.add(amountToSend))
    })
  })

  describe("receive", async () => {
    it("should receive Ether using receive function", async function () {
      const initialBalance = await ethers.provider.getBalance(fallback.address)

      // Send Ether to the contract using a simple Ether transfer without data
      const amountToSend = ethers.utils.parseEther("1")
      await sender.sendTransaction({ to: fallback.address, value: amountToSend })

      // Check if the contract's balance increased by the sent amount
      const finalBalance = await ethers.provider.getBalance(fallback.address)
      expect(finalBalance).to.equal(initialBalance.add(amountToSend))
    })

    it("should emit Log event when receiving Ether", async function () {
      const amountToSend = ethers.utils.parseEther("1")

      // Send Ether to the contract using a simple Ether transfer
      const tx = await sender.sendTransaction({ to: fallback.address, value: amountToSend })
      await tx.wait()

      // Check if the Log event was emitted with the correct data
      const logs = await fallback.queryFilter("Log")
      expect(logs.length).to.equal(1)
      const log = logs[0]
      expect(log.args.func).to.equal("receive")
      expect(log.args.sender).to.equal(sender.address)
      expect(log.args.value).to.equal(amountToSend)
      expect(log.args.data).to.not.be.empty
      expect(log.args.gas.toNumber()).to.be.above(0)
    })
  })

  describe("get balance", async () => {
    it("should return the correct contract balance", async function () {
      // Get the contract's balance using the getBalance function
      const contractBalance = await fallback.getBalance()

      // Get the actual balance from the provider
      const actualBalance = await ethers.provider.getBalance(fallback.address)

      expect(contractBalance).to.equal(actualBalance)
    })
  })
})

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

describe("Fallback", async () => {
  let fallback
  let accounts = []
  let sender

  beforeEach(async () => {
    ;[deployer, sender] = await ethers.getSigners()
    deployer = (await getNamedAccounts()).deployer
    await deployments.fixture(["all"])
    fallback = await ethers.getContract("Fallback", deployer)
  })

  describe("fallback", async () => {
    it("should receive Ether using fallback function", async function () {
      const initialBalance = await ethers.provider.getBalance(fallback.address)

      // Send Ether to the contract using a simple Ether transfer
      const amountToSend = ethers.utils.parseEther("1")
      await sender.sendTransaction({ to: fallback.address, value: amountToSend })

      // Check if the contract's balance increased by the sent amount
      const finalBalance = await ethers.provider.getBalance(fallback.address)
      expect(finalBalance).to.equal(initialBalance.add(amountToSend))
    })
  })

  describe("receive", async () => {
    it("should receive Ether using receive function", async function () {
      const initialBalance = await ethers.provider.getBalance(fallback.address)

      // Send Ether to the contract using a simple Ether transfer without data
      const amountToSend = ethers.utils.parseEther("1")
      await sender.sendTransaction({ to: fallback.address, value: amountToSend })

      // Check if the contract's balance increased by the sent amount
      const finalBalance = await ethers.provider.getBalance(fallback.address)
      expect(finalBalance).to.equal(initialBalance.add(amountToSend))
    })

    it("should emit Log event when receiving Ether", async function () {
      const amountToSend = ethers.utils.parseEther("1")

      // Send Ether to the contract using a simple Ether transfer
      const tx = await sender.sendTransaction({ to: fallback.address, value: amountToSend })
      await tx.wait()

      // Check if the Log event was emitted with the correct data
      const logs = await fallback.queryFilter("Log")
      expect(logs.length).to.equal(1)
      const log = logs[0]
      expect(log.args.func).to.equal("receive")
      expect(log.args.sender).to.equal(sender.address)
      expect(log.args.value).to.equal(amountToSend)
      expect(log.args.data).to.not.be.empty
      expect(log.args.gas.toNumber()).to.be.above(0)
    })
  })

  describe("get balance", async () => {
    it("should return the correct contract balance", async function () {
      // Get the contract's balance using the getBalance function
      const contractBalance = await fallback.getBalance()

      // Get the actual balance from the provider
      const actualBalance = await ethers.provider.getBalance(fallback.address)

      expect(contractBalance).to.equal(actualBalance)
    })
  })
})