Expected transaction to be reverted with reason 'FundMe__NotOwner', but it didn't revert

[Mayank-Pandey1]

While running a unit test, I get this error:

withdraw
        only allow the owner to withdraw:
    AssertionError: Expected transaction to be reverted with reason 'FundMe__NotOwner', but it didn't revert

when I run the command:

yarn hardhat test --grep "only allow the owner"

Here is the FundMe.test.js code:

const { deployments, ethers, getNamedAccounts } = require("hardhat");
const { assert, expect } = require("chai");

describe("FundMe", async function () {
    let fundMe;
    let deployer;
    let mockV3Aggregator;
    const sendValue = ethers.utils.parseEther("1"); //1 ETH
    beforeEach(async function () {
        deployer = (await getNamedAccounts()).deployer;
        //specifying which account we want connected to our deployed fundMe contract since we will be making transactions
        //while testing
        await deployments.fixture(["all"]); //using fixture we can deploy our contracts with as many tags as we want
        //running all the deploy scripts using this line
        fundMe = await ethers.getContract("FundMe", deployer);

        mockV3Aggregator = await ethers.getContract(
            "MockV3Aggregator",
            deployer
        );
    });

    describe("constructor", function () {
        it("sets the priceFeed addresses correctly", async () => {
            const response = await fundMe.priceFeed();
            assert.equal(mockV3Aggregator.address, response);
        });
    });

    describe("fund", function () {
        it("check it fails if don't send enough ETH", async () => {
            await expect(fundMe.fund()).to.be.revertedWith(
                "Didn't send enough"
            );
        });

        // it("check the amount funded by address is updated in mapping data structure", async () => {
        //     await fundMe.fund({ value: sendValue });
        //     const response = await fundMe.addressToAmountFunded(deployer);
        //     assert.equal(sendValue.toString(), response.toString());
        // });

        it("adds funder to array of funders", async () => {
            // const length = fundMe.funders.length;
            // await fundMe.fund({ value: sendValue });
            // assert.equal(length + 1, fundMe.funders.length);
            await fundMe.fund({ value: sendValue });
            const funder = await fundMe.funders(0);
            assert.equal(funder, deployer);
        });
    });

    describe("withdraw", function () {
        beforeEach(async () => {
            await fundMe.fund({ value: sendValue });
        });

        it("ETH is withdrawn by only one owner/account", async () => {
            const initialContractBalance = await fundMe.provider.getBalance(
                fundMe.address
            );
            const initialDeployerBalance = await fundMe.provider.getBalance(
                deployer
            );

            const transactionResponse = await fundMe.withdraw();
            const transactionReceipt = await transactionResponse.wait(1);
            const { gasUsed, effectiveGasPrice } = transactionReceipt;
            const gasCost = gasUsed.mul(effectiveGasPrice);

            const newContractBalance = await fundMe.provider.getBalance(
                fundMe.address
            );
            const newDeployerBalance = await fundMe.provider.getBalance(
                deployer
            );

            assert.equal(newContractBalance, 0);
            assert.equal(
                initialContractBalance.add(initialDeployerBalance).toString(),
                newDeployerBalance.add(gasCost).toString()
            );
        });

        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 initialContractBalance = await fundMe.provider.getBalance(
                fundMe.address
            );
            const initialDeployerBalance = await fundMe.provider.getBalance(
                deployer
            );
            const transactionResponse = await fundMe.withdraw();
            const transactionReceipt = await transactionResponse.wait(1);
            const { gasUsed, effectiveGasPrice } = transactionReceipt;
            const gasCost = gasUsed.mul(effectiveGasPrice);

            const newContractBalance = await fundMe.provider.getBalance(
                fundMe.address
            );
            const newDeployerBalance = await fundMe.provider.getBalance(
                deployer
            );

            assert.equal(newContractBalance, 0);
            assert.equal(
                initialContractBalance.add(initialDeployerBalance).toString(),
                newDeployerBalance.add(gasCost).toString()
            );

            //funders array is reset if any of the funders withdraws
            await expect(fundMe.funders(0)).to.be.reverted;

            for (i = 1; i < 6; i++) {
                assert.equal(
                    await fundMe.addressToAmountFunded(accounts[i].address),
                    0
                );
            }
        });
        it("only allow the owner to withdraw", async () => {
            const accounts = await ethers.getSigners();
            const attacker = accounts[1]; //suppose the random non-owner account which tries to withdraw is account no. 1
            const attackerConnectedContract = await fundMe.connect(attacker);
            await expect(
                attackerConnectedContract.withdraw()
            ).to.be.revertedWith("FundMe__NotOwner"); //if account 1 tries to withdraw, then the transaction is reverted
        });
    });
});

Here is the contract code:

//Send native token to this contract and withdraw from this contract

//contracts like metamask wallets can also hold tokens (a contract is deployed at an address in the blockchain)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import "./PriceConvertor.sol"; //PriceConvertor library
import "hardhat/console.sol";

error FundMe__NotOwner();

//NatSpec: Ethereum Natural Language Specification Format
/** @author Mayank Pandey
 *  @title A contract for crowdfunding
 *  @notice The contract demonstrates how people can fund to this contract and only the owner can withdraw the donated funds
 */

contract FundMe {
    address public immutable i_owner;
    AggregatorV3Interface public priceFeed;

    constructor(address priceFeedAddress) {
        i_owner = msg.sender;
        priceFeed = AggregatorV3Interface(priceFeedAddress);
    }

    using PriceConvertor for uint256;

    address[] public funders;
    mapping(address => uint256) addressToAmountFunded;

    uint256 public constant MINIMUM_USD = 50 * 1e18;

    modifier onlyOwner() {
        // require(msg.sender == i_owner, "You are not the owner");
        if (msg.sender != i_owner) revert FundMe__NotOwner();
        _;
    }

    function fund() public payable {
        //we can send tokens to this function or to the contract
        //using this function
        require(
            msg.value.getConversionRate(priceFeed) >= MINIMUM_USD,
            "Didn't send enough"
        ); //1e18 is in wei 1*10^18 wei = 1 ether
        //18 decimals
        funders.push(msg.sender);
        addressToAmountFunded[msg.sender] += msg.value;
    }

    function withdraw() public onlyOwner {
        for (uint256 i = 0; i < funders.length; i++) {
            addressToAmountFunded[funders[i]] = 0;
        }

        //reset the array
        funders = new address[](0);

        (bool callSuccess /*bytes memory functionReturnedData*/, ) = payable(
            msg.sender
        ).call{value: address(this).balance}("");
        require(callSuccess, "Withdraw failed");
    }
}

[alymurtazamemon]

@Mayank-Pandey1 It looks perfect, Leave your repo link so I can test it.

[Mayank-Pandey1]

https://github.com/Mayank-Pandey1/Crowdfunding-DApp-backend

[paulcoffee85]

Has this been resolved ? @Mayank-Pandey1

[Mayank-Pandey1]

No

[alymurtazamemon]

@Mayank-Pandey1 I apologise, I think I missed this discussion. But now I checked your repo and did not find any test folder in it. Are you sure you pushed it?

[Mayank-Pandey1]

@alymurtazamemon I have added the folder, could you check now..