Lesson 7 Test 0 passing

[PatrickZimmerer]

Hey guys I just can't get my FundMe.test.ts to run properly, when I run

yarn hardhat test --network goerli

the staging test just runs fine 1 passing (XXX ms), but when I run

yarn hardhat test

I always get

0 passing (20ms)

I already looked around the discussions a lot and tried a lot like checking if

1. The test folder is named "Test" and not "Tests"
2. ./test is added in ts.config
3. misspelled "describe" somewhere
4. copied both test files from the github typescript repo
5. Looked trough my hardhat.config.ts as well as my helper-hardhat-config.ts
6. General folder structure is just like in the TS repo
7. Renamed to.be.revertedWith => to.be.rejectedWith ( new syntax )
8. I had other errors that I resolved like downgrading to ethers 5.7.2
9. I can deploy to both, the local and the goerli testnet without any problems

I'm confused why the staging test runs just fine, here's my stagin test

import { assert } from "chai";
import { ethers, network } from "hardhat";
import { developmentChains } from "../../helper-hardhat-config";
import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/signers";
import { FundMe } from "../../typechain-types";

developmentChains.includes(network.name)
    ? describe.skip
    : describe("FundMe Staging Tests", async function() {
          let fundMe: FundMe;
          let deployer: SignerWithAddress;

          const sendValue = ethers.utils.parseEther("0.04");
          beforeEach(async function() {
              const accounts = await ethers.getSigners();
              deployer = accounts[0];
              fundMe = await ethers.getContract("FundMe", deployer.address);
          });

          it("Allows people to fund and withdraw", async function() {
              await fundMe.fund({ value: sendValue });
              await fundMe.withdraw({
                  gasLimit: 100000
              });
              const endingFundMeBalance = await fundMe.provider.getBalance(
                  fundMe.address
              );
              console.log(
                  endingFundMeBalance.toString() +
                      " should equal 0, running assert equal..."
              );
              assert.equal(endingFundMeBalance.toString(), "0");
          });
      });

and here is my unit test

import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/signers";
import { assert, expect } from "chai";
import { network, deployments, ethers } from "hardhat";
import { developmentChains } from "../../helper-hardhat-config";
import { FundMe, MockV3Aggregator } from "../../typechain-types";

