Test case optimization

test/camelot/Demeter_CamelotFarm.t.sol

@@ -141,7 +141,7 @@ contract Demeter_CamelotFarmTest is BaseFarmTest {
         return camelotProxy;
     }
 
-    function test_initialize_RevertWhen_camelotPairIsZero() public {
+    function test_RevertWhen_camelotPairIsZero() public {
         address farm = createFarmImplementation();
         address[] memory rewardToken = rwdTokens;
         RewardTokenData[] memory rwdTokenData = new RewardTokenData[](rewardToken.length);
@@ -153,20 +153,59 @@ contract Demeter_CamelotFarmTest is BaseFarmTest {
             FARM_ID, block.timestamp, 0, address(factory), address(0), rwdTokenData, ROUTER, NFT_POOL_FACTORY
         );
     }
+}
+
+contract OnERC721ReceivedTest is Demeter_CamelotFarmTest {
+    using SafeERC20 for IERC20;
 
-    function test_OnERC721Received_RevertWhen_NotACamelotNFT() public {
+    // Deposit test
+    function test_onERC721Received() public useKnownActor(user) {
+        address farm;
+        bool lockup;
+        for (uint8 j; j < 2; ++j) {
+            lockup = j == 0 ? true : false;
+            farm = lockup ? lockupFarm : nonLockupFarm;
+            uint256 amt1 = 1e3 * 10 ** ERC20(DAI).decimals();
+            deal(DAI, user, amt1);
+            uint256 amt2 = 1e3 * 10 ** ERC20(USDCe).decimals();
+            deal(USDCe, user, amt2);
+            IERC20(DAI).forceApprove(POSITION_HELPER, amt1);
+            IERC20(USDCe).forceApprove(POSITION_HELPER, amt2);
+            IPositionHelper(POSITION_HELPER).addLiquidityAndCreatePosition(
+                DAI, USDCe, amt1, amt2, amt1 / 10, amt2 / 10, block.timestamp, user, INFTPool(getPoolAddress()), 0
+            );
+            uint256 tokenId = INFTPool(getPoolAddress()).lastTokenId();
+            (uint256 liquidity,,,,,,,) = INFTPool(getPoolAddress()).getStakingPosition(tokenId);
+            if (!lockup) {
+                vm.expectEmit(address(farm));
+                emit PoolSubscribed(BaseFarm(farm).totalDeposits() + 1, 0);
+            } else {
+                vm.expectEmit(address(farm));
+                emit PoolSubscribed(BaseFarm(farm).totalDeposits() + 1, 0);
+                vm.expectEmit(address(farm));
+                emit PoolSubscribed(BaseFarm(farm).totalDeposits() + 1, 1);
+            }
+            vm.expectEmit(address(farm));
+            emit Deposited(BaseFarm(farm).totalDeposits() + 1, currentActor, lockup, liquidity);
+            IERC721(getPoolAddress()).safeTransferFrom(user, farm, tokenId, abi.encode(lockup));
+        }
+    }
+
+    function test_RevertWhen_NotACamelotNFT() public {
         vm.expectRevert(abi.encodeWithSelector(Demeter_CamelotFarm.NotACamelotNFT.selector));
         Demeter_CamelotFarm(lockupFarm).onERC721Received(address(0), address(0), 0, "");
     }
 
-    function test_OnERC721Received_RevertWhen_NoData() public {
+    function test_RevertWhen_NoData() public {
         address nftPool = Demeter_CamelotFarm(lockupFarm).nftPool();
         vm.startPrank(nftPool);
         vm.expectRevert(abi.encodeWithSelector(Demeter_CamelotFarm.NoData.selector));
         Demeter_CamelotFarm(lockupFarm).onERC721Received(address(0), address(0), 0, "");
     }
+}
 
-    function test_onNFTHarvest_RevertWhen_notNftPool() public {
+contract OnNFTHarvestTest is Demeter_CamelotFarmTest {
+    function test_RevertWhen_notNftPool() public {
         vm.expectRevert(abi.encodeWithSelector(Demeter_CamelotFarm.NotAllowed.selector));
         Demeter_CamelotFarm(lockupFarm).onNFTHarvest(address(0), address(0), 742, 1, 1);
     }
@@ -177,7 +216,9 @@ contract Demeter_CamelotFarmTest is BaseFarmTest {
         bool harvested = Demeter_CamelotFarm(lockupFarm).onNFTHarvest(address(0), user, 742, 1, 1);
         assertEq(harvested, true);
     }
+}
 
+contract ClaimPoolRewardsTest is Demeter_CamelotFarmTest {
     function test_claimPoolRewards_RevertWhen_FarmIsClosed()
         public
         depositSetup(nonLockupFarm, false)

test/e20-farms/BaseE20Farm.t.sol

@@ -16,6 +16,39 @@ abstract contract BaseE20FarmTest is BaseFarmTest {
     function getPoolAddress() public virtual returns (address);
 }
 
+abstract contract E20FarmDepositTest is BaseE20FarmTest {
+    function test_E20FarmDeposit() public useKnownActor(user) {
+        address farm;
+        bool lockup;
+        for (uint8 j; j < 2; ++j) {
+            lockup = j == 0 ? true : false;
+            farm = lockup ? lockupFarm : nonLockupFarm;
+            address poolAddress = getPoolAddress();
+            uint256 amt = 1e3 * 10 ** ERC20(poolAddress).decimals();
+            deal(poolAddress, currentActor, amt);
+            ERC20(poolAddress).approve(address(farm), amt);
+            uint256 usrBalanceBefore = ERC20(poolAddress).balanceOf(currentActor);
+            uint256 farmBalanceBefore = ERC20(poolAddress).balanceOf(farm);
+            if (!lockup) {
+                vm.expectEmit(address(farm));
+                emit PoolSubscribed(BaseFarm(farm).totalDeposits() + 1, 0);
+            } else {
+                vm.expectEmit(address(farm));
+                emit PoolSubscribed(BaseFarm(farm).totalDeposits() + 1, 0);
+                vm.expectEmit(address(farm));
+                emit PoolSubscribed(BaseFarm(farm).totalDeposits() + 1, 1);
+            }
+            vm.expectEmit(address(farm));
+            emit Deposited(BaseFarm(farm).totalDeposits() + 1, currentActor, lockup, amt);
+            BaseE20Farm(farm).deposit(amt, lockup);
+            uint256 usrBalanceAfter = ERC20(poolAddress).balanceOf(currentActor);
+            uint256 farmBalanceAfter = ERC20(poolAddress).balanceOf(farm);
+            assertEq(usrBalanceAfter, usrBalanceBefore - amt);
+            assertEq(farmBalanceAfter, farmBalanceBefore + amt);
+        }
+    }
+}
+
 abstract contract IncreaseDepositTest is BaseE20FarmTest {
     event DepositIncreased(uint256 indexed depositId, uint256 liquidity);
 
@@ -29,10 +62,10 @@ abstract contract IncreaseDepositTest is BaseE20FarmTest {
         BaseE20Farm(lockupFarm).increaseDeposit(DEPOSIT_ID, amt);
     }
 
-    function testFuzz_RevertWhen_farmIsClosed(uint256 amt) public depositSetup(lockupFarm, true) useKnownActor(user) {
+    function test_IncreaseDeposit_RevertWhen_farmIsClosed() public depositSetup(lockupFarm, true) useKnownActor(user) {
         address poolAddress = getPoolAddress();
 
-        vm.assume(amt > 100 * 10 ** ERC20(poolAddress).decimals() && amt <= 1000 * 10 ** ERC20(poolAddress).decimals());
+        uint256 amt = 100 * 10 ** ERC20(poolAddress).decimals();
 
         deal(poolAddress, currentActor, amt);
         ERC20(poolAddress).approve(address(lockupFarm), amt);
@@ -42,13 +75,9 @@ abstract contract IncreaseDepositTest is BaseE20FarmTest {
         BaseE20Farm(lockupFarm).increaseDeposit(DEPOSIT_ID, amt);
     }
 
-    function testFuzz_RevertWhen_depositInCoolDown(uint256 amt)
-        public
-        depositSetup(lockupFarm, true)
-        useKnownActor(user)
-    {
+    function test_RevertWhen_depositInCoolDown() public depositSetup(lockupFarm, true) useKnownActor(user) {
         address poolAddress = getPoolAddress();
-        vm.assume(amt > 100 * 10 ** ERC20(poolAddress).decimals() && amt <= 1000 * 10 ** ERC20(poolAddress).decimals());
+        uint256 amt = 100 * 10 ** ERC20(poolAddress).decimals();
         BaseE20Farm(lockupFarm).initiateCooldown(DEPOSIT_ID);
         skip(86400 * 2);
         deal(poolAddress, currentActor, amt);
@@ -57,32 +86,21 @@ abstract contract IncreaseDepositTest is BaseE20FarmTest {
         BaseE20Farm(lockupFarm).increaseDeposit(DEPOSIT_ID, amt);
     }
 
-    function testFuzz_lockupFarm(uint256 amt) public depositSetup(lockupFarm, true) useKnownActor(user) {
-        address poolAddress = getPoolAddress();
-        vm.assume(amt > 100 * 10 ** ERC20(poolAddress).decimals() && amt <= 1000 * 10 ** ERC20(poolAddress).decimals());
-
-        deal(poolAddress, currentActor, amt);
-        uint256 usrBalanceBefore = ERC20(poolAddress).balanceOf(currentActor);
-        uint256 farmBalanceBefore = ERC20(poolAddress).balanceOf(lockupFarm);
-        ERC20(poolAddress).approve(address(lockupFarm), amt);
-        BaseE20Farm(lockupFarm).increaseDeposit(DEPOSIT_ID, amt);
-        uint256 usrBalanceAfter = ERC20(poolAddress).balanceOf(currentActor);
-        uint256 farmBalanceAfter = ERC20(poolAddress).balanceOf(lockupFarm);
-        assertEq(usrBalanceAfter, usrBalanceBefore - amt);
-        assertEq(farmBalanceAfter, farmBalanceBefore + amt);
-    }
-
-    function testFuzz_nonLockupFarm(uint256 amt) public depositSetup(nonLockupFarm, false) useKnownActor(user) {
+    function testFuzz_IncreaseDepositTest(bool lockup, uint256 amt) public {
+        address farm;
+        farm = lockup ? lockupFarm : nonLockupFarm;
+        depositSetupFn(farm, lockup);
+        vm.startPrank(user);
         address poolAddress = getPoolAddress();
         vm.assume(amt > 100 * 10 ** ERC20(poolAddress).decimals() && amt <= 1000 * 10 ** ERC20(poolAddress).decimals());
 
-        deal(poolAddress, currentActor, amt);
-        uint256 usrBalanceBefore = ERC20(poolAddress).balanceOf(currentActor);
-        uint256 farmBalanceBefore = ERC20(poolAddress).balanceOf(nonLockupFarm);
-        ERC20(poolAddress).approve(address(nonLockupFarm), amt);
-        BaseE20Farm(nonLockupFarm).increaseDeposit(DEPOSIT_ID, amt);
-        uint256 usrBalanceAfter = ERC20(poolAddress).balanceOf(currentActor);
-        uint256 farmBalanceAfter = ERC20(poolAddress).balanceOf(nonLockupFarm);
+        deal(poolAddress, user, amt);
+        uint256 usrBalanceBefore = ERC20(poolAddress).balanceOf(user);
+        uint256 farmBalanceBefore = ERC20(poolAddress).balanceOf(farm);
+        ERC20(poolAddress).approve(address(farm), amt);
+        BaseE20Farm(farm).increaseDeposit(DEPOSIT_ID, amt);
+        uint256 usrBalanceAfter = ERC20(poolAddress).balanceOf(user);
+        uint256 farmBalanceAfter = ERC20(poolAddress).balanceOf(farm);
         assertEq(usrBalanceAfter, usrBalanceBefore - amt);
         assertEq(farmBalanceAfter, farmBalanceBefore + amt);
     }
@@ -139,12 +157,12 @@ abstract contract IncreaseDepositTest is BaseE20FarmTest {
 abstract contract RecoverERC20E20FarmTest is BaseE20FarmTest {
     event Transfer(address indexed from, address indexed to, uint256 value);
 
-    function test_recoverE20_LockupFarm_RevertWhen_CannotWithdrawRewardTokenOrFarmToken() public useKnownActor(owner) {
+    function test_RevertWhen_CannotWithdrawRewardTokenOrFarmToken() public useKnownActor(owner) {
         vm.expectRevert(abi.encodeWithSelector(BaseE20Farm.CannotWithdrawRewardTokenOrFarmToken.selector));
         BaseFarm(lockupFarm).recoverERC20(USDCe);
     }
 
-    function test_recoverE20_LockupFarm_RevertWhen_CannotWithdrawZeroAmount() public useKnownActor(owner) {
+    function test_RevertWhen_CannotWithdrawZeroAmount() public useKnownActor(owner) {
         vm.expectRevert(abi.encodeWithSelector(BaseFarm.CannotWithdrawZeroAmount.selector));
         BaseFarm(lockupFarm).recoverERC20(USDT);
     }

test/e20-farms/balancer/BalancerFarm.t.sol

@@ -65,6 +65,7 @@ contract BalancerFarmTest is
     UpdateCoolDownPeriodTest,
     CloseFarmTest,
     _SetupFarmTest,
+    E20FarmDepositTest,
     IncreaseDepositTest,
     DecreaseDepositTest,
     RecoverERC20E20FarmTest,
@@ -135,24 +136,7 @@ contract BalancerFarmTest is
         uint256 amt = baseAmt * 10 ** ERC20(poolAddress).decimals();
         deal(poolAddress, currentActor, amt);
         ERC20(poolAddress).approve(address(farm), amt);
-        uint256 usrBalanceBefore = ERC20(poolAddress).balanceOf(currentActor);
-        uint256 farmBalanceBefore = ERC20(poolAddress).balanceOf(farm);
-        if (!locked) {
-            vm.expectEmit(address(farm));
-            emit PoolSubscribed(BaseFarm(farm).totalDeposits() + 1, 0);
-        } else {
-            vm.expectEmit(address(farm));
-            emit PoolSubscribed(BaseFarm(farm).totalDeposits() + 1, 0);
-            vm.expectEmit(address(farm));
-            emit PoolSubscribed(BaseFarm(farm).totalDeposits() + 1, 1);
-        }
-        vm.expectEmit(address(farm));
-        emit Deposited(BaseFarm(farm).totalDeposits() + 1, currentActor, locked, amt);
         BaseE20Farm(farm).deposit(amt, locked);
-        uint256 usrBalanceAfter = ERC20(poolAddress).balanceOf(currentActor);
-        uint256 farmBalanceAfter = ERC20(poolAddress).balanceOf(farm);
-        assertEq(usrBalanceAfter, usrBalanceBefore - amt);
-        assertEq(farmBalanceAfter, farmBalanceBefore + amt);
         return amt;
     }