testFundUpdatesFundedDataStructure FAILED : OutOfFunds

[AnaAse]

I got kinda stock here, with the prank code.
I am getting the following error:

[FAIL: EvmError: Revert] testFundUpdatesFundedDataStructure() (gas: 16886)
Traces:
[16886] FundMeTest::testFundUpdatesFundedDataStructure()
├─ [0] VM::prank(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D])
│ └─ ← [Return]
├─ [0] FundMe::fund{value: 100000000000000000}()
│ └─ ← [OutOfFunds] EvmError: OutOfFunds
└─ ← [Revert] EvmError: Revert

Seems to be obvious OutOfFunds yeah but... not as obvious really

FundMeTest:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.18;

import {Test, console} from "forge-std/Test.sol";
import {FundMe} from "../src/FundMe.sol";
import {DeployFundMe} from "../script/DeployFundMe.s.sol";

contract FundMeTest is Test {
FundMe fundMe;
address USER = makeAddr("user"); //we can use this user when we want to work with somebody
uint256 constant SEND_VALUE = 0.1 ether; // that makes it 100000000000000000

function setUp() external {
    // fundMe = new FundMe(0x106379F11C3cF4027C38655b79327081eA9C9Cf5);   OJO este numero copiado del curso!!!
    DeployFundMe deployFundMe = new DeployFundMe();
    fundMe = deployFundMe.run();
}
function testMinimumDollarFive() public view {
    assertEq(fundMe.MINIMUM_USD(), 5e18);
}
function testOwnerIsMsgSender() public view {
    assertEq(fundMe.i_owner(), msg.sender);

    //What can we do to work with addresses outside our system?
    // 1. Unit
    //   -Testing a specific part of our code
    // 2. Integration
    //   -Testing how our code works with other parts of our code
    // 3. Forked
    //   -Testing our code on a simulated real environment
    // 4. Staging
    //   - Testing our code in a real environment that is not production
}
function testPriceFeedVersionIsAccurate() public view{
    uint256 version = fundMe.getVersion();
    assertTrue(version == 4 || version == 6, "Version must be 4 or 6");
    // assertEq(version, 4);
}

function testFundFailsWithoutEnoughETH() public{
    vm.expectRevert(); //hey the next line should revert!!
    // assert (This tx fails/reverts)
    fundMe.fund(); //send with no value, 0 value
}

function testFundUpdatesFundedDataStructure() public {
    vm.prank(USER); // The next TX will be sent by USER... the following fundME.fund will be sent by USER
    fundMe.fund{value: SEND_VALUE}(); //vamos a enviar lo que hemos determinado arriba en una variable, mas que 5$
    uint256 amountFunded = fundMe.getAddressToAmountFunded(USER);
    assertEq(amountFunded, SEND_VALUE);
}

}

FundMe:

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

// Note: The AggregatorV3Interface might be at a different location than what was in the video!
import {AggregatorV3Interface} from "@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol";
import {PriceConverter} from "./PriceConverter.sol";

error FundMe__NotOwner();

