Need Help With Liquidation Tests...

[AllenOps08]

Hey so i was writing some tests for liquidation function ...

And got this error

allen@LN08:~/foundry/foundry-defi-stablecoin-f23$ forge test --mt testIfLiquidatesCorrectly -vvvvv
[⠰] Compiling...
No files changed, compilation skipped

Ran 1 test for test/unit/DSCEngineTest.t.sol:DSCEngineTest
[FAIL. Reason: DSCEngine__BreaksHealthFactor(0)] testIfLiquidatesCorrectly() (gas: 181341)
Traces:
  [10828231] DSCEngineTest::setUp()
    ├─ [4869836] → new DeployDSC@0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f
    │   └─ ← [Return] 24210 bytes of code
    ├─ [5706972] DeployDSC::run()
    │   ├─ [3746933] → new <unknown>@0x104fBc016F4bb334D775a19E8A6510109AC63E00
    │   │   ├─ [0] VM::startBroadcast()
    │   │   │   └─ ← [Return] 
    │   │   ├─ [372455] → new <unknown>@0x90193C961A926261B756D1E5bb255e67ff9498A1
    │   │   │   └─ ← [Return] 1083 bytes of code
    │   │   ├─ [658896] → new <unknown>@0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496
    │   │   │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: DeployDSC: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f], value: 100000000000 [1e11])
    │   │   │   └─ ← [Return] 2829 bytes of code
    │   │   ├─ [372455] → new <unknown>@0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3
    │   │   │   └─ ← [Return] 1083 bytes of code
    │   │   ├─ [658896] → new <unknown>@0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76
    │   │   │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: DeployDSC: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f], value: 100000000000 [1e11])
    │   │   │   └─ ← [Return] 2829 bytes of code
    │   │   ├─ [0] VM::stopBroadcast()
    │   │   │   └─ ← [Return] 
    │   │   └─ ← [Return] 6970 bytes of code
    │   ├─ [912] 0x104fBc016F4bb334D775a19E8A6510109AC63E00::activeNetworkConfig() [staticcall]
    │   │   └─ ← [Return] 0x90193C961A926261B756D1E5bb255e67ff9498A1, 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3, 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76, 77814517325470205911140941194401928579557062014761831930645393041380819009408 [7.781e76]
    │   ├─ [0] VM::startBroadcast(<pk>)
    │   │   └─ ← [Return] 
    │   ├─ [750023] → new <unknown>@0x5FbDB2315678afecb367f032d93F642f64180aa3
    │   │   ├─ emit OwnershipTransferred(previousOwner: 0x0000000000000000000000000000000000000000, newOwner: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266)
    │   │   └─ ← [Return] 3402 bytes of code
    │   ├─ [969172] → new DSCEngine@0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512
    │   │   └─ ← [Return] 4163 bytes of code
    │   ├─ [2446] 0x5FbDB2315678afecb367f032d93F642f64180aa3::transferOwnership(DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512])
    │   │   ├─ emit OwnershipTransferred(previousOwner: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266, newOwner: DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512])
    │   │   └─ ← [Stop] 
    │   ├─ [0] VM::stopBroadcast()
    │   │   └─ ← [Return] 
    │   └─ ← [Return] 0x5FbDB2315678afecb367f032d93F642f64180aa3, DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], 0x104fBc016F4bb334D775a19E8A6510109AC63E00
    ├─ [912] 0x104fBc016F4bb334D775a19E8A6510109AC63E00::activeNetworkConfig() [staticcall]
    │   └─ ← [Return] 0x90193C961A926261B756D1E5bb255e67ff9498A1, 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3, 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76, 77814517325470205911140941194401928579557062014761831930645393041380819009408 [7.781e76]
    ├─ [24728] 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496::mint(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], 10000000000000000000 [1e19])
    │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], value: 10000000000000000000 [1e19])
    │   └─ ← [Stop] 
    ├─ [271] DSCEngine::getLiquidationThreshold() [staticcall]
    │   └─ ← [Return] 50
    ├─ [226] DSCEngine::getLiquidationPrecision() [staticcall]
    │   └─ ← [Return] 100
    └─ ← [Stop] 

  [153841] DSCEngineTest::testIfLiquidatesCorrectly()
    ├─ [0] VM::startPrank(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D])
    │   └─ ← [Return] 
    ├─ [24651] 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496::approve(DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], 10000000000000000000 [1e19])
    │   ├─ emit Approval(owner: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], spender: DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], value: 10000000000000000000 [1e19])
    │   └─ ← [Return] true
    ├─ [65039] DSCEngine::depositCollateral(0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 10000000000000000000 [1e19])
    │   ├─ emit CollateralDeposited(user: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], token: 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, amount: 10000000000000000000 [1e19])
    │   ├─ [32489] 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496::transferFrom(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], 10000000000000000000 [1e19])
    │   │   ├─ emit Approval(owner: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], spender: DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], value: 0)
    │   │   ├─ emit Transfer(from: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], to: DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], value: 10000000000000000000 [1e19])
    │   │   └─ ← [Return] true
    │   └─ ← [Stop] 
    ├─ [0] VM::stopPrank()
    │   └─ ← [Return] 
    ├─ [73067] DSCEngine::mintDsc(350000000000000000 [3.5e17])
    │   ├─ [14098] OracleLib::staleCheckLastestRoundData() [delegatecall]
    │   │   ├─ [8993] 0x90193C961A926261B756D1E5bb255e67ff9498A1::latestRoundData() [staticcall]
    │   │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   ├─ [14098] OracleLib::staleCheckLastestRoundData() [delegatecall]
    │   │   ├─ [8993] 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3::latestRoundData() [staticcall]
    │   │   │   └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
    │   │   └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
    │   └─ ← [Revert] DSCEngine__BreaksHealthFactor(0)
    └─ ← [Revert] DSCEngine__BreaksHealthFactor(0)

Suite result: FAILED. 0 passed; 1 failed; 0 skipped; finished in 19.76ms (1.68ms CPU time)

