TESTS NOT RUNNING FOR FUNDME

[tediyang]

I'm following the web3 course and I came across an issue when testing my hardhat fund me Contract. My tests just stopped running. I get:
$ npx hardhat test 0 passing (2ms)

every single time I run the test command. It was running at first, but it stopped after adding new test criteria. I undid the changes and it wasn't successful, it's more like my test files aren't detected. I've done everything I could but I'm not getting a positive result. I created a sample test file that ran successfully but the test file that includes my FundMe Contract doesn't get detected and didn't run. I renamed the test file name but still no positive result. But when I intentionally create an error in the FundMe test file and run the test command, It detects the test file and throws that Error, but if error codes are reverted the FundMe test doesn't run.

I also tried running npx hardhat coverage. Then got a result showing that I hadn't written the test for my FundMe Contract yet, when the test is available. So please I need someone to help me out because other tests are running and the FundMe below isn't.

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

!developmentChains.includes(network.name)
? describe.skip
: describe("FundMe Contract", async () => {
let fundMe;
let deployer;
let mockV3Aggregator;
const sendValue = ethers.utils.parseEther("1");
beforeEach(async () => {
// deploy FundMe contract
// using hardhat-deploy
deployer = (await getNamedAccounts()).deployer;
// const deployer = await ethers.getSigners();
await deployments.fixture(["all"]);

        // Get the contract factory
        const fundMeFactory = await ethers.getContractFactory("FundMe");
        // Attach the deployed contract instance
        fundMe = fundMeFactory.attach(
            (await deployments.get("FundMe")).address
        );

        // Get the contract factory for MockV3Aggregator
        const mockV3AggregatorFactory = await ethers.getContractFactory("MockV3Aggregator");
        // Attach the deployed MockV3Aggregator contract instance
        mockV3Aggregator = mockV3AggregatorFactory.attach(
            (await deployments.get("MockV3Aggregator")).address
        );
    });

    describe("constructor", async () => {
        it("sets the aggregator address correctly", async () => {
            const response = await fundMe.getPriceFeed();
            expect(response).to.equal(await mockV3Aggregator.getAddress());
        })
    });

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

        it("updates the amount funded data structure", async () => {
            await fundMe.fund({ value: sendValue });
            const response = await fundMe.getAddressToAmountFunded(
                deployer
            );
            expect(response.toString()).to.equal(sendValue.toString());
        });

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

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

        it("withdraw ETH from a single funder", async () => {
            // Arrange
            const startingFundMeBalance = await fundMe.provider.getBalance(
                await fundMe.getAddress()
            );
            const startingDeployerBalance = await fundMe.provide.getBalance(
                deployer
            );

            // Act
            const withdraw = await fundMe.withdraw();
            const transactionReceipt = await withdraw.wait(1);

            /* gas */
            const { gasUsed, effectiveGasPrice } = transactionReceipt;
            const gasCost = gasUsed.mul(effectiveGasPrice);

            // Assert
            const endingFundMeBalance = await fundMe.provider.getBalance(
                await fundMe.getaddress()
            );
            const endingDeployerBalance = await fundMe.provider.getBalance(
                deployer
            );

            expect(endingFundMeBalance).to.equal(0);
            expect(startingDeployerBalance.add(startingFundMeBalance).toString()).to.equal(
                endingDeployerBalance.add(gasCost).toString()
            );
        });

        it("withdraw ETH from many funders", async () => {
            // Arrange
            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 fundMe.provider.getBalance(
                await fundMe.getAddress()
            );
            const startingDeployerBalance = await fundMe.provide.getBalance(
                deployer
            );

            // Act
            const withdraw = await fundMe.withdraw();
            const transactionReceipt = await withdraw.wait(1);
            const { gasUsed, effectiveGasPrice } = transactionReceipt;
            const gasCost = gasUsed * effectiveGasPrice;

            // Assert
            const endingFundMeBalance = await fundMe.provider.getBalance(
                await fundMe.getaddress()
            );
            const endingDeployerBalance = await fundMe.provider.getBalance(
                deployer
            );

            expect(endingFundMeBalance).to.equal(0);
            expect(startingDeployerBalance.add(startingFundMeBalance).toString()).to.equal(
                endingDeployerBalance.add(gasCost).toString()
            );

            // Make sure that funders are reset properly
            await expect(fundMe.getFunders(0)).to.be.reverted;

            // check if all account balance is 0
            for (i = 1; i < 6; i++) {
                expect(await fundMe.getAddressToAmountFunded(accounts[i].address)).to.equal(0);
            }
        });

        it("only allows the owner to withdraw", async () => {
            const accounts = ethers.getSigners();
            const attacker = accounts[1];
            const attackerConnectedContract = await fundMe.connect(attacker);
            await expect(attackerConnectedContract.withdraw()).to.be.revertedWith("FundMe_notOwner");
        });

        it("cheaperWithdraw ETH from many funders", async () => {
            // Arrange
            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 fundMe.provider.getBalance(
                await fundMe.getAddress()
            );
            const startingDeployerBalance = await fundMe.provide.getBalance(
                deployer
            );

            // Act
            const withdraw = await fundMe.cheaperWithdraw();
            const transactionReceipt = await withdraw.wait(1);
            const { gasUsed, effectiveGasPrice } = transactionReceipt;
            const gasCost = gasUsed * effectiveGasPrice;

            // Assert
            const endingFundMeBalance = await fundMe.provider.getBalance(
                await fundMe.getaddress()
            );
            const endingDeployerBalance = await fundMe.provider.getBalance(
                deployer
            );

            expect(endingFundMeBalance).to.equal(0);
            expect(startingDeployerBalance.add(startingFundMeBalance).toString()).to.equal(
                endingDeployerBalance.add(gasCost).toString()
            );

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

            // check if all account balance is 0
            for (i = 1; i < 6; i++) {
                expect(await fundMe.getAddressToAmountFunded(accounts[i].address)).to.equal(0);
            }
        });
    });
});

`