智能合约测试：Foundry 单元与集成、Fork 主网、模糊与不变量、Gas 与升级验证

层次一：单元测试    —— 单个函数的输入输出、边界、回滚（revert）
层次二：集成测试    —— 多合约协作、代币转账、权限流转
层次三：Fork 测试   —— 连到主网分叉，用真实预言机/池子/DEX
层次四：模糊测试    —— 随机输入找边界；不变量测试穷举状态
层次五：非功能测试  —— Gas 快照、重放防护、升级存储兼容

// test/Counter.t.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "forge-std/Test.sol";
import {Counter} from "../src/Counter.sol";

contract CounterTest is Test {
    Counter counter;
    address alice = address(0xA11CE);

    function setUp() public {
        counter = new Counter();
    }

    function test_Increment() public {
        counter.increment();
        assertEq(counter.number(), 1);
    }

    function test_RevertWhen_Unauthorized() public {
        vm.prank(alice);                       // 模拟 alice 调用
        vm.expectRevert("not owner");          // 断言回滚与消息
        counter.ownerIncrement();
    }

    function testFuzz_IncrementAnyTimes(uint8 times) public {
        for (uint256 i; i < times; i++) counter.increment();
        assertEq(counter.number(), times);     // 对任意 times 都成立
    }
}

forge test                       # 运行全部测试
forge test -vvv                  # 打印调用 trace
forge test --match-test Fuzz     # 只跑模糊测试
forge coverage                   # 覆盖率

function test_TimeDependent() public {
    vm.warp(1_700_000_000);                 // 操纵 block.timestamp
    vm.roll(19_000_000);                    // 操纵 block.number
    counter.incrementWithCooldown();
    vm.warp(1_700_000_001);
    counter.incrementWithCooldown();        // 冷却期内第二次
}

function test_ImpersonateWhale() public {
    address whale = 0x28C6c06298d514Db089934071355E5743bf21d60;
    vm.prank(whale);                        // 冒充任意地址
    token.transfer(address(this), 1000e18);
}

function test_ExpectEmit() public {
    vm.expectEmit(true, true, false, true); // 断言事件被正确 emit
    emit Transfer(alice, bob, 100);
    token.transfer(bob, 100);
}

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("Counter", () => {
  let counter, owner, alice;

  beforeEach(async () => {
    [owner, alice] = await ethers.getSigners();
    const Counter = await ethers.getContractFactory("Counter");
    counter = await Counter.deploy();
  });

  it("仅 owner 可调用受保护方法", async () => {
    await expect(counter.connect(alice).ownerIncrement())
      .to.be.revertedWith("not owner");
  });

  it("状态变化后余额与事件都正确", async () => {
    await expect(counter.increment())
      .to.emit(counter, "Incremented").withArgs(1);
    expect(await counter.number()).to.equal(1);
  });
});

// test/Fork.t.sol
contract ForkTest is Test {
    // 通过 RPC 分叉主网某个区块
    uint256 mainnetFork = vm.createFork(vm.envString("MAINNET_RPC_URL"), 18_500_000);

    function setUp() public {
        vm.selectFork(mainnetFork);          // 切到主网分叉
    }

    function test_SwapOnRealUniswap() public {
        // 使用主网上真实的 WETH/USDC 池
        IUniswapV2Pair pair = IUniswapV2Pair(0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc);
        (uint112 r0, uint112 r1,) = pair.getReserves();
        assertGt(r0, 0, "池子应有储备");
        // 在这里测试你的合约与真实池子的交互
    }
}

export MAINNET_RPC_URL="https://eth-mainnet.g.alchemy.com/v2/..."
forge test --match-contract ForkTest --fork-url $MAINNET_RPC_URL

function test_FlashLoanPriceManipulation() public {
    // 复现攻击：闪电贷巨额资金 → 操纵池子价格 → 触发你的合约错误定价
    uint256 loanAmount = 10_000_000e6;   // 1000 万 USDC
    vm.deal(address(this), 100 ether);

    // 1. 借入闪电贷
    // 2. 在真实池子大额 swap，把价格打偏
    // 3. 调用被攻击合约，观察是否被薅走资金
    // 4. 断言：合约应拒绝这笔交易，或价格未被操纵
    vm.expectRevert("price deviation too high");
    vulnerableContract.execute();
}

Fork 测试覆盖不了的：
  · 未来才会发生的链上状态变化
  · 其他合约在同区块内的行为（需要精确复现整块交易）
  · 跨链消息与 L2 → L1 的延迟

因此 Fork 测试是"集成测试"的一种，不能替代单元测试与不变量测试。

function testFuzz_TransferNeverExceedsBalance(
    address to, uint256 amount
) public {
    vm.assume(to != address(0));           // 排除无效输入
    uint256 balance = token.balanceOf(address(this));

    if (amount > balance) {
        vm.expectRevert();                  // 超额必须回滚
        token.transfer(to, amount);
    } else {
        token.transfer(to, amount);
        assertEq(token.balanceOf(to), amount);
    }
}

# Foundry 默认每个 fuzz 用例跑 256 次随机输入
forge test --fuzz-runs 10000
# 失败时输出使测试失败的具体输入：
# [FAIL. Reason: assertion failed]
#   counterexample: calldata=0x..., args=[1234]