Ran 1 test suite in 1.06s (19.76ms CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/unit/DSCEngineTest.t.sol:DSCEngineTest
[FAIL. Reason: DSCEngine__BreaksHealthFactor(0)] testIfLiquidatesCorrectly() (gas: 181341)

Encountered a total of 1 failing tests, 0 tests succeeded
allen@LN08:~/foundry/foundry-defi-stablecoin-f23$ 

The problem is that the health factor is breaking and I don't know how to fix it.

This is my DSCTEST file

// SPDX-License-Identifier: SEE LICENSE IN LICENSE
pragma solidity 0.8.22;

import {Test, console} from "forge-std/Test.sol";
import {DeployDSC} from "script/DeployDSC.s.sol";
import {DecentralizedStableCoin} from "src/DecentralizedStableCoin.sol";
import {DSCEngine} from "src/DSCEngine.sol";
import {HelperConfig} from "script/HelperConfig.s.sol";
import {ERC20Mock} from "@openzeppelin/contracts/mocks/ERC20Mock.sol";
import {VmSafe} from "lib/forge-std/src/Vm.sol";
import {MockV3Aggregator} from "../mocks/MockV3Aggregator.sol";

contract DSCEngineTest is Test {
    DeployDSC deployer;
    DecentralizedStableCoin dsc;
    DSCEngine dsce;
    HelperConfig config;
    address ethUsdPriceFeed;
    address btcUsdPriceFeed;
    address weth;
    address public USER = makeAddr("user");
    address liquidator = makeAddr("liquidator");
    uint256 public constant AMOUNT_COLLATERAL = 10 ether;
    uint256 DEBT_AMOUNT = 7 ether;
    uint256 public constant STARTING_ERC20_BALANCE = 10 ether;

    uint256 public LIQUIDATION_THRESHOLD;
    uint256 public LIQUIDATION_PRECISION;

    function setUp() public {
        deployer = new DeployDSC();
        (dsc, dsce, config) = deployer.run();
        (ethUsdPriceFeed, btcUsdPriceFeed, weth,,) = config.activeNetworkConfig();

        ERC20Mock(weth).mint(USER, STARTING_ERC20_BALANCE);

        LIQUIDATION_THRESHOLD = dsce.getLiquidationThreshold();
        LIQUIDATION_PRECISION = dsce.getLiquidationPrecision(); //Initialize things in the constructor
    }

    /*//////////////////////////////////////////////////////////////
                        CONSTRUCTOR TESTS 
    //////////////////////////////////////////////////////////////*/

    address[] public tokenAddresses;
    address[] public priceFeedAddresses;

    function testRevertsIfTokenLengthDoesntMatchPriceFeeds() public {
        tokenAddresses.push(weth);
        priceFeedAddresses.push(ethUsdPriceFeed);
        priceFeedAddresses.push(btcUsdPriceFeed);

        vm.expectRevert(DSCEngine.DSCEngine__TokenAddressesAndPriceFeedAddressesMustBeSameLength.selector);
        new DSCEngine(tokenAddresses, priceFeedAddresses, address(dsc));
    }

    /*//////////////////////////////////////////////////////////////
                              PRICE TESTS
    //////////////////////////////////////////////////////////////*/

    function testGetUsdInValue() public view {
        uint256 ethAmount = 15e18;
        //15e18 = 2000/ETH = 30000e18 Because 1 ETH equals $2000
        uint256 expectedUsd = 30000e18;
        uint256 actualUsd = dsce.getUsdInValue(weth, ethAmount);
        assertEq(expectedUsd, actualUsd);
    }

    function testGetTokenAmountFromUsd() public view {
        uint256 usdAmount = 100 ether;
        // $2000/ETH , $100 , wEth = 100/2000
        uint256 expectedWeth = 0.05 ether;
        uint256 actualWeth = dsce.getTokenAmountFromUsd(weth, usdAmount);
        assertEq(expectedWeth, actualWeth);
    }

    /*//////////////////////////////////////////////////////////////
                           DEPOSIT COLLATERAL
    //////////////////////////////////////////////////////////////*/

    function testRevertsIfCollateralZero() public {
        vm.startPrank(USER);
        ERC20Mock(weth).approve(address(dsce), AMOUNT_COLLATERAL);

        vm.expectRevert(DSCEngine.DSCEngine__NeedsMoreThanZero.selector);
        dsce.depositCollateral(weth, 0);
        vm.stopPrank();
    }

    function testRevertsWithUnapprovedCollateral() public {
        ERC20Mock ranToken = new ERC20Mock("RAN", "RAN", USER, AMOUNT_COLLATERAL);
        vm.startPrank(USER);
        vm.expectRevert(DSCEngine.DSCEngine__NotAllowedToken.selector);
        dsce.depositCollateral(address(ranToken), AMOUNT_COLLATERAL);
        vm.stopPrank();
    }

    //Test reentrancy too

    modifier depositedCollateral() {
        vm.startPrank(USER);
        ERC20Mock(weth).approve(address(dsce), AMOUNT_COLLATERAL);
        dsce.depositCollateral(weth, AMOUNT_COLLATERAL);
        vm.stopPrank();
        _;
    }

    function testDepositCollateralAndMintDsc() public depositedCollateral {
        vm.startPrank(address(dsce));
        uint256 amountToMint = 1e18;
        dsc.mint(address(dsce), amountToMint);
        uint256 balance = dsc.balanceOf(address(dsce));
        assertEq(balance, amountToMint);
        vm.stopPrank();
    }

    function testCanDepositCollateralAndGetAccountInfo() public depositedCollateral {
        (uint256 totalDscMinted, uint256 collateralValueInUsd) = dsce.getAccountInformation(USER);
        uint256 expectedTotalDscMinted = 0;
        //10 ether*2000 = $20000
        uint256 expectedDepositAmount = dsce.getTokenAmountFromUsd(weth, collateralValueInUsd);
        assertEq(totalDscMinted, expectedTotalDscMinted);
        assertEq(expectedDepositAmount, AMOUNT_COLLATERAL);
    }

    function testRedeemCollateralForDsc() public depositedCollateral {
        //Start the prank for the USER
        vm.startPrank(USER);

        //Mint some DSC first
        uint256 amountToMint = 1e18;
        dsce.mintDsc(amountToMint);

        //Get the initial balances
        uint256 initialDscBalance = dsc.balanceOf(USER);
        uint256 initialCollateralBalance = ERC20Mock(weth).balanceOf(USER);

        //Calculate the amount to collateral to redeem
        uint256 collateralToRedeem = 1 ether;

        //Approve DSCEngine to spend user's DSC
        dsc.approve(address(dsce), amountToMint);

        dsce.redeemCollateralForDsc(weth, collateralToRedeem, amountToMint);

        //Get updated balances
        uint256 updatedDscBalance = dsc.balanceOf(USER);
        uint256 updatedCollateralBalance = ERC20Mock(weth).balanceOf(USER);
        vm.stopPrank();

        assertEq(updatedDscBalance, initialDscBalance - amountToMint);
        assertEq(updatedCollateralBalance, initialCollateralBalance + collateralToRedeem);
    }

    function testIfRevertsIfHealthFactorIsBroken() public depositedCollateral {
        //Calculating the maximum amount of DSC that can be minted
        (, uint256 collateralValueInUsd) = dsce.getAccountInformation(USER);
        uint256 maxDscToMint = collateralValueInUsd * dsce.getLiquidationThreshold() / dsce.getLiquidationPrecision();

        //Attempt to mint slightly more than the maximum allowed
        uint256 amountToMint = maxDscToMint + 1;
        vm.startPrank(USER);

        //This should revert due to broken health factor
        vm.expectRevert(abi.encodeWithSelector(DSCEngine.DSCEngine__BreaksHealthFactor.selector, 999999999999999999));
        dsce.mintDsc(amountToMint);

        vm.stopPrank();
    }

    //Write these tests yourself, you might need to refractor some code

    /*//////////////////////////////////////////////////////////////
                               LIQUIDATE
    //////////////////////////////////////////////////////////////*/

    function testIfLiquidatesCorrectly() public depositedCollateral {
        //Setup , done
        //Provide collateral and mint dsc for the user , done
        dsce.mintDsc(DEBT_AMOUNT/20);

        //Check health factor
        uint256 userHealthFactor = dsce.getHealthFactor(USER);
        assertLt(userHealthFactor, dsce.MIN_HEALTH_FACTOR());

        //Prepare the liquidator
        vm.startPrank(liquidator);
        uint256 debtToCover = DEBT_AMOUNT/4;
        uint256 liquidatorCollateral = 10 ether;
        ERC20Mock(weth).mint(liquidator, debtToCover);
        ERC20Mock(weth).approve(address(dsce), debtToCover);
        // Deposit more collateral than the debt to ensure a good health factor
        dsce.depositCollateralAndMintDSC(weth, liquidatorCollateral, debtToCover);
        dsc.approve(address(dsce), debtToCover);

        //Record balances after liquidation
        uint256 liquidatorWethBefore = ERC20Mock(weth).balanceOf(liquidator);
        uint256 liquidatorDscBefore = dsc.balanceOf(liquidator);
        uint256 userWethBefore = ERC20Mock(weth).balanceOf(USER);
        uint256 userDscBefore = dsc.balanceOf(USER);

        //Perform liquidation
        dsce.liquidate(liquidator, USER, debtToCover);
        vm.stopPrank();

        //Check balances after liquidation
        uint256 liquidatorWethAfter = ERC20Mock(weth).balanceOf(liquidator);
        uint256 liquidatorDscAfter = dsc.balanceOf(liquidator);
        uint256 userWethAfter = ERC20Mock(weth).balanceOf(USER);
        uint256 userDscAfter = dsc.balanceOf(USER);

        assertLt(liquidatorWethAfter, liquidatorWethBefore, "Liquidator WETH should decrease");
        assertGt(liquidatorDscAfter, liquidatorDscBefore, "Liquidator DSC amount should increase");
        assertLt(userWethAfter, userWethBefore, "User WETH should decrease");
        assertEq(userDscAfter, userDscBefore - debtToCover, "User DSC should decrease by debtToCover");

        //Check health factor improvement
        uint256 userHealthFactorAfter = dsce.getHealthFactor(USER);
        assertGt(userHealthFactorAfter, userHealthFactor, "User health factor should improve");
    }
}

and this is my health factor function , tried to refractor it by adding a error

    function _healthFactor(address user) private view returns (uint256) {
        //Get total DSC minted , get total collateral value
        (uint256 totalDSCMinted, uint256 collateralValueInUsd) = _getAccountInformation(user);
        if (totalDSCMinted == 0) revert DSCEngine__HealthFactorOk(); //This means no debt
        uint256 collateralAdjustedForThreshold = (collateralValueInUsd * LIQUIDATION_THRESHOLD) / LIQUIDATION_PRECISION;
        return (collateralAdjustedForThreshold * PRECISION) / totalDSCMinted; //If this is <1 you will get liquidated
            //1000 ETH*50 = 50000/100 = 500
            // $150 ETH / 100 DSC = 1.5
            // 150*50 = 7500/100 = (75/100) = 0.75
            // return (collateralValueInUsd / totalDSCMinted); //(150/100) , if we go down a penny we'll be under collateralized..Thus set the threshold higher, like 150 so that under 150 you'' get liquidated
    }

    function _revertIfHealthFactorIsBroken(address user) internal view {
        //1. Check health factor , check aave documentation..Revert if the don't
        uint256 userHealthFactor = _healthFactor(user);
        if (userHealthFactor < MIN_HEALTH_FACTOR) {
            revert DSCEngine__BreaksHealthFactor(userHealthFactor);
        }
    }

[EngrPips]

Hello @AllenOps08, import console from forge-std/Script.sol in your DSCEngine contract, and then in your _healthFactor function, use console.log to print out what the value of collateralValueInUsd and totalDSCMinted. Let's start from there, and we should soon catch the issue.

[AllenOps08]

Yo bro @EngrPips

here's it...Looks like the collateralValue is 0 here....

allen@LN08:~/foundry/foundry-defi-stablecoin-f23$ forge test --mt testIfLiquidatesCorrectly -vvvv
[⠆] Compiling...
[⠘] Compiling 3 files with Solc 0.8.22
[⠊] Solc 0.8.22 finished in 4.42s
Compiler run successful!

Ran 1 test for test/unit/DSCEngineTest.t.sol:DSCEngineTest
[FAIL. Reason: DSCEngine__BreaksHealthFactor(0)] testIfLiquidatesCorrectly() (gas: 184559)
Logs:
  0
  350000000000000000

Traces:
  [10879141] DSCEngineTest::setUp()
    ├─ [4895272] → new DeployDSC@0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f
    │   └─ ← [Return] 24337 bytes of code
    ├─ [5732410] DeployDSC::run()
    │   ├─ [3746933] → new <unknown>@0x104fBc016F4bb334D775a19E8A6510109AC63E00
    │   │   ├─ [0] VM::startBroadcast()
    │   │   │   └─ ← [Return] 
    │   │   ├─ [372455] → new <unknown>@0x90193C961A926261B756D1E5bb255e67ff9498A1
    │   │   │   └─ ← [Return] 1083 bytes of code
    │   │   ├─ [658896] → new <unknown>@0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496
    │   │   │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: DeployDSC: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f], value: 100000000000 [1e11])
    │   │   │   └─ ← [Return] 2829 bytes of code
    │   │   ├─ [372455] → new <unknown>@0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3
    │   │   │   └─ ← [Return] 1083 bytes of code
    │   │   ├─ [658896] → new <unknown>@0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76
    │   │   │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: DeployDSC: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f], value: 100000000000 [1e11])
    │   │   │   └─ ← [Return] 2829 bytes of code
    │   │   ├─ [0] VM::stopBroadcast()
    │   │   │   └─ ← [Return] 
    │   │   └─ ← [Return] 6970 bytes of code
    │   ├─ [912] 0x104fBc016F4bb334D775a19E8A6510109AC63E00::activeNetworkConfig() [staticcall]
    │   │   └─ ← [Return] 0x90193C961A926261B756D1E5bb255e67ff9498A1, 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3, 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76, 77814517325470205911140941194401928579557062014761831930645393041380819009408 [7.781e76]
    │   ├─ [0] VM::startBroadcast(<pk>)
    │   │   └─ ← [Return] 
    │   ├─ [750023] → new <unknown>@0x5FbDB2315678afecb367f032d93F642f64180aa3
    │   │   ├─ emit OwnershipTransferred(previousOwner: 0x0000000000000000000000000000000000000000, newOwner: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266)
    │   │   └─ ← [Return] 3402 bytes of code
    │   ├─ [994598] → new DSCEngine@0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512
    │   │   └─ ← [Return] 4290 bytes of code
    │   ├─ [2446] 0x5FbDB2315678afecb367f032d93F642f64180aa3::transferOwnership(DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512])
    │   │   ├─ emit OwnershipTransferred(previousOwner: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266, newOwner: DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512])
    │   │   └─ ← [Stop] 
    │   ├─ [0] VM::stopBroadcast()
    │   │   └─ ← [Return] 
    │   └─ ← [Return] 0x5FbDB2315678afecb367f032d93F642f64180aa3, DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], 0x104fBc016F4bb334D775a19E8A6510109AC63E00
    ├─ [912] 0x104fBc016F4bb334D775a19E8A6510109AC63E00::activeNetworkConfig() [staticcall]
    │   └─ ← [Return] 0x90193C961A926261B756D1E5bb255e67ff9498A1, 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3, 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76, 77814517325470205911140941194401928579557062014761831930645393041380819009408 [7.781e76]
    ├─ [24728] 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496::mint(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], 10000000000000000000 [1e19])
    │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], value: 10000000000000000000 [1e19])
    │   └─ ← [Stop] 
    ├─ [271] DSCEngine::getLiquidationThreshold() [staticcall]
    │   └─ ← [Return] 50
    ├─ [226] DSCEngine::getLiquidationPrecision() [staticcall]
    │   └─ ← [Return] 100
    └─ ← [Stop] 

  [157059] DSCEngineTest::testIfLiquidatesCorrectly()
    ├─ [0] VM::startPrank(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D])
    │   └─ ← [Return] 
    ├─ [24651] 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496::approve(DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], 10000000000000000000 [1e19])
    │   ├─ emit Approval(owner: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], spender: DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], value: 10000000000000000000 [1e19])
    │   └─ ← [Return] true
    ├─ [65039] DSCEngine::depositCollateral(0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 10000000000000000000 [1e19])
    │   ├─ emit CollateralDeposited(user: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], token: 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, amount: 10000000000000000000 [1e19])
    │   ├─ [32489] 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496::transferFrom(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], 10000000000000000000 [1e19])
    │   │   ├─ emit Approval(owner: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], spender: DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], value: 0)
    │   │   ├─ emit Transfer(from: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], to: DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], value: 10000000000000000000 [1e19])
    │   │   └─ ← [Return] true
    │   └─ ← [Stop] 
    ├─ [0] VM::stopPrank()
    │   └─ ← [Return] 
    ├─ [76285] DSCEngine::mintDsc(350000000000000000 [3.5e17])
    │   ├─ [14098] OracleLib::staleCheckLastestRoundData() [delegatecall]
    │   │   ├─ [8993] 0x90193C961A926261B756D1E5bb255e67ff9498A1::latestRoundData() [staticcall]
    │   │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   ├─ [14098] OracleLib::staleCheckLastestRoundData() [delegatecall]
    │   │   ├─ [8993] 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3::latestRoundData() [staticcall]
    │   │   │   └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
    │   │   └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
    │   ├─ [0] console::log(0) [staticcall]
    │   │   └─ ← [Stop] 
    │   ├─ [0] console::log(350000000000000000 [3.5e17]) [staticcall]
    │   │   └─ ← [Stop] 
    │   └─ ← [Revert] DSCEngine__BreaksHealthFactor(0)
    └─ ← [Revert] DSCEngine__BreaksHealthFactor(0)

