AssertionError: expected 1000000000000000000n to equal +0

[borailci]

Hello everyone!
I'm currently on Lesson 7 in the course.
TimeStamp : 11.43:50

I am getting a error like:

---

1. FundMe
   withdraw
   allows us to withdraw with multiple funders:
   AssertionError: expected 1000000000000000000n to equal +0
   at Context. (test/unit/FundMe.test.js:127:24)
   at processTicksAndRejections (node:internal/process/task_queues:96:5)

---

My FundMe.test.js code is below :

const { assert, expect } = require("chai")
const { deployments, ethers, getNamedAccounts } = require("hardhat")
describe("FundMe", async function () {
    let fundMe
    let deployer
    let mockV3Aggregator
    const sendValue = ethers.parseEther("1")
    // 1 eth
    beforeEach(async function () {
        //deploy our fundme contract using hardhat-deploy
        /*
        const accounts = await ethers.getSigners()
        const accountZero = accounts[0]
        */

        deployer = (await getNamedAccounts()).deployer
        // this is a hardhat-deploy plugin function
        //call the getNamedAccounts() function, wait for it to finish,
        // then assign the value of the deployer property
        // from the object that getNamedAccounts() returned to the deployer variable
        const contracts = await deployments.fixture(["all"])
        // this ensures that all deployment scripts
        // tagged with "all" are run before each test.
        const signer = await ethers.getSigner(deployer)
        const fundMeAddress = contracts["FundMe"].address
        fundMe = await ethers.getContractAt("FundMe", fundMeAddress, signer)

        mockV3Aggregator = contracts["MockV3Aggregator"]
    })
    describe("constructor", function () {
        it("sets the aggregator addresses correctly", async function () {
            const response = await fundMe.priceFeed()
            console.log("response : ", response)
            console.log("address : ", mockV3Aggregator.address)
            assert.equal(response, mockV3Aggregator.address)
        })
    })
    // testing the fund function
    describe("fund", async function () {
        it("fails if you do not send enough ETH", async function () {
            await expect(fundMe.fund()).to.be.revertedWith(
                "Insufficient funds!"
            )
        })
        it("updates the amount funded", async function () {
            await fundMe.fund({ value: sendValue })
            const response = await fundMe.addressToAmountFunded(deployer)
            assert.equal(response.toString(), sendValue)
            // yarn hardhat test --grep "amount funded"
            // -grep is a filter to filter among tests
        })
        it("adds funder to array of funders", async function () {
            await fundMe.fund({ value: sendValue })
            const funder = await fundMe.funders(0)
            assert.equal(funder, deployer)
        })
    })
    // testing the withdraw function
    describe("withdraw", async function () {
        beforeEach(async function () {
            await fundMe.fund({ value: sendValue })
        })
        it("withdraw ETH from a single founder", async function () {
            const startingFundMeBalance = await ethers.provider.getBalance(
                fundMe.getAddress()
            )
            const startingDeployerBalance = await ethers.provider.getBalance(
                deployer
            )
            const transactionResponse = await fundMe.withdraw()
            const transactionReceipt = await transactionResponse.wait(1)

            //pull objects from another objects
            const gasUsed =
                transactionReceipt.gasUsed * transactionReceipt.gasPrice

            const endingFundMeBalance = await ethers.provider.getBalance(
                fundMe.getAddress()
            )
            const endingDeployerBalance = await ethers.provider.getBalance(
                deployer
            )
            assert.equal(
                startingDeployerBalance + startingFundMeBalance,
                endingDeployerBalance + gasUsed
            )
        })
        it("allows us to withdraw with multiple funders", async function () {
            const accounts = await ethers.getSigners()

            for (let i = 1; i < 6; i++) {
                const fundMeConnectedContract = await fundMe.connect(
                    accounts[i]
                )
                await fundMeConnectedContract.fund({ value: sendValue })
            }

            const startingFundMeBalance = await ethers.provider.getBalance(
                fundMe.getAddress()
            )
            const startingDeployerBalance = await ethers.provider.getBalance(
                deployer
            )
            const transactionResponse = await fundMe.withdraw()
            const transactionReceipt = await transactionResponse.wait()
            console.log(transactionReceipt)
            const gasUsed =
                transactionReceipt.gasUsed * transactionReceipt.gasPrice
            const endingFundMeBalance = await ethers.provider.getBalance(
                fundMe.getAddress()
            )
            const endingDeployerBalance = await ethers.provider.getBalance(
                deployer
            )

            assert.equal(endingFundMeBalance, 0)

            assert.equal(
                startingFundMeBalance + startingDeployerBalance,
                endingDeployerBalance + gasUsed
            )

            // make sure that funders are reset properly
            await expect(fundMe.getFunder(0)).to.be.reverted

            for (let i = 1; i < 6; i++) {
                assert.equal(
                    await fundMe.getAddressToAmountFunded(accounts[i].address),
                    0
                )
            }
        })
    })
})

I assume that funders could not withdraw properly but I could not figure it out.
Can anyone help me out?

[ghastlypale]

try change:

                const endingFundMeBalance = await ethers.provider.getBalance(
                fundMe.getAddress()
            )

to:

                  const endingFundMeBalance = await ethers.provider.getBalance(
                      fundMe.target
                  )

if you use newest ethers

[EthereumBits]

@borailci What made it work for you?