Lesson 7:AssertionError: Expected transaction to be reverted with "Not_enough_Money"

[parishill25]

Hi,
I got this error when i want to test my fund function :

 AssertionError: Expected transaction to be reverted with "Not_enough_Money", but other reason was found: "function call to a non-contract account"

Test code

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



describe("fundMe", async function(){
    let fundMe;
    let deployer;
    let MockV3Aggregator;
    beforeEach(async function(){

        deployer= (await getNamedAccounts()).deployer
        await deployments.fixture(["all"])
        fundMe= await ethers.getContract("fundMe",deployer)
        MockV3Aggregator= await ethers.getContract("MockV3Aggregator",deployer)




    })

    describe("constructor",async function(){
        it("sets the Aggregator address correctly",async function(){
            const response= await fundMe.pricefeed()
            assert.equal(response,MockV3Aggregator.address)

        })
    })

    describe("fund", async function(){
        it("Fails if it not send enough ETH",async function(){
            await expect(fundMe.fund()).to.be.revertedWith("Not_enough_Money")
        })
    })
})

deploy Mock00:

const{network}=require("hardhat")
const {networkConfig,DECIMALS,INITIAL_ANSWER,developmentChains}=require("../helper-hardhat-config.js")


module.exports=async({deployments,getNamedAccounts})=>{
    const {deployer}=  await getNamedAccounts()
    const {log,deploy}=deployments
    const chainId= network.config.chainId


const args= [DECIMALS,INITIAL_ANSWER]



if(developmentChains.includes(network.name)){
    log("local network detected!Deploying mock.............")
    const MockV3Aggregator= await deploy("MockV3Aggregator",{
        contract:"MockV3Aggregator",
        from:deployer,
        args:args,
        log:true,
    })

    log("Mocks Deloyed")
    log("---------------------------------------------")
}

}
module.exports.tags=["all","mocks"]

001-deploy code :

const { deployments,network } = require("hardhat")

const {networkConfig, developmentChains}=require("../helper-hardhat-config.js")
const { verify } = require("../utils/verify.js")

module.exports= async({getNamedAccounts,deplyoments})=>{
    const {deploy,log}=deployments
    const {deployer}=await getNamedAccounts()
    const chainId= network.config.chainId
   
    let ethUsdPriceFeedAddress;
    if(developmentChains.includes(network.name)){
        const AggregatorV3= await deployments.get("MockV3Aggregator")
        ethUsdPriceFeedAddress=  AggregatorV3.address;
    }else {
        ethUsdPriceFeedAddress=networkConfig[chainId]["ethUsdPriceFeed"]
    }
  args=[ethUsdPriceFeedAddress]
    const fundMe = await deploy("fundMe",{
        from:deployer,
        args:args,
        log:true,
        waitConfirmations:network.config.blockConfirmartions||1

    })
    if(!developmentChains.includes(network.name)&& process.env.ETHERSCAN_KEY)
    await verify(fundMe.address,args)
    log("--------------------------------------------")

}

module.exports.tags=["all","fundMe"]

hardhat-config:

require("@nomiclabs/hardhat-waffle")
require("@nomiclabs/hardhat-etherscan")
require("hardhat-deploy")
require("solidity-coverage")
require("hardhat-gas-reporter")
require("hardhat-contract-sizer")
require("dotenv").config()

ALCHEMY_URL=process.env.ALCHEMY_URL
PRIVATE_KEY=process.env.PRIVATE_KEY
ETHERSCAN_KEY=process.env.ETHERSCAN_KEY


/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {

  defaultNetwork:"hardhat",
networks:{
  sepolia:{
    url:ALCHEMY_URL,
    accounts:[PRIVATE_KEY],
    chainId:11155111,
    blockConfirmations:6
  }
 },

etherscan:{
  apiKey:{
    sepolia:ETHERSCAN_KEY
  }
 
},

gasReporter:{

},
 
  solidity: {
    compilers:[
      {version:"0.8.8"},{version:"0.6.6"}
    ]
  },

  namedAccounts: {
    deployer: {
        default: 0,
    },
    uer:{
      default:1,
    }
},

}
hardhat-helper code : 
`

const networkConfig={

    11155111:{
        name:"sepolia",
        ethUsdPriceFeed:"0x694AA1769357215DE4FAC081bf1f309aDC325306",


    }

}


const developmentChains=["hardhat","localhost"]

const DECIMALS= 8
const INITIAL_ANSWER=200000000000

module.exports={networkConfig,DECIMALS,INITIAL_ANSWER,developmentChains}`

fund Me Contract:

// SPDX-License-Identifier: SEE LICENSE IN LICENSE

// Pragma
pragma solidity ^0.8.7;

//imports
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import "./priceConverter.sol";

/**
 * @title A contract for a crowd funding 
 * @notice this contract i to demo a sample of funding contract
 * @dev this implements Price Feed as our library
 */
contract fundMe {

    //type declaration:
    using priceConverter for uint256;

    // State variables:
    uint256 amountInUsd = 50*10**18;
    address public immutable owner;
    address[] public funders;
    mapping(address => uint256) addressToValue;
    AggregatorV3Interface public pricefeed;

    // modifier: 
    modifier onlyOwner() {
        require(msg.sender == owner, "NOT_OWNER");
        _;
    }

    // Functions:
    constructor(address pricefeedAddress) {
        owner = msg.sender;
        pricefeed = AggregatorV3Interface(pricefeedAddress);
    }

  fallback() external payable {
        fund();
    }

    receive() external payable {
        fund();
    }
    

    function fund() public payable {
        require(msg.value.getpriceConverion(pricefeed)>= amountInUsd, "Not_enough_Money");
        addressToValue[msg.sender] += msg.value;
        funders.push(msg.sender);
    }

    function withraw() public onlyOwner {
        for (
            uint256 funderIndex = 0;
            funderIndex < funders.length;
            funderIndex++
        ) {
            address funder = funders[funderIndex];
            addressToValue[funder] = 0;
        }
        (bool sucess, ) = payable(msg.sender).call{
            value: address(this).balance
        }("");
        require(sucess, "withraw Failed");
    }

  
}

PriceConverter code:

// SPDX-License-Identifier: SEE LICENSE IN LICENSE

pragma solidity ^0.8.7;

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

library priceConverter {
    function getPrice(
        AggregatorV3Interface pricefeed
    ) internal  view returns (uint256) {
        pricefeed = AggregatorV3Interface(
            0x694AA1769357215DE4FAC081bf1f309aDC325306
        );
        (, int256 price, , , ) = pricefeed.latestRoundData();
        return uint256(price * 1e10);
    }

    function getpriceConverion(
        uint256 amount,
        AggregatorV3Interface pricefeed
    ) internal view returns (uint256) {
        uint256 priceEth = getPrice(pricefeed);
        uint256 amountInEth =(amount*priceEth)/ 1e18;
        return amountInEth;
    }
    
}

[alymurtazamemon]

@parishill25 Check it out this LINK, if you do not found solution here, then leave your repository so I can check locally.