Stop Breaking Your Foundry Tests - Isolate Development with Branch Snapshots

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

import "forge-std/Test.sol";

contract BranchingTest is Test {
    uint256 mainnetFork;
    
    function setUp() public {
        // Personal note: Learned to use environment variables after 
        // accidentally committing API keys twice
        string memory rpcUrl = vm.envString("MAINNET_RPC_URL");
        
        // Create fork at specific block for reproducibility
        mainnetFork = vm.createFork(rpcUrl, 18000000);
        
        // Watch out: Forgetting vm.selectFork means you're not on the fork!
        vm.selectFork(mainnetFork);
    }
    
    function testForkCreated() public {
        // Verify we're on mainnet fork
        assertEq(block.number, 18000000);
        console.log("Fork created at block:", block.number);
    }
}

contract SnapshotTest is Test {
    uint256 mainnetFork;
    uint256 cleanStateSnapshot;
    
    // USDC contract on mainnet
    address constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
    address constant WHALE = 0x47ac0Fb4F2D84898e4D9E7b4DaB3C24507a6D503; // Binance wallet
    
    function setUp() public {
        mainnetFork = vm.createFork(vm.envString("MAINNET_RPC_URL"));
        vm.selectFork(mainnetFork);
        
        // Personal note: I used to manually reset state - snapshots saved me 
        // 30 seconds per test, which adds up to 20 minutes in a full suite
        cleanStateSnapshot = vm.snapshot();
    }
    
    function testTransferDoesntAffectNextTest() public {
        // Modify state
        vm.prank(WHALE);
        IERC20(USDC).transfer(address(this), 1000e6); // 1000 USDC
        
        uint256 balance = IERC20(USDC).balanceOf(address(this));
        assertEq(balance, 1000e6);
        console.log("Received USDC:", balance);
    }
    
    function testStateIsClean() public {
        // This runs with clean state because setUp() creates new snapshot
        uint256 balance = IERC20(USDC).balanceOf(address(this));
        assertEq(balance, 0);
        console.log("Balance is clean:", balance);
    }
    
    function testManualRevert() public {
        // Make changes
        vm.deal(address(this), 1000 ether);
        
        // Revert to clean state mid-test
        vm.revertTo(cleanStateSnapshot);
        
        // Watch out: After revert, balance is back to setUp() state
        assertEq(address(this).balance, 0);
    }
}

interface IERC20 {
    function balanceOf(address) external view returns (uint256);
    function transfer(address, uint256) external returns (bool);
}

contract MultiForkTest is Test {
    uint256 mainnetFork;
    uint256 polygonFork;
    
    address constant MAINNET_USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
    address constant POLYGON_USDC = 0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174;
    
    function setUp() public {
        // Create both forks upfront - costs ~2 seconds total
        mainnetFork = vm.createFork(vm.envString("MAINNET_RPC_URL"));
        polygonFork = vm.createFork(vm.envString("POLYGON_RPC_URL"));
    }
    
    function testCrossChainUSDCDecimals() public {
        // Check mainnet USDC (6 decimals)
        vm.selectFork(mainnetFork);
        uint8 mainnetDecimals = IERC20Metadata(MAINNET_USDC).decimals();
        console.log("Mainnet USDC decimals:", mainnetDecimals);
        assertEq(mainnetDecimals, 6);
        
        // Switch to Polygon - instant, no re-forking needed!
        vm.selectFork(polygonFork);
        uint8 polygonDecimals = IERC20Metadata(POLYGON_USDC).decimals();
        console.log("Polygon USDC decimals:", polygonDecimals);
        assertEq(polygonDecimals, 6);
        
        // Personal note: This pattern helped me find a decimals bug 
        // in our cross-chain bridge before production deploy
    }
    
    function testForkIsolation() public {
        // Changes on mainnet fork
        vm.selectFork(mainnetFork);
        vm.roll(block.number + 100);
        uint256 mainnetBlock = block.number;
        
        // Polygon fork unchanged
        vm.selectFork(polygonFork);
        uint256 polygonBlock = block.number;
        
        // Watch out: Each fork maintains independent state
        assertGt(mainnetBlock, polygonBlock + 50);
        console.log("Mainnet advanced, Polygon unchanged:", mainnetBlock, polygonBlock);
    }
}

interface IERC20Metadata {
    function decimals() external view returns (uint8);
}

contract TeamSafeTest is Test {
    uint256 immutable FORK_BLOCK = 18000000;
    uint256 mainnetFork;
    uint256 baseSnapshot;
    
    function setUp() public {
        // Everyone forks same block - reproducible results
        mainnetFork = vm.createFork(
            vm.envString("MAINNET_RPC_URL"),
            FORK_BLOCK
        );
        vm.selectFork(mainnetFork);
        
        // Snapshot after fork creation
        baseSnapshot = vm.snapshot();
    }
    
    function testMyFeature() public {
        // Each test gets clean fork state
        // Do whatever you want - deploy contracts, change state
        
        // Example: Deploy and test new contract
        MyContract c = new MyContract();
        c.doSomething();
        
        // Your changes don't affect other tests!
        assertTrue(c.isComplete());
    }
    
    function testTeammateFeature() public {
        // Runs with fresh fork - no conflicts with testMyFeature()
        // Even if that test deployed contracts or modified state
        
        assertEq(block.number, FORK_BLOCK, "Clean fork state confirmed");
    }
    
    function tearDown() public {
        // Optional: Revert to base snapshot for extra safety
        // Personal note: I don't usually need this because setUp() 
        // runs before each test, but it helps when debugging
        vm.revertTo(baseSnapshot);
    }
}

contract MyContract {
    bool public isComplete;
    
    function doSomething() external {
        isComplete = true;
    }
}