// test/Invariant.t.sol
contract VaultInvariantTest is Test {
    Vault vault;
    VaultHandler handler;

    function setUp() public {
        vault = new Vault();
        handler = new VaultHandler(vault);
        // 让 fuzzer 只调用 handler 的受控入口
        targetContract(address(handler));
    }

    // 核心不变量：合约持有的资产 >= 所有用户存款总和
    function invariant_Solvency() public view {
        assertGe(
            address(vault).balance,
            vault.totalDeposits(),
            "不变量违反：合约资不抵债"
        );
    }

    // 不变量：总供应量守恒
    function invariant_TotalSupplyConserved() public view {
        assertEq(vault.totalSupply(), handler.sumOfBalances());
    }
}

forge test --match-test invariant --invariant-runs 500
# Fuzzer 随机调用 deposit/withdraw/transfer 的组合，
# 一旦 Solvency 被打破，立即输出导致失败的函数调用序列

用例思维：  转账 100 → 断言 A 减少 100、B 增加 100
不变式思维：任何操作序列后，Σ(所有余额) == totalSupply
           任何操作序列后，合约余额 >= 用户可取总额
           任何操作序列后，owner 权限不变

function test_GasIncrement() public {
    uint256 gasBefore = gasleft();
    counter.increment();
    uint256 gasUsed = gasBefore - gasleft();
    assertLt(gasUsed, 30_000, "increment 超过 Gas 预算");
}

# Foundry 生成 Gas 快照
forge snapshot
# 输出 .gas-snapshot：
# CounterTest:test_Increment() (gas: 24318)
# VaultTest:test_Deposit() (gas: 87102)

# CI 中对比，超支则失败
forge snapshot --check .gas-snapshot

function test_SignatureCannotBeReplayed() public {
    bytes memory sig = _sign(ownerKey, msgHash, nonce);

    // 第一次使用成功
    vault.executeWithSig(action, nonce, sig);
    assertEq(vault.executedCount(), 1);

    // 第二次用同一签名重放，必须失败
    vm.expectRevert("nonce already used");
    vault.executeWithSig(action, nonce, sig);
}

function test_SignatureBoundToChainId() public {
    // 在 fork 上签名，切到另一条链应失效
    uint256 forkB = vm.createFork(vm.envString("OTHER_RPC_URL"));
    vm.selectFork(forkB);
    vm.expectRevert("invalid chainId");
    vault.executeWithSig(action, nonce, sig);
}

用户 → Proxy（存 storage，含 implementation 地址）
              ↓ delegatecall
           Implementation V1（只有逻辑，无自己的 storage）

// V1
contract VaultV1 {
    address owner;        // slot 0
    uint256 totalDeposits;// slot 1
}

// V2 错误写法：在中间插入新变量 → 全部错位！
contract VaultV2Bad {
    address owner;        // slot 0
    uint256 feeRate;      // slot 1 ← 挤走了 totalDeposits
    uint256 totalDeposits;// slot 2 ← 读到的是 feeRate 的值
}

// V2 正确写法：只在末尾追加
contract VaultV2Good {
    address owner;        // slot 0
    uint256 totalDeposits;// slot 1
    uint256 feeRate;      // slot 2 ← 追加在末尾
}

# 用 OpenZeppelin 的升级检查插件自动验证
npx @openzeppelin/upgrades-core validate
# 输出：
# ✔ Storage layout is compatible
# 或
# ✖ Storage layout changed: variable 'totalDeposits' moved from slot 1 to slot 2

function test_UpgradePreservesState() public {
    // V1 部署并写入状态
    VaultV1 v1 = new VaultV1();
    ERC1967Proxy proxy = new ERC1967Proxy(address(v1), "");
    VaultV1(address(proxy)).deposit{value: 1 ether}();
    uint256 depositsBefore = VaultV1(address(proxy)).totalDeposits();

    // 升级到 V2
    VaultV2 v2 = new VaultV2();
    VaultV1(address(proxy)).upgradeTo(address(v2));

    // 断言：状态完好，新功能可用
    assertEq(VaultV2(address(proxy)).totalDeposits(), depositsBefore, "状态丢失");
    VaultV2(address(proxy)).setFeeRate(100);
    assertEq(VaultV2(address(proxy)).feeRate(), 100);
}

function test_UpgradeOnlyByAuthorized() public {
    vm.prank(alice);
    vm.expectRevert("not authorized");
    VaultV1(address(proxy)).upgradeTo(address(newImpl));
}

jobs:
  contract-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: foundry-rs/foundry-toolchain@v1
      - run: forge fmt --check              # 格式检查
      - run: forge build --sizes            # 合约大小（EIP-170 限制 24KB）
      - run: forge test -vvv                # 单元 + 集成
      - run: forge test --fuzz-runs 10000   # 模糊测试（更多轮次）
      - run: forge test --match-test invariant --invariant-runs 500
      - run: forge snapshot --check         # Gas 回归门禁
      - run: forge coverage --report summary
      - name: Fork tests
        env:
          MAINNET_RPC_URL: ${{ secrets.ALCHEMY_KEY }}
        run: forge test --match-contract Fork --fork-block-number 18500000
      - run: npx @openzeppelin/upgrades-core validate   # 存储布局