contract FundMe {
using PriceConverter for uint256;

mapping(address => uint256) private s_addressToAmountFunded; //antes sin s_, ahora hemos añadido
address[] private s_funders;  //antes sin s_, ahora hemos añadido

// Could we make this constant?  /* hint: no! We should make it immutable! */
address public /* immutable */ i_owner;
uint256 public constant MINIMUM_USD = 5e18;
AggregatorV3Interface private s_priceFeed;

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

//function fund() public payable {
//    require(msg.value.getConversionRate() >= MINIMUM_USD, "You need to spend more ETH!");
    // require(PriceConverter.getConversionRate(msg.value) >= MINIMUM_USD, "You need to spend more ETH!");
//  addressToAmountFunded[msg.sender] += msg.value;
//  funders.push(msg.sender);
//}

function fund() public payable {
require(
    msg.value.getConversionRate(s_priceFeed) >= MINIMUM_USD,
    "You need to spend more ETH!"
);
s_addressToAmountFunded[msg.sender] += msg.value;
s_funders.push(msg.sender);

}

function getVersion() public view returns (uint256) {
    return s_priceFeed.version();
}

modifier onlyOwner() {
    // require(msg.sender == owner);
    if (msg.sender != i_owner) revert FundMe__NotOwner();
    _;
}

function withdraw() public onlyOwner {
    for (uint256 funderIndex = 0; funderIndex < s_funders.length; funderIndex++) {
        address funder = s_funders[funderIndex];
        s_addressToAmountFunded[funder] = 0;
    }
    s_funders = new address[](0);
    // // transfer
    // payable(msg.sender).transfer(address(this).balance);

    // // send
    // bool sendSuccess = payable(msg.sender).send(address(this).balance);
    // require(sendSuccess, "Send failed");

    // call
    (bool callSuccess,) = payable(msg.sender).call{value: address(this).balance}("");
    require(callSuccess, "Call failed");
}
// Explainer from: https://solidity-by-example.org/fallback/
// Ether is sent to contract
//      is msg.data empty?
//          /   \
//         yes  no
//         /     \
//    receive()?  fallback()
//     /   \
//   yes   no
//  /        \
//receive()  fallback()

fallback() external payable {
    fund();
}

receive() external payable {
    fund();
}
/**
 * View / Pure functions are going to be our Getters
 */

function getAddressToAmountFunded(
    address fundingAddress
    ) external view returns(uint256) {
        return s_addressToAmountFunded[fundingAddress];
    }

function getFunder(uint256 index) external view returns(address){
        return s_funders[index];
}

}

// Concepts we didn't cover yet (will cover in later sections)
// 1. Enum
// 2. Events
// 3. Try / Catch
// 4. Function Selector
// 5. abi.encode / decode
// 6. Hash with keccak256
// 7. Yul / Assembly

DeployFundMe:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.18;

import {Script} from "forge-std/Script.sol";
import {FundMe} from "../src/FundMe.sol";
import {HelperConfig} from "./HelperConfig.s.sol";

contract DeployFundMe is Script {
function run() external returns (FundMe){
//Before startBroadcast -> Not a "real" tx transaction
HelperConfig helperConfig = new HelperConfig();
address ethUsdPriceFeed = helperConfig.activeNetworkConfig();

    // After startBroadcast -> Real tx transaction!
    vm.startBroadcast();
    // Mock contract
    FundMe fundMe = new FundMe(ethUsdPriceFeed);  // OJO este numero copiado del curso!!!
    vm.stopBroadcast();
    return fundMe;
}

}

PriceConverter:

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

import {AggregatorV3Interface} from "@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol";

// Why is this a library and not abstract?
// Why not an interface?
library PriceConverter {
// We could make this public, but then we'd have to deploy it
function getPrice(AggregatorV3Interface priceFeed) internal view returns (uint256) {
// Sepolia ETH / USD Address
// https://docs.chain.link/data-feeds/price-feeds/addresses

    (, int256 answer, , , ) = priceFeed.latestRoundData();
    // ETH/USD rate in 18 digit
    return uint256(answer * 10000000000);
}

// 1000000000
function getConversionRate(
    uint256 ethAmount,
    AggregatorV3Interface priceFeed
) internal view returns (uint256) {
    uint256 ethPrice = getPrice(priceFeed);
    uint256 ethAmountInUsd = (ethPrice * ethAmount) / 1000000000000000000;
    // the actual ETH/USD conversion rate, after adjusting the extra 0s.
    return ethAmountInUsd;
}

}

[EngrPips]

Hello @AnaAse, Please make your setup function the below, then retry your test.

function setUp() external {
    // fundMe = new FundMe(0x106379F11C3cF4027C38655b79327081eA9C9Cf5);   OJO este numero copiado del curso!!!
    DeployFundMe deployFundMe = new DeployFundMe();
    fundMe = deployFundMe.run();
    vm.deal(USER, 100e18);
}