Testing Problem

[RedHosain]

this is my commands
forge test -vvvv --fork-url $MAINNET_RPC_URL

forge test -vvvv --fork-url $SEPOLIA_RPC_URL

forge test -vvvv

what should i do for test successfully?
Here is my TestFubdNe.t.sol code

// SPDX-License-Identifier: MIT
pragma solidity 0.8.24;

import {Test, console} from "forge-std/Test.sol";
import {FundMe} from "../src/FundMe.sol";
import {DeployFM} from "../script/DeployFM.s.sol";
import {ZkSyncChainChecker} from "../lib/foundry-devops/src/ZkSyncChainChecker.sol";
import {HelperConfig, CodeConstants} from "../script/HelperConfig.s.sol";
import {MockV3Aggregator} from "./Mock/MockV3Aggregator.t.sol";
import {StdCheats} from "forge-std/StdCheats.sol";


contract TestFM is ZkSyncChainChecker, CodeConstants, StdCheats, Test {

    uint256 public constant SEND_VALUE = 0.1 ether;
    uint256 public constant STARTING_USER_BALANCE = 10 ether;
    uint256 public constant GAS_PRICE = 1;

    address public constant USER = address(1);
    FundMe public fundMe;
    HelperConfig public helperConfig;

    function setUp() external {
        if (!isZkSyncChain()) {
            DeployFM deployer = new DeployFM();
            (fundMe, helperConfig) = deployer.deployFM();
        } else {
            MockV3Aggregator mockPriceFeed = new MockV3Aggregator(DEC, INI_PRICE);
            fundMe = new FundMe(address(mockPriceFeed));
        }
        vm.deal(USER, STARTING_USER_BALANCE);
    }

    function test_PriceFeed_set_correctly() public skipZkSync {
        address retreivedPriceFeed = address(fundMe.getPriceFeed());
        address expectedPriceFeed = helperConfig.getConfigByChainId(block.chainid).priceFeed;
        assertEq(retreivedPriceFeed, expectedPriceFeed);
    }

    function test_funds_fails_without_anough_ETH() public skipZkSync {
        vm.expectRevert();
        fundMe.fund();
    }

    function test_fund_updates_funded_data_structure() public skipZkSync {
        vm.startPrank(USER);
        fundMe.fund{value: SEND_VALUE}();
        vm.stopPrank();

        uint256 amountFunded = fundMe.getAddToAmountFunded(USER);
        assertEq(amountFunded, SEND_VALUE);
    }

    function test_adds_funder_to_array_of_funders() public skipZkSync {
        vm.startPrank(USER);
        fundMe.fund{value: SEND_VALUE}();
        vm.stopPrank();

        address funder = fundMe.getFunder(0);
        assertEq(funder, USER);
    }

    modifier funded() {
        vm.prank(USER);
        fundMe.fund{value: SEND_VALUE}();
        assert(address(fundMe).balance > 0);
        _;
    }

    function test_onlyOwner_can_withdraw() public skipZkSync {
        vm.expectRevert();
        vm.prank(address(3));
        fundMe.withdraw();
    }

    function test_withdraw_from_a_single_funder() public skipZkSync {
        uint256 startingFundMeBalance = address(fundMe).balance;
        uint256 startingOwnerBalance = fundMe.getOwner().balance;

        vm.startPrank(fundMe.getOwner());
        fundMe.withdraw();
        vm.stopPrank();

        uint256 endingFundMeBalance = address(fundMe).balance;
        uint256 endingOwnerBalance = fundMe.getOwner().balance;
        assertEq(endingFundMeBalance, 0);
        assertEq(startingFundMeBalance + startingOwnerBalance, endingOwnerBalance);
    }


    
    function test_withdraw_from_multiple_funders() public funded skipZkSync {
        uint160 numberOfFunders = 10;
        uint160 startingFunderIndex = 2;
        
        for (uint160 i = startingFunderIndex; i < numberOfFunders + startingFunderIndex; i++) {
            hoax(address(i), STARTING_USER_BALANCE);
            fundMe.fund{value: SEND_VALUE}();
        }

        uint256 startingFundMeBalance = address(fundMe).balance;
        uint256 startingOwnerBalance = fundMe.getOwner().balance;

        vm.startPrank(fundMe.getOwner());
        fundMe.withdraw();
        vm.stopPrank();

        assert(address(fundMe).balance == 0);
        assert(startingFundMeBalance + startingOwnerBalance == fundMe.getOwner().balance);
        assert((numberOfFunders + 1) * SEND_VALUE == fundMe.getOwner().balance - startingOwnerBalance);
    }
    
}