Suite result: FAILED. 0 passed; 1 failed; 0 skipped; finished in 22.08ms (2.41ms CPU time)

Ran 1 test suite in 1.02s (22.08ms CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/unit/DSCEngineTest.t.sol:DSCEngineTest
[FAIL. Reason: DSCEngine__BreaksHealthFactor(0)] testIfLiquidatesCorrectly() (gas: 184559)

Encountered a total of 1 failing tests, 0 tests succeeded
allen@LN08:~/foundry/foundry-defi-stablecoin-f23$ 

[AllenOps08]

Also Here's my DSCEngine

// SPDX-License-Identifier: SEE LICENSE IN LICENSE
pragma solidity 0.8.22;

/*
 * @title DSCEngine
 * @author Allen George 
 *
 * The system is designed to be as minimal as possible, and have the tokens maintain a 1 token == $1 peg at all times.
 * This is a stablecoin with the properties:
 * - Exogenously Collateralized
 * - Dollar Pegged
 * - Algorithmically Stable
 *
 * - It is similar to DAI if DAI had no governance, no fees, and was backed by only WETH and WBTC.
 * 
 * - Our DSC system should always be "overcollateralized". At no point, should the value of
 * all collateral < the $ backed value of all the DSC.
 *
 * - @notice This contract is the core of the Decentralized Stablecoin system. It handles all the logic
 * for minting and redeeming DSC, as well as depositing and withdrawing collateral.
 * @notice This contract is based on the MakerDAO DSS system
 */

import {console} from "forge-std/Script.sol";
import {DecentralizedStableCoin} from "./DecentralizedStableCoin.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
import {AggregatorV3Interface} from "@chainlink/contracts/v0.8/interfaces/AggregatorV3Interface.sol";
import {OracleLib} from "./libraries/OracleLib.sol";

contract DSCEngine is ReentrancyGuard {
    error DSCEngine__NeedsMoreThanZero();
    error DSCEngine__TokenAddressesAndPriceFeedAddressesMustBeSameLength();
    error DSCEngine__NotAllowedToken();
    error DSCEngine__TransferFailed();
    error DSCEngine__BreaksHealthFactor(uint256 healthFactor);
    error DSCEngine__MintFailed();
    error DSCEngine__HealthFactorOk();
    error DSCEngine__HealthFactorNotImproved();

    using OracleLib for AggregatorV3Interface;

    //State variables
    uint256 private constant ADDITIONAL_FEED_PRECISION = 1e10;
    uint256 private constant PRECISION = 1e18;
    uint256 private constant LIQUIDATION_THRESHOLD = 50; // We need to be 200% overcollateralized
    uint256 private constant LIQUIDATION_PRECISION = 100;
    uint256 private constant LIQUIDATION_BONUS = 10; //This means a 10% bonus 10/100
    uint256 public constant MIN_HEALTH_FACTOR = 1e18;

    //200% overcollaterilzation <-> 110% , Safe Zone
    //50% collateralization

    mapping(address token => address priceFeeds) private s_priceFeeds; //tokentoPriceFeed
    mapping(address user => mapping(address => uint256 amount)) private s_collateralDeposited;
    mapping(address user => uint256 amountDscMinted) s_DSCMinted;

    address[] private s_collateralTokens;
    DecentralizedStableCoin private immutable i_dsc;

    //Events
    event CollateralDeposited(address indexed user, address indexed token, uint256 indexed amount);
    event CollateralRedeemed(
        address indexed redeemedFrom, address indexed redeemedTo, address indexed token, uint256 amount
    );

    //Modifiers
    modifier moreThanZero(uint256 amount) {
        if (amount <= 0) {
            revert DSCEngine__NeedsMoreThanZero();
        }
        _;
    }

    modifier isAllowedToken(address token) {
        if (s_priceFeeds[token] == address(0)) {
            revert DSCEngine__NotAllowedToken();
        }
        _;
    }

    //Constructors
    constructor(address[] memory tokenAddresses, address[] memory priceFeedAddresses, address dscAddress) {
        if (tokenAddresses.length != priceFeedAddresses.length) {
            revert DSCEngine__TokenAddressesAndPriceFeedAddressesMustBeSameLength();
        }
        //For example ETH/USD , BTC/USD
        for (uint256 i = 0; i < tokenAddresses.length; i++) {
            s_priceFeeds[tokenAddresses[i]] = priceFeedAddresses[i]; //token of i = pricefeed of i
            s_collateralTokens.push(tokenAddresses[i]);
        }
        i_dsc = DecentralizedStableCoin(dscAddress);
    }

    /*
    * @param tokenCollateralAddress The address of the token to deposit as collateral
    * @param amountCollateral The amount of collateral to deposit
    * @notice this function will deposit your collateral and mint DSC in one transaction
    */

    function depositCollateralAndMintDSC(
        address tokenCollateralAddress,
        uint256 amountCollateral,
        uint256 amountDscToMint
    ) external {
        depositCollateral(tokenCollateralAddress, amountCollateral);
        mintDsc(amountDscToMint);
    }

    /* Notice follows CEI
    * The description of the functions
    * @param tokenCollateralAddress The address of the token to deposit as collateral
    * @param amountCollateral The amount of collateral to deposit
    */

    function depositCollateral(address tokenCollateralAddress, uint256 amountCollateral)
        public
        moreThanZero(amountCollateral)
        isAllowedToken(tokenCollateralAddress)
        nonReentrant //Imp attack in Web3, most functions must be nonRentrant , but it's a bit more gas intensive...
    {
        s_collateralDeposited[msg.sender][tokenCollateralAddress] += amountCollateral;
        emit CollateralDeposited(msg.sender, tokenCollateralAddress, amountCollateral);
        bool success = IERC20(tokenCollateralAddress).transferFrom(msg.sender, address(this), amountCollateral);
        if (!success) {
            revert DSCEngine__TransferFailed();
        }
    }

    /**
     *
     * @param tokenCollateralAddress The collateral address to redeem
     * @param amountCollateral The amount of collateral to redeem
     * @param amountDscToBurn The amount of Dsc to burn
     */
    function redeemCollateralForDsc(address tokenCollateralAddress, uint256 amountCollateral, uint256 amountDscToBurn)
        external
    {
        burnDsc(amountDscToBurn);
        redeemCollateral(tokenCollateralAddress, amountCollateral);
        //redeemCollateral already checks health factor
    }

    //Threshold to let's say 150%
    //$100ETH -> $60 ETH
    //$50 DSC ->
    //Do we need to check if this breaks health factor?

    function burnDsc(uint256 amount) public moreThanZero(amount) {
        _burnDsc(amount, msg.sender, msg.sender);
        _revertIfHealthFactorIsBroken(msg.sender); // I don't think this would ever hit.....
    }

    /**
     * In order to redeem collateral:
     * 1. Health factor must be 1 After collateral is pulled
     * 2. DRY: Don't repeat yourself
     * CEI: Check, Effects, Interactions
     */
    function redeemCollateral(address tokenCollateralAddress, uint256 amountCollateral)
        public
        moreThanZero(amountCollateral)
        nonReentrant
    {
        _redeemCollateral(msg.sender, msg.sender, tokenCollateralAddress, amountCollateral);
        _revertIfHealthFactorIsBroken(msg.sender);
    }

    // $100  -> $20 DSC
    //100(break) If redeem all your eth , it will break your health factor
    // 1. burn DSC
    // 2. Redeem Eth

    /*
     * 
     * @param amountDscToMint The amount of decentralized stablecoin to mint
     * @notice they must have more collateral value than the minimum threshol
     */

    //1. Check if the collateral value is greater than DSC amount. Price feeds
    //People deposits $20ETH --> and want to mint only $20 DSC

    function mintDsc(uint256 amountDscToMint) public moreThanZero(amountDscToMint) nonReentrant {
        s_DSCMinted[msg.sender] += amountDscToMint;
        // If they minted too much ($150 DSC, $100 ETH)
        _revertIfHealthFactorIsBroken(msg.sender);
        bool minted = i_dsc.mint(msg.sender, amountDscToMint);
        if (!minted) {
            revert DSCEngine__MintFailed();
        }
    }

    //If we start nearing undercolateralization, we need someone to liquidate positions
    // $100 ETH backing $50 DSC
    // $20 ETH back $50 <- DSC isn't worth $1 !!
    //$75 backing $50 DSC
    //liquidator take $75 backing and burns off the $50 DSC
    //If someone is almost undercollateralized, we will pay you to liquidate them!

    /**
     *
     * @param collateral The ERC20 collateral address to liquidate
     * @param user The user who has broken the health factor. Their _healthFactor should be below MIN_HEALTH_FACTOR ..Value Of Collaterals/Value Of borrowed assets
     * @param debtToCover The amount of DSC you want to burn to improve the users health factor
     * @notice You can partially liquidate a user.
     * @notice You will get a liquidation bonus for taking the users funds
     * @notice This function working assumes the protocol will be roughly 200% overcolletralized
     * @notice A known bug would be if the protocol were 100% or less collateralized, then we wouldn't be able to incentivize the liquidators.
     * For example, if the price of the collateral plummeted before anyone could be liquidated
     * Follows CEI: Checks, Effects, Interactions
     */
    function liquidate(address collateral, address user, uint256 debtToCover)
        external
        moreThanZero(debtToCover)
        nonReentrant
    {
        // If health factor is perfect
        uint256 startingUserHealthFactor = _healthFactor(user);
        if (startingUserHealthFactor >= MIN_HEALTH_FACTOR) {
            revert DSCEngine__HealthFactorOk();
        }
        //We want to burn their DSC "debt" and take their collateral
        //Bad user: $140 ETH, $100 DSC
        // $100 of DSC = ??ETH
        // 0.05 ETH
        uint256 tokenAmountFromDebtCovered = getTokenAmountFromUsd(collateral, debtToCover);
        // And give them a 10% bonus
        // So we are giving the liquidator $110 of WETH for 100 DSC
        //We should implement a feature to liquidate in the event the protocol is insolvent
        // And sweep extra amounts into a treasury

        //0.05 ETH * .1 = 0.005 ETH. Get 0.055 ETH
        uint256 bonusCollateral = (tokenAmountFromDebtCovered * LIQUIDATION_BONUS) / LIQUIDATION_PRECISION;
        uint256 totalCollateralToRedeem = tokenAmountFromDebtCovered + bonusCollateral;
        _redeemCollateral(user, msg.sender, collateral, totalCollateralToRedeem);
        // We need to burn the dsc
        _burnDsc(debtToCover, user, msg.sender);

        uint256 endingUserHealthFactor = _healthFactor(user);
        if (endingUserHealthFactor <= startingUserHealthFactor) {
            revert DSCEngine__HealthFactorNotImproved();
        }
        _revertIfHealthFactorIsBroken(msg.sender);
    }

    /*//////////////////////////////////////////////////////////////
                     PRIVATE AND INTERNAL  VIEW FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    /**
     *
     * @param amountDscToBurn Amount of dsc to burn
     * @param onBehalfOf Who gets it
     * @param dscFrom Wh
     * @dev Low level internal function , do not call unless the function calling it is checking for health factors for being broken
     */
    function _burnDsc(uint256 amountDscToBurn, address onBehalfOf, address dscFrom) private {
        s_DSCMinted[onBehalfOf] -= amountDscToBurn;
        bool success = i_dsc.transferFrom(dscFrom, address(this), amountDscToBurn);
        //Hypothetically unreachable as
        if (!success) {
            revert DSCEngine__TransferFailed();
        }
        i_dsc.burn(amountDscToBurn);
    }

    function _redeemCollateral(address from, address to, address tokenCollateralAddress, uint256 amountCollateral)
        private
    {
        s_collateralDeposited[from][tokenCollateralAddress] -= amountCollateral;
        emit CollateralRedeemed(from, to, tokenCollateralAddress, amountCollateral);
        bool success = IERC20(tokenCollateralAddress).transfer(to, amountCollateral);
        if (!success) {
            revert DSCEngine__TransferFailed();
        }
    }

    function _healthFactor(address user) private view returns (uint256) {
        //Get total DSC minted , get total collateral value
        (uint256 totalDSCMinted, uint256 collateralValueInUsd) = _getAccountInformation(user);
        if (totalDSCMinted == 0) revert DSCEngine__HealthFactorOk(); //This means no debt
        uint256 collateralAdjustedForThreshold = (collateralValueInUsd * LIQUIDATION_THRESHOLD) / LIQUIDATION_PRECISION;
        console.log(collateralValueInUsd);
        console.log(totalDSCMinted);
        return (collateralAdjustedForThreshold * PRECISION) / totalDSCMinted; //If this is <1 you will get liquidated
            //1000 ETH*50 = 50000/100 = 500
            // $150 ETH / 100 DSC = 1.5
            // 150*50 = 7500/100 = (75/100) = 0.75
            // return (collateralValueInUsd / totalDSCMinted); //(150/100) , if we go down a penny we'll be under collateralized..Thus set the threshold higher, like 150 so that under 150 you'' get liquidated
    }

    function _revertIfHealthFactorIsBroken(address user) internal view {
        //1. Check health factor , check aave documentation..Revert if the don't
        uint256 userHealthFactor = _healthFactor(user);
        if (userHealthFactor < MIN_HEALTH_FACTOR) {
            revert DSCEngine__BreaksHealthFactor(userHealthFactor);
        }
    }

    function _getAccountInformation(address user)
        private
        view
        returns (uint256 totalDSCMinted, uint256 collateralValueInUSD)
    {
        totalDSCMinted = s_DSCMinted[user];
        collateralValueInUSD = _getAccountCollateralValueInUsd(user);
    }

    /*//////////////////////////////////////////////////////////////
                     PUBLIC AND EXTERNAL VIEW FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    function getTokenAmountFromUsd(address token, uint256 usdAmountInWei) public view returns (uint256) {
        //price of ETH(token)
        // $/ETH ETH??
        // $2000 / ETH ,We have $1000... = 0.5 ETH i.e usdAmountInWei/Price
        AggregatorV3Interface priceFeed = AggregatorV3Interface(s_priceFeeds[token]);
        (, int256 price,,,) = priceFeed.latestRoundData();
        // ($10e18*1e18)/ ($2000e18*1e10)

        return (usdAmountInWei * PRECISION) / (uint256(price) * ADDITIONAL_FEED_PRECISION);
    }

    function _getAccountCollateralValueInUsd(address user) public view returns (uint256 totalCollateralValueInUsd) {
        //loop through each collateral token, get the amount they deposited and map it to the price, to get the USD

        for (uint256 i = 0; i < s_collateralTokens.length; i++) {
            address token = s_collateralTokens[i];
            uint256 amount = s_collateralDeposited[user][token];
            totalCollateralValueInUsd += getUsdInValue(token, amount);
        }
        return totalCollateralValueInUsd;
    }

    function getUsdInValue(address token, uint256 amount) public view returns (uint256) {
        AggregatorV3Interface priceFeed = AggregatorV3Interface(s_priceFeeds[token]);
        (, int256 price,,,) = priceFeed.staleCheckLastestRoundData();

        //1 ETH = $1000
        // The returned value from CL will be 1000*1e18
        return ((uint256(price) * ADDITIONAL_FEED_PRECISION) * amount) / PRECISION; //(1000*1e8)*(1e10)*1000*1e18;
    }

    function getAccountInformation(address user)
        external
        view
        returns (uint256 totalDscMinted, uint256 collateralValueInUsd)
    {
        (totalDscMinted, collateralValueInUsd) = _getAccountInformation(user);
    }

    function getCollateralTokens() external view returns (address[] memory) {
        return s_collateralTokens;
    }

    function getCollateralTokensPriceFeed(address token) external view returns (address) {
        return s_priceFeeds[token];
    }

    function getCollateralBalanceOfUser(address user, address token) external view returns (uint256 balance) {
        return s_collateralDeposited[user][token];
    }

    function getPrecision() external pure returns (uint256) {
        return PRECISION;
    }

    function getLiquidationBonus() external pure returns (uint256) {
        return LIQUIDATION_BONUS;
    }

    function getHealthFactor(address user) external view returns (uint256) {
        return _healthFactor(user);
    }

    function getLiquidationThreshold() external pure returns (uint256) {
        return LIQUIDATION_THRESHOLD;
    }

    function getLiquidationPrecision() external pure returns (uint256) {
        return LIQUIDATION_PRECISION;
    }

    function getTokenAddress(address tokenId) external view returns (address) {
        return s_priceFeeds[tokenId];
    }

}

[EngrPips]

You pranked USER here and deposited collateral by USER

modifier depositedCollateral() {
        vm.startPrank(USER);
        ERC20Mock(weth).approve(address(dsce), AMOUNT_COLLATERAL);
        dsce.depositCollateral(weth, AMOUNT_COLLATERAL);
        vm.stopPrank();
        _;
    }

And then you come inside here and didnt prank USER when you call the the mintDSC function on the dsce contract meaning you are minting to the test contract.

function testIfLiquidatesCorrectly() public depositedCollateral {
        //Setup , done
        //Provide collateral and mint dsc for the user , done
        dsce.mintDsc(DEBT_AMOUNT/20);

        //Check health factor
        uint256 userHealthFactor = dsce.getHealthFactor(USER);
        assertLt(userHealthFactor, dsce.MIN_HEALTH_FACTOR());

        //Prepare the liquidator
        vm.startPrank(liquidator);
        uint256 debtToCover = DEBT_AMOUNT/4;
        uint256 liquidatorCollateral = 10 ether;
        ERC20Mock(weth).mint(liquidator, debtToCover);
        ERC20Mock(weth).approve(address(dsce), debtToCover);
        // Deposit more collateral than the debt to ensure a good health factor
        dsce.depositCollateralAndMintDSC(weth, liquidatorCollateral, debtToCover);
        dsc.approve(address(dsce), debtToCover);

        //Record balances after liquidation
        uint256 liquidatorWethBefore = ERC20Mock(weth).balanceOf(liquidator);
        uint256 liquidatorDscBefore = dsc.balanceOf(liquidator);
        uint256 userWethBefore = ERC20Mock(weth).balanceOf(USER);
        uint256 userDscBefore = dsc.balanceOf(USER);

        //Perform liquidation
        dsce.liquidate(liquidator, USER, debtToCover);
        vm.stopPrank();

        //Check balances after liquidation
        uint256 liquidatorWethAfter = ERC20Mock(weth).balanceOf(liquidator);
        uint256 liquidatorDscAfter = dsc.balanceOf(liquidator);
        uint256 userWethAfter = ERC20Mock(weth).balanceOf(USER);
        uint256 userDscAfter = dsc.balanceOf(USER);

        assertLt(liquidatorWethAfter, liquidatorWethBefore, "Liquidator WETH should decrease");
        assertGt(liquidatorDscAfter, liquidatorDscBefore, "Liquidator DSC amount should increase");
        assertLt(userWethAfter, userWethBefore, "User WETH should decrease");
        assertEq(userDscAfter, userDscBefore - debtToCover, "User DSC should decrease by debtToCover");

        //Check health factor improvement
         uint256 userHealthFactorAfter = dsce.getHealthFactor(USER);
        assertGt(userHealthFactorAfter, userHealthFactor, "User health factor should improve");
    }

If anything is confusing please ask questions @AllenOps08.

[AllenOps08]

Yes...Got another error..

allen@LN08:~/foundry/foundry-defi-stablecoin-f23$ forge test --mt testIfLiquidatesCorrectly -vvvv
[⠒] Compiling...
No files changed, compilation skipped

Ran 1 test for test/unit/DSCEngineTest.t.sol:DSCEngineTest
[FAIL. Reason: assertion failed: 714285714285714285714 >= 1000000000000000000] testIfLiquidatesCorrectly() (gas: 330050)
Logs:
  20000000000000000000000
  7000000000000000000
  10000000000000000000000
  7000000000000000000

Traces:
  [10879141] DSCEngineTest::setUp()
    ├─ [4895272] → new DeployDSC@0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f
    │   └─ ← [Return] 24337 bytes of code
    ├─ [5732410] DeployDSC::run()
    │   ├─ [3746933] → new <unknown>@0x104fBc016F4bb334D775a19E8A6510109AC63E00
    │   │   ├─ [0] VM::startBroadcast()
    │   │   │   └─ ← [Return] 
    │   │   ├─ [372455] → new <unknown>@0x90193C961A926261B756D1E5bb255e67ff9498A1
    │   │   │   └─ ← [Return] 1083 bytes of code
    │   │   ├─ [658896] → new <unknown>@0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496
    │   │   │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: DeployDSC: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f], value: 100000000000 [1e11])
    │   │   │   └─ ← [Return] 2829 bytes of code
    │   │   ├─ [372455] → new <unknown>@0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3
    │   │   │   └─ ← [Return] 1083 bytes of code
    │   │   ├─ [658896] → new <unknown>@0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76
    │   │   │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: DeployDSC: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f], value: 100000000000 [1e11])
    │   │   │   └─ ← [Return] 2829 bytes of code
    │   │   ├─ [0] VM::stopBroadcast()
    │   │   │   └─ ← [Return] 
    │   │   └─ ← [Return] 6970 bytes of code
    │   ├─ [912] 0x104fBc016F4bb334D775a19E8A6510109AC63E00::activeNetworkConfig() [staticcall]
    │   │   └─ ← [Return] 0x90193C961A926261B756D1E5bb255e67ff9498A1, 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3, 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76, 77814517325470205911140941194401928579557062014761831930645393041380819009408 [7.781e76]
    │   ├─ [0] VM::startBroadcast(<pk>)
    │   │   └─ ← [Return] 
    │   ├─ [750023] → new <unknown>@0x5FbDB2315678afecb367f032d93F642f64180aa3
    │   │   ├─ emit OwnershipTransferred(previousOwner: 0x0000000000000000000000000000000000000000, newOwner: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266)
    │   │   └─ ← [Return] 3402 bytes of code
    │   ├─ [994598] → new DSCEngine@0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512
    │   │   └─ ← [Return] 4290 bytes of code
    │   ├─ [2446] 0x5FbDB2315678afecb367f032d93F642f64180aa3::transferOwnership(DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512])
    │   │   ├─ emit OwnershipTransferred(previousOwner: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266, newOwner: DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512])
    │   │   └─ ← [Stop] 
    │   ├─ [0] VM::stopBroadcast()
    │   │   └─ ← [Return] 
    │   └─ ← [Return] 0x5FbDB2315678afecb367f032d93F642f64180aa3, DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], 0x104fBc016F4bb334D775a19E8A6510109AC63E00
    ├─ [912] 0x104fBc016F4bb334D775a19E8A6510109AC63E00::activeNetworkConfig() [staticcall]
    │   └─ ← [Return] 0x90193C961A926261B756D1E5bb255e67ff9498A1, 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3, 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76, 77814517325470205911140941194401928579557062014761831930645393041380819009408 [7.781e76]
    ├─ [24728] 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496::mint(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], 10000000000000000000 [1e19])
    │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], value: 10000000000000000000 [1e19])
    │   └─ ← [Stop] 
    ├─ [271] DSCEngine::getLiquidationThreshold() [staticcall]
    │   └─ ← [Return] 50
    ├─ [226] DSCEngine::getLiquidationPrecision() [staticcall]
    │   └─ ← [Return] 100
    └─ ← [Stop] 

  [299750] DSCEngineTest::testIfLiquidatesCorrectly()
    ├─ [0] VM::startPrank(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D])
    │   └─ ← [Return] 
    ├─ [24651] 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496::approve(DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], 10000000000000000000 [1e19])
    │   ├─ emit Approval(owner: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], spender: DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], value: 10000000000000000000 [1e19])
    │   └─ ← [Return] true
    ├─ [65039] DSCEngine::depositCollateral(0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 10000000000000000000 [1e19])
    │   ├─ emit CollateralDeposited(user: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], token: 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, amount: 10000000000000000000 [1e19])
    │   ├─ [32489] 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496::transferFrom(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], 10000000000000000000 [1e19])
    │   │   ├─ emit Approval(owner: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], spender: DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], value: 0)
    │   │   ├─ emit Transfer(from: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], to: DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], value: 10000000000000000000 [1e19])
    │   │   └─ ← [Return] true
    │   └─ ← [Stop] 
    ├─ [0] VM::stopPrank()
    │   └─ ← [Return] 
    ├─ [0] VM::startPrank(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D])
    │   └─ ← [Return] 
    ├─ [126266] DSCEngine::mintDsc(7000000000000000000 [7e18])
    │   ├─ [14098] OracleLib::staleCheckLastestRoundData() [delegatecall]
    │   │   ├─ [8993] 0x90193C961A926261B756D1E5bb255e67ff9498A1::latestRoundData() [staticcall]
    │   │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   ├─ [14098] OracleLib::staleCheckLastestRoundData() [delegatecall]
    │   │   ├─ [8993] 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3::latestRoundData() [staticcall]
    │   │   │   └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
    │   │   └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
    │   ├─ [0] console::log(20000000000000000000000 [2e22]) [staticcall]
    │   │   └─ ← [Stop] 
    │   ├─ [0] console::log(7000000000000000000 [7e18]) [staticcall]
    │   │   └─ ← [Stop] 
    │   ├─ [48965] 0x5FbDB2315678afecb367f032d93F642f64180aa3::mint(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], 7000000000000000000 [7e18])
    │   │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], value: 7000000000000000000 [7e18])
    │   │   └─ ← [Return] true
    │   └─ ← [Stop] 
    ├─ [0] VM::stopPrank()
    │   └─ ← [Return] 
    ├─ [77404] 0x90193C961A926261B756D1E5bb255e67ff9498A1::updateAnswer(100000000000 [1e11])
    │   └─ ← [Stop] 
    ├─ [13038] DSCEngine::getHealthFactor(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D]) [staticcall]
    │   ├─ [3598] OracleLib::staleCheckLastestRoundData() [delegatecall]
    │   │   ├─ [993] 0x90193C961A926261B756D1E5bb255e67ff9498A1::latestRoundData() [staticcall]
    │   │   │   └─ ← [Return] 2, 100000000000 [1e11], 1, 1, 2
    │   │   └─ ← [Return] 2, 100000000000 [1e11], 1, 1, 2
    │   ├─ [3598] OracleLib::staleCheckLastestRoundData() [delegatecall]
    │   │   ├─ [993] 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3::latestRoundData() [staticcall]
    │   │   │   └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
    │   │   └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
    │   ├─ [0] console::log(10000000000000000000000 [1e22]) [staticcall]
    │   │   └─ ← [Stop] 
    │   ├─ [0] console::log(7000000000000000000 [7e18]) [staticcall]
    │   │   └─ ← [Stop] 
    │   └─ ← [Return] 714285714285714285714 [7.142e20]
    ├─ [273] DSCEngine::MIN_HEALTH_FACTOR() [staticcall]
    │   └─ ← [Return] 1000000000000000000 [1e18]
    ├─ [0] VM::assertLt(714285714285714285714 [7.142e20], 1000000000000000000 [1e18]) [staticcall]
    │   └─ ← [Revert] assertion failed: 714285714285714285714 >= 1000000000000000000
    └─ ← [Revert] assertion failed: 714285714285714285714 >= 1000000000000000000

Suite result: FAILED. 0 passed; 1 failed; 0 skipped; finished in 12.72ms (2.43ms CPU time)

Ran 1 test suite in 962.22ms (12.72ms CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/unit/DSCEngineTest.t.sol:DSCEngineTest
[FAIL. Reason: assertion failed: 714285714285714285714 >= 1000000000000000000] testIfLiquidatesCorrectly() (gas: 330050)

Encountered a total of 1 failing tests, 0 tests succeeded
allen@LN08:~/foundry/foundry-defi-stablecoin-f23$ 

Tried to refractor the code a bit....

// SPDX-License-Identifier: SEE LICENSE IN LICENSE
pragma solidity 0.8.22;

import {Test, console} from "forge-std/Test.sol";
import {DeployDSC} from "script/DeployDSC.s.sol";
import {DecentralizedStableCoin} from "src/DecentralizedStableCoin.sol";
import {DSCEngine} from "src/DSCEngine.sol";
import {HelperConfig} from "script/HelperConfig.s.sol";
import {ERC20Mock} from "@openzeppelin/contracts/mocks/ERC20Mock.sol";
import {VmSafe} from "lib/forge-std/src/Vm.sol";
import {MockV3Aggregator} from "../mocks/MockV3Aggregator.sol";

contract DSCEngineTest is Test {
    DeployDSC deployer;
    DecentralizedStableCoin dsc;
    DSCEngine dsce;
    HelperConfig config;
    address ethUsdPriceFeed;
    address btcUsdPriceFeed;
    address weth;
    address public USER = makeAddr("user");
    address liquidator = makeAddr("liquidator");
    uint256 public constant AMOUNT_COLLATERAL = 10 ether;
    uint256 DEBT_AMOUNT = 7 ether;
    uint256 public constant STARTING_ERC20_BALANCE = 10 ether;

    uint256 public LIQUIDATION_THRESHOLD;
    uint256 public LIQUIDATION_PRECISION;

    function setUp() public {
        deployer = new DeployDSC();
        (dsc, dsce, config) = deployer.run();
        (ethUsdPriceFeed, btcUsdPriceFeed, weth,,) = config.activeNetworkConfig();

        ERC20Mock(weth).mint(USER, STARTING_ERC20_BALANCE);

        LIQUIDATION_THRESHOLD = dsce.getLiquidationThreshold();
        LIQUIDATION_PRECISION = dsce.getLiquidationPrecision(); //Initialize things in the constructor
    }

    /*//////////////////////////////////////////////////////////////
                        CONSTRUCTOR TESTS 
    //////////////////////////////////////////////////////////////*/

    address[] public tokenAddresses;
    address[] public priceFeedAddresses;

    function testRevertsIfTokenLengthDoesntMatchPriceFeeds() public {
        tokenAddresses.push(weth);
        priceFeedAddresses.push(ethUsdPriceFeed);
        priceFeedAddresses.push(btcUsdPriceFeed);

        vm.expectRevert(DSCEngine.DSCEngine__TokenAddressesAndPriceFeedAddressesMustBeSameLength.selector);
        new DSCEngine(tokenAddresses, priceFeedAddresses, address(dsc));
    }

    /*//////////////////////////////////////////////////////////////
                              PRICE TESTS
    //////////////////////////////////////////////////////////////*/

    function testGetUsdInValue() public view {
        uint256 ethAmount = 15e18;
        //15e18 = 2000/ETH = 30000e18 Because 1 ETH equals $2000
        uint256 expectedUsd = 30000e18;
        uint256 actualUsd = dsce.getUsdInValue(weth, ethAmount);
        assertEq(expectedUsd, actualUsd);
    }

    function testGetTokenAmountFromUsd() public view {
        uint256 usdAmount = 100 ether;
        // $2000/ETH , $100 , wEth = 100/2000
        uint256 expectedWeth = 0.05 ether;
        uint256 actualWeth = dsce.getTokenAmountFromUsd(weth, usdAmount);
        assertEq(expectedWeth, actualWeth);
    }

    /*//////////////////////////////////////////////////////////////
                           DEPOSIT COLLATERAL
    //////////////////////////////////////////////////////////////*/

    function testRevertsIfCollateralZero() public {
        vm.startPrank(USER);
        ERC20Mock(weth).approve(address(dsce), AMOUNT_COLLATERAL);

        vm.expectRevert(DSCEngine.DSCEngine__NeedsMoreThanZero.selector);
        dsce.depositCollateral(weth, 0);
        vm.stopPrank();
    }

    function testRevertsWithUnapprovedCollateral() public {
        ERC20Mock ranToken = new ERC20Mock("RAN", "RAN", USER, AMOUNT_COLLATERAL);
        vm.startPrank(USER);
        vm.expectRevert(DSCEngine.DSCEngine__NotAllowedToken.selector);
        dsce.depositCollateral(address(ranToken), AMOUNT_COLLATERAL);
        vm.stopPrank();
    }

    //Test reentrancy too

    modifier depositedCollateral() {
        vm.startPrank(USER);
        ERC20Mock(weth).approve(address(dsce), AMOUNT_COLLATERAL);
        dsce.depositCollateral(weth, AMOUNT_COLLATERAL);
        vm.stopPrank();
        _;
    }

    function testDepositCollateralAndMintDsc() public depositedCollateral {
        vm.startPrank(address(dsce));
        uint256 amountToMint = 1e18;
        dsc.mint(address(dsce), amountToMint);
        uint256 balance = dsc.balanceOf(address(dsce));
        assertEq(balance, amountToMint);
        vm.stopPrank();
    }

    function testCanDepositCollateralAndGetAccountInfo() public depositedCollateral {
        (uint256 totalDscMinted, uint256 collateralValueInUsd) = dsce.getAccountInformation(USER);
        uint256 expectedTotalDscMinted = 0;
        //10 ether*2000 = $20000
        uint256 expectedDepositAmount = dsce.getTokenAmountFromUsd(weth, collateralValueInUsd);
        assertEq(totalDscMinted, expectedTotalDscMinted);
        assertEq(expectedDepositAmount, AMOUNT_COLLATERAL);
    }

    function testRedeemCollateralForDsc() public depositedCollateral {
        //Start the prank for the USER
        vm.startPrank(USER);

        //Mint some DSC first
        uint256 amountToMint = 1e18;
        dsce.mintDsc(amountToMint);

        //Get the initial balances
        uint256 initialDscBalance = dsc.balanceOf(USER);
        uint256 initialCollateralBalance = ERC20Mock(weth).balanceOf(USER);

        //Calculate the amount to collateral to redeem
        uint256 collateralToRedeem = 1 ether;

        //Approve DSCEngine to spend user's DSC
        dsc.approve(address(dsce), amountToMint);

        dsce.redeemCollateralForDsc(weth, collateralToRedeem, amountToMint);

        //Get updated balances
        uint256 updatedDscBalance = dsc.balanceOf(USER);
        uint256 updatedCollateralBalance = ERC20Mock(weth).balanceOf(USER);
        vm.stopPrank();

        assertEq(updatedDscBalance, initialDscBalance - amountToMint);
        assertEq(updatedCollateralBalance, initialCollateralBalance + collateralToRedeem);
    }

    function testIfRevertsIfHealthFactorIsBroken() public depositedCollateral {
        //Calculating the maximum amount of DSC that can be minted
        (, uint256 collateralValueInUsd) = dsce.getAccountInformation(USER);
        uint256 maxDscToMint = collateralValueInUsd * dsce.getLiquidationThreshold() / dsce.getLiquidationPrecision();

        //Attempt to mint slightly more than the maximum allowed
        uint256 amountToMint = maxDscToMint + 1;
        vm.startPrank(USER);

        //This should revert due to broken health factor
        vm.expectRevert(abi.encodeWithSelector(DSCEngine.DSCEngine__BreaksHealthFactor.selector, 999999999999999999));
        dsce.mintDsc(amountToMint);

        vm.stopPrank();
    }

    //Write these tests yourself, you might need to refractor some code

    /*//////////////////////////////////////////////////////////////
                               LIQUIDATE
    //////////////////////////////////////////////////////////////*/

    function testIfLiquidatesCorrectly() public depositedCollateral {
        //Setup , done
        //Provide collateral and mint dsc for the user , done
        vm.startPrank(USER);
        dsce.mintDsc(DEBT_AMOUNT);
        vm.stopPrank();

        //Manipulating the price feed to create a liquidable position
        MockV3Aggregator(ethUsdPriceFeed).updateAnswer(100000000000);

        //Check health factor
        uint256 userHealthFactor = dsce.getHealthFactor(USER);
        assertLt(userHealthFactor, dsce.MIN_HEALTH_FACTOR());

        //Prepare the liquidator
        vm.startPrank(liquidator);
        uint256 debtToCover = DEBT_AMOUNT /2;
        uint256 liquidatorCollateral = 10 ether;
        ERC20Mock(weth).mint(liquidator, liquidatorCollateral);
        ERC20Mock(weth).approve(address(dsce), liquidatorCollateral);
        // Deposit more collateral than the debt to ensure a good health factor
        dsce.depositCollateralAndMintDSC(weth, liquidatorCollateral, debtToCover);
        dsc.approve(address(dsce), debtToCover);

        //Record balances after liquidation
        uint256 liquidatorWethBefore = ERC20Mock(weth).balanceOf(liquidator);
        uint256 liquidatorDscBefore = dsc.balanceOf(liquidator);
        uint256 userWethBefore = ERC20Mock(weth).balanceOf(USER);
        uint256 userDscBefore = dsc.balanceOf(USER);

        //Perform liquidation
        dsce.liquidate(weth, USER, debtToCover);
        vm.stopPrank();

        //Check balances after liquidation
        uint256 liquidatorWethAfter = ERC20Mock(weth).balanceOf(liquidator);
        uint256 liquidatorDscAfter = dsc.balanceOf(liquidator);
        uint256 userWethAfter = ERC20Mock(weth).balanceOf(USER);
        uint256 userDscAfter = dsc.balanceOf(USER);

        assertGt(liquidatorWethAfter, liquidatorWethBefore, "Liquidator WETH should increase");
        assertGt(liquidatorDscAfter, liquidatorDscBefore, "Liquidator DSC amount should increase");
        assertLt(userWethAfter, userWethBefore, "User WETH should decrease");
        assertEq(userDscAfter, userDscBefore - debtToCover, "User DSC should decrease by debtToCover");

        //Check health factor improvement
        uint256 userHealthFactorAfter = dsce.getHealthFactor(USER);
        assertGt(userHealthFactorAfter, userHealthFactor, "User health factor should improve");
    }
}

[EngrPips]

A different error means you are making progress. Now, you need to go through your test step by step to discover why your assert reverted.