describe("FundMe", function() {
    let fundMe: FundMe;
    let mockV3Aggregator: MockV3Aggregator;
    let deployer: SignerWithAddress;
    beforeEach(async () => {
        // if you need accounts
        // const accounts = await ethers.getSigners();
        // const accountOne = accounts[0]
        console.log("before each");

        const accounts = await ethers.getSigners();
        deployer = accounts[0];
        await deployments.fixture(["all"]);
        fundMe = await ethers.getContract("FundMe");
        mockV3Aggregator = await ethers.getContract("MockV3Aggregator");
        console.log("went through beforeEach");

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

        describe("fund", function() {
            it("Fails if you don't send enough ETH", async function() {
                await expect(fundMe.fund()).to.be.rejectedWith(
                    "You need to spend more ETH!"
                );
            });
            it("Updated the amount funded data structure", async function() {
                await fundMe.fund({
                    value: ethers.utils.parseEther("1")
                });
                const response = await fundMe.getFunders(deployer.address);
                assert.equal(
                    response.toString(),
                    ethers.utils.parseEther("1").toString()
                );
            });
            it("Adds funder to array of getFunders", async function() {
                await fundMe.fund({
                    value: ethers.utils.parseEther("1")
                });
                const response = await fundMe.getFunders(0);
                assert.equal(response, deployer.address);
            });
        });

        describe("withdraw", function() {
            beforeEach(async () => {
                await fundMe.fund({
                    value: ethers.utils.parseEther("1")
                });
            });
            it("withdraw ETH from a single founder", async () => {
                // Arrange
                const startingFundMeBalance = await fundMe.provider.getBalance(
                    fundMe.address
                );
                const startingDeployerBalance = await fundMe.provider.getBalance(
                    deployer.address
                );
                // Act
                const transactionResponse = await fundMe.withdraw();
                const transactionReceipt = await transactionResponse.wait(1);

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

                const endingFundMeBalance = await fundMe.provider.getBalance(
                    fundMe.address
                );
                const endingDeployerBalance = await fundMe.provider.getBalance(
                    deployer.address
                );
                // Assert
                assert.equal(endingFundMeBalance.toString(), "0");
                assert.equal(
                    startingFundMeBalance
                        .add(startingDeployerBalance.toString())
                        .toString(),
                    endingDeployerBalance.add(gasCost).toString()
                );
            });
            // this test is overloaded. Ideally we'd split it into multiple tests
            // but for simplicity we left it as one
            it("is allows us to withdraw with multiple funders", async () => {
                // Arrange
                const accounts = await ethers.getSigners();
                await fundMe.connect(accounts[1]).fund({
                    value: ethers.utils.parseEther("1")
                });
                await fundMe.connect(accounts[2]).fund({
                    value: ethers.utils.parseEther("1")
                });
                await fundMe.connect(accounts[3]).fund({
                    value: ethers.utils.parseEther("1")
                });
                await fundMe.connect(accounts[4]).fund({
                    value: ethers.utils.parseEther("1")
                });
                await fundMe.connect(accounts[5]).fund({
                    value: ethers.utils.parseEther("1")
                });
                // Act
                const startingFundMeBalance = await fundMe.provider.getBalance(
                    fundMe.address
                );
                const startingDeployerBalance = await fundMe.provider.getBalance(
                    deployer.address
                );
                const transactionResponse = await fundMe.cheaperWithdraw();
                // Let's comapre gas costs :)
                // const transactionResponse = await fundMe.withdraw()
                const transactionReceipt = await transactionResponse.wait();
                const { gasUsed, effectiveGasPrice } = transactionReceipt;
                const withdrawGasCost = gasUsed.mul(effectiveGasPrice);
                console.log(`GasCost: ${withdrawGasCost}`);
                console.log(`GasUsed: ${gasUsed}`);
                console.log(`GasPrice: ${effectiveGasPrice}`);
                const endingFundMeBalance = await fundMe.provider.getBalance(
                    fundMe.address
                );
                const endingDeployerBalance = await fundMe.provider.getBalance(
                    deployer.address
                );
                // Assert
                assert.equal(
                    startingFundMeBalance
                        .add(startingDeployerBalance)
                        .toString(),
                    endingDeployerBalance.add(withdrawGasCost).toString()
                );
                await expect(fundMe.getFunders(0)).to.be.rejected;
                assert.equal(
                    (
                        await fundMe.getAddressToAmountFunded(
                            accounts[1].address
                        )
                    ).toString(),
                    "0"
                );
                assert.equal(
                    (
                        await fundMe.getAddressToAmountFunded(
                            accounts[2].address
                        )
                    ).toString(),
                    "0"
                );
                assert.equal(
                    (
                        await fundMe.getAddressToAmountFunded(
                            accounts[3].address
                        )
                    ).toString(),
                    "0"
                );
                assert.equal(
                    (
                        await fundMe.getAddressToAmountFunded(
                            accounts[4].address
                        )
                    ).toString(),
                    "0"
                );
                assert.equal(
                    (
                        await fundMe.getAddressToAmountFunded(
                            accounts[5].address
                        )
                    ).toString(),
                    "0"
                );
            });
            it("testing cheaperWithdraw...", async () => {
                const accounts = await ethers.getSigners();
                for (let i = 0; i < 6; i++) {
                    const fundMeConnectedContract = await fundMe.connect(
                        accounts[i]
                    );
                    await fundMeConnectedContract.fund({
                        value: ethers.utils.parseEther("1")
                    });
                }
                const startingFundMeBalance = await fundMe.provider.getBalance(
                    fundMe.address
                );
                const startingDeployerBalance = await fundMe.provider.getBalance(
                    deployer.address
                );

                const transactionResponse = await fundMe.cheaperWithdraw();
                const transactionReceipt = await transactionResponse.wait(1);

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

                const endingFundMeBalance = await fundMe.provider.getBalance(
                    fundMe.address
                );
                const endingDeployerBalance = await fundMe.provider.getBalance(
                    deployer.address
                );

                assert.equal(endingFundMeBalance.toString(), "0");
                assert.equal(
                    startingFundMeBalance
                        .add(startingDeployerBalance)
                        .toString(),
                    endingDeployerBalance.add(gasCost).toString()
                );

                await expect(fundMe.getFunders(0)).to.be.rejected;

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

here is the link to my repo:
https://github.com/PatrickZimmerer/hardhat-fund-me

[sonhd91]

I don't know how but please try install ethers@5.7.2 in terminal
yarn add --dev ethers@5.7.2

[prakhar9015]

It should work, if you will add !developmentChains.includes(network.name) ? describe.skip : in your unit test, just before your describe("FundMe", async function () { }

This was the same issue with me, and then i noticed that there was a ! exclamation mark before developmentChains and it basically represents the if not condition sort of .