here is my helperconfig code

// SPDX-License-Identifier: MIT
pragma solidity 0.8.24;

import {MockV3Aggregator} from "../test/Mock/MockV3Aggregator.t.sol";
import {Script, console2} from "forge-std/Script.sol";

abstract contract CodeConstants {

    uint8 public constant DEC = 8;
    int256 public constant INI_PRICE = 200e8;

    uint256 public constant ETH_SEP_CHAIN_ID = 1115111;
    uint256 public constant ZKS_SEP_CHAIN_ID = 300;
    uint256 public constant ETH_MAIN_CHAIN_ID = 1;
    uint256 public constant LOCAL_CHAIN_ID = 31337;
    
}

contract HelperConfig is CodeConstants, Script {

    error HelperConfig_InvalidchainId();

    struct NetworkConfig {
        address priceFeed;
    }

    NetworkConfig public localNetworkConfig;
    mapping(uint256 chainId => NetworkConfig) public networkConfig;

    constructor() {
        networkConfig[ETH_MAIN_CHAIN_ID] = getMainEthConfig();
        networkConfig[ETH_SEP_CHAIN_ID] = getSepEthConfig();
        networkConfig[ZKS_SEP_CHAIN_ID] = getZksSepConfig();
    }

    function getConfigByChainId(uint256 chainId) public returns(NetworkConfig memory) {
        if (networkConfig[chainId].priceFeed != address(0)) {
            return networkConfig[chainId];
        } else if (chainId == LOCAL_CHAIN_ID) {
            return getOrCreateAnvilEthConfig();
        } else {
            revert HelperConfig_InvalidchainId();
        }
    }

    function getSepEthConfig() public pure returns(NetworkConfig memory) {
        return NetworkConfig({
            priceFeed: 0x694AA1769357215DE4FAC081bf1f309aDC325306
        });
    }

    function getZksSepConfig() public pure returns(NetworkConfig memory) {
        return NetworkConfig({
            priceFeed: 0xfEefF7c3fB57d18C5C6Cdd71e45D2D0b4F9377bF
        });
    }

    function getMainEthConfig() public pure returns(NetworkConfig memory) {
        return NetworkConfig({
            priceFeed: 0x6D41d1dc818112880b40e26BD6FD347E41008eDA
        });
    }

    function getOrCreateAnvilEthConfig() public returns(NetworkConfig memory) {
        if (localNetworkConfig.priceFeed != address(0)) {
            return localNetworkConfig;
        }

        console2.log(unicode"You have deployed a mock contract!");
        console2.log("Make sure this was international");
        vm.startBroadcast();
        MockV3Aggregator mockPriceFeed = new MockV3Aggregator(DEC, INI_PRICE);
        vm.stopBroadcast();

        localNetworkConfig = NetworkConfig({priceFeed: address(mockPriceFeed)});
        return localNetworkConfig;
    }
    
}

[EngrPips]

The below from your HelperConfig is wrong

uint256 public constant ETH_SEP_CHAIN_ID = 1115111;

It should be

uint256 public constant ETH_SEP_CHAIN_ID = 11155111;

Fix that and let's see if the error persists.

[chainflash]

Awesome

[RedHosain]

The below from your HelperConfig is wrong

uint256 public constant ETH_SEP_CHAIN_ID = 1115111;

It should be

uint256 public constant ETH_SEP_CHAIN_ID = 11155111;

Fix that and let's see if the error persists.

thanks it's working

[EngrPips]

For the mainnet test you should make sure you are using the correct price feed address for the mainnet chain.

[RedHosain]

For the mainnet test you should make sure you are using the correct price feed address for the mainnet chain.

maybe

[EngrPips]

For the mainnet test you should make sure you are using the correct price feed address for the mainnet chain.

maybe

This 0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419 is the correct price feed address for eth/usd on the Ethereum mainnet

[TatyOko28]

Ensure all imports are correct
Change getConfigByChainId() to view
Verify chain detection (isZkSyncChain())
Debug the DeployFM contract separately
Use assertApproxEqAbs() for funder balance validation
Run forge test -vvv for debugging

[EngrPips]

🤔