Merge pull request #4 from anticlimactic/migration-revoke-tests

test: add migration, revoke tests

src/interface/Vault.sol

@@ -124,6 +124,10 @@ interface IVault is IERC20 {
      */
     function revokeStrategy() external;
 
+    function revokeStrategy(address strategy) external;
+
+    function migrateStrategy(address oldVersion, address newVersion) external;
+
     function updateStrategyDebtRatio(address strategy, uint256 debtRatio) external;
 
     /**

src/test/StrategyMigration.t.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: AGPL-3.0
+pragma solidity ^0.8.12;
+
+import {StrategyFixture} from "./utils/StrategyFixture.sol";
+
+// NOTE: if the name of the strat or file changes this needs to be updated
+import {Strategy} from "../Strategy.sol";
+
+contract StrategyMigrationTest is StrategyFixture {
+
+    function setUp() public override {
+        super.setUp();
+    }
+
+    // TODO: Add tests that show proper migration of the strategy to a newer one
+    // Use another copy of the strategy to simmulate the migration
+    // Show that nothing is lost.
+    function testMigration(uint256 _amount) public {
+        vm_std_cheats.assume(_amount > 0.1 ether && _amount < 10e18);
+
+        // Deposit to the vault and harvest
+        vm_std_cheats.prank(user);
+        want.approve(address(vault), _amount);
+        vm_std_cheats.prank(user);
+        vault.deposit(_amount);
+        skip(1);
+        strategy.harvest();
+        assertEq(strategy.estimatedTotalAssets(), _amount);
+
+        // Migrate to a new strategy
+        vm_std_cheats.prank(strategist);
+        address newStrategyAddr = deployStrategy(address(vault));
+        vault.migrateStrategy(address(strategy), newStrategyAddr);
+        assertEq(Strategy(newStrategyAddr).estimatedTotalAssets(), _amount);
+    }
+
+}

src/test/Strategy.t.sol → src/test/StrategyOperation.t.sol

@@ -1,51 +1,15 @@
 // SPDX-License-Identifier: AGPL-3.0
 pragma solidity ^0.8.12;
-import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "forge-std/console.sol";
 
-import {StrategyFixture} from "./utils/Test.sol";
+import {StrategyFixture} from "./utils/StrategyFixture.sol";
 
-// NOTE: maybe is worth to make several contracts to test several operations
-// and different strategy functionality
-contract StrategyTest is StrategyFixture {
-    using SafeERC20 for IERC20;
-
-    IERC20 want;
-    IERC20 weth;
-
-    // NOTE: feel free change these vars to adjust for your strategy testing
-    IERC20 public immutable DAI = IERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
-    IERC20 public immutable WETH = IERC20(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
-    address public whale = 0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643;
-    address public user = address(1337);
-    address public user2 = address(7331);
-    uint256 WETH_AMT = 10 ** 18;
+contract StrategyOperationsTest is StrategyFixture {
 
     // setup is run on before each test
     function setUp() public override {
         // setup vault
         super.setUp();
-
-        // replace with your token
-        want = DAI;
-        weth = WETH;
-
-        deployVaultAndStrategy(
-            address(want),
-            address(this),
-            address(this),
-            "",
-            "",
-            address(this),
-            address(this),
-            address(this)
-        );
-
-        // do here additional setup
-        vault.setDepositLimit(type(uint256).max);
-        tip(address(want), address(user), 10000e18);
-        vm_std_cheats.deal(user, 10_000 ether);
     }
 
     function testSetupVaultOK() public {
@@ -62,6 +26,7 @@ contract StrategyTest is StrategyFixture {
         assertEq(address(strategy.vault()), address(vault));
     }
 
+    /// Test Operations
     function testStrategyOperation(uint256 _amount) public {
         vm_std_cheats.assume(_amount > 0.1 ether && _amount < 10e18);
 
@@ -127,7 +92,7 @@ contract StrategyTest is StrategyFixture {
         skip(1);
         strategy.harvest();
         skip(3600 * 6);
-        
+
         // TODO: Uncomment the lines below
         // uint256 profit = want.balanceOf(address(vault));
         // assertGt(want.balanceOf(address(strategy) + profit), _amount);
@@ -210,4 +175,5 @@ contract StrategyTest is StrategyFixture {
         strategy.harvestTrigger(0);
         strategy.tendTrigger(0);
     }
+
 }

src/test/StrategyRevoke.t.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: AGPL-3.0
+pragma solidity ^0.8.12;
+
+import {StrategyFixture} from "./utils/StrategyFixture.sol";
+
+contract StrategyRevokeTest is StrategyFixture {
+
+    function setUp() public override {
+        super.setUp();
+    }
+
+    function testRevokeStrategyFromVault(uint256 _amount) public {
+        vm_std_cheats.assume(_amount > 0.1 ether && _amount < 10e18);
+
+        // Deposit to the vault and harvest
+        vm_std_cheats.prank(user);
+        want.approve(address(vault), _amount);
+        vm_std_cheats.prank(user);
+        vault.deposit(_amount);
+        skip(1);
+        strategy.harvest();
+        assertEq(strategy.estimatedTotalAssets(), _amount);
+
+        // In order to pass these tests, you will need to implement prepareReturn.
+        // TODO: uncomment the following lines.
+        // vault.revokeStrategy(address(strategy));
+        // skip(1);
+        // strategy.harvest();
+        // assertEq(want.balanceOf(address(vault)), _amount);
+    }
+
+    function testRevokeStrategyFromStrategy(uint256 _amount) public {
+        vm_std_cheats.assume(_amount > 0.1 ether && _amount < 10e18);
+
+        vm_std_cheats.prank(user);
+        want.approve(address(vault), _amount);
+        vm_std_cheats.prank(user);
+        vault.deposit(_amount);
+        skip(1);
+        strategy.harvest();
+        assertEq(strategy.estimatedTotalAssets(), _amount);
+
+        strategy.setEmergencyExit();
+        skip(1);
+        strategy.harvest();
+        assertEq(want.balanceOf(address(vault)), _amount);
+    }
+
+}

src/test/utils/Test.sol → src/test/utils/StrategyFixture.sol

@@ -2,6 +2,8 @@
 pragma solidity ^0.8.12;
 pragma abicoder v2;
 
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import {ExtendedDSTest} from "./ExtendedDSTest.sol";
 import {stdCheats} from "forge-std/stdlib.sol";
 import {IVault} from "../../interface/Vault.sol";
@@ -15,11 +17,43 @@ string constant vaultArtifact = 'artifacts/Vault.json';
 
 // Base fixture deploying Vault
 contract StrategyFixture is ExtendedDSTest, stdCheats {
+    using SafeERC20 for IERC20;
+
     IVault public vault;
     Strategy public strategy;
+    IERC20 public weth;
+    IERC20 public want;
+
+    // NOTE: feel free change these vars to adjust for your strategy testing
+    IERC20 public immutable DAI = IERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
+    IERC20 public immutable WETH = IERC20(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
+    address public whale = 0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643;
+    address public user = address(1337);
+    address public strategist = address(1);
+    uint256 public WETH_AMT = 10 ** 18;
 
     function setUp() public virtual {
-        // setup vault
+        weth = WETH;
+
+        // replace with your token
+        want = DAI;
+
+        deployVaultAndStrategy(
+            address(want),
+            address(this),
+            address(this),
+            "",
+            "",
+            address(this),
+            address(this),
+            address(this),
+            strategist
+        );
+
+        // do here additional setup
+        vault.setDepositLimit(type(uint256).max);
+        tip(address(want), address(user), 10000e18);
+        vm_std_cheats.deal(user, 10_000 ether);
     }
 
     // Deploys a vault
@@ -52,9 +86,9 @@ contract StrategyFixture is ExtendedDSTest, stdCheats {
     function deployStrategy(
         address _vault
     ) public returns (address) {
-        strategy = new Strategy(_vault);
+        Strategy _strategy = new Strategy(_vault);
 
-        return address(strategy);
+        return address(_strategy);
     }
 
     // Deploys a vault and strategy attached to vault
@@ -66,7 +100,8 @@ contract StrategyFixture is ExtendedDSTest, stdCheats {
         string memory _symbol,
         address _guardian,
         address _management,
-        address _keeper
+        address _keeper,
+        address _strategist
     ) public returns (address _vault, address _strategy) {
         _vault = deployCode(vaultArtifact);
         vault = IVault(_vault);
@@ -81,8 +116,11 @@ contract StrategyFixture is ExtendedDSTest, stdCheats {
             _management
         );
 
+        vm_std_cheats.prank(_strategist);
         _strategy = deployStrategy(_vault);
+        strategy = Strategy(_strategy);
 
+        vm_std_cheats.prank(_strategist);
         strategy.setKeeper(_keeper);
 
         vault.addStrategy(