test: draft

contracts/mocks/IrmMock.sol

@@ -9,15 +9,21 @@ import {MathLib} from "@morpho-blue/libraries/MathLib.sol";
 contract IrmMock is IIrm {
     using MathLib for uint128;
 
-    function borrowRateView(MarketParams memory, Market memory market) public pure returns (uint256) {
+    uint256 public rate;
+
+    function setRate(uint256 newRate) external {
+        rate = newRate;
+    }
+
+    function borrowRateView(MarketParams memory, Market memory market) public view returns (uint256) {
         uint256 utilization = market.totalBorrowAssets.wDivDown(market.totalSupplyAssets);
 
         // Divide by the number of seconds in a year.
         // This is a very simple model where x% utilization corresponds to x% APR.
-        return utilization / 365 days;
+        return rate == 0 ? utilization / 365 days : rate / 365 days;
     }
 
-    function borrowRate(MarketParams memory marketParams, Market memory market) external pure returns (uint256) {
+    function borrowRate(MarketParams memory marketParams, Market memory market) external view returns (uint256) {
         return borrowRateView(marketParams, market);
     }
 }

test/forge/BaseTest.sol

@@ -31,9 +31,10 @@ contract BaseTest is Test {
     address internal ONBEHALF = _addrFromHashedString("Morpho On Behalf");
     address internal RECEIVER = _addrFromHashedString("Morpho Receiver");
     address internal LIQUIDATOR = _addrFromHashedString("Morpho Liquidator");
-    address internal OWNER = _addrFromHashedString("Morpho Owner");
-    address internal RISK_MANAGER = _addrFromHashedString("Morpho Risk Manager");
-    address internal ALLOCATOR = _addrFromHashedString("Morpho Allocator");
+    address internal OWNER = _addrFromHashedString("Owner");
+    address internal RISK_MANAGER = _addrFromHashedString("Risk Manager");
+    address internal ALLOCATOR = _addrFromHashedString("Allocator");
+    address internal FEE_RECIPIENT = _addrFromHashedString("Fee Recipient");
 
     uint256 internal constant LLTV = 0.8 ether;
     uint256 internal constant TIMELOCK = 0;
@@ -131,4 +132,14 @@ contract BaseTest is Test {
         vault.enableMarket(params.id());
         vm.stopPrank();
     }
+
+    function _borrow(MarketParams memory params, uint256 amount) internal {
+        deal(address(collateralToken), BORROWER, type(uint256).max);
+
+        vm.startPrank(BORROWER);
+        collateralToken.approve(address(morpho), type(uint256).max);
+        morpho.supplyCollateral(params, type(uint128).max, BORROWER, hex"");
+        morpho.borrow(params, amount, 0, BORROWER, BORROWER);
+        vm.stopPrank();
+    }
 }

test/forge/FeeTest.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.0;
+
+import "./BaseTest.sol";
+
+contract FeeTest is BaseTest {
+    using MarketParamsLib for MarketParams;
+
+    uint256 internal constant FEE = 0.1 ether; // 10%
+
+    function setUp() public override {
+        super.setUp();
+
+        _submitAndEnableMarket(allMarkets[0], CAP);
+
+        irm.setRate(0.1 ether); // 10% APY.
+    }
+
+    function _setFee() internal {
+        vm.startPrank(OWNER);
+        vault.submitPendingFee(FEE);
+        vault.setFee();
+        vault.setFeeRecipient(FEE_RECIPIENT);
+        vm.stopPrank();
+    }
+
+    function testShouldMintSharesToFeeRecipient(uint256 amount) public {
+        _setFee();
+
+        amount = bound(amount, MIN_TEST_AMOUNT, MAX_TEST_AMOUNT);
+
+        vm.prank(SUPPLIER);
+        uint256 shares = vault.deposit(amount, SUPPLIER);
+
+        _borrow(allMarkets[0], amount / 2);
+
+        vm.warp(block.timestamp + 365 days);
+
+        vm.prank(SUPPLIER);
+        vault.redeem(shares / 3, SUPPLIER, SUPPLIER);
+
+        assertGt(vault.balanceOf(FEE_RECIPIENT), 0, "fee recipient balance is zero");
+    }
+}

test/forge/VaultSeveralMarketsTest.sol

@@ -202,16 +202,6 @@ contract VaultSeveralMarketsTest is BaseTest {
         _assertBalances(cap, amount - toWithdraw);
     }
 
-    function _borrow(MarketParams memory marketParams, uint256 amount) internal {
-        deal(address(collateralToken), BORROWER, type(uint256).max);
-
-        vm.startPrank(BORROWER);
-        collateralToken.approve(address(morpho), type(uint256).max);
-        morpho.supplyCollateral(marketParams, type(uint128).max, BORROWER, hex"");
-        morpho.borrow(marketParams, amount, 0, BORROWER, BORROWER);
-        vm.stopPrank();
-    }
-
     function testWithdrawSeveralMarketsWithLessLiquidity(uint128 cap, uint256 toWithdraw, uint256 borrowed) public {
         cap = uint128(bound(cap, MIN_TEST_AMOUNT, MAX_TEST_AMOUNT));
         uint256 amount = 3 * cap;