15.4.3 合约测试与本地链工程
所属:全栈开发面试题库 / 15 Web3 与区块链 / 15.4 Solidity 与合约工程
本节要解决的问题
面试里问"怎么测试合约",多数人答"用 Hardhat"。这是入门。真正的分水岭是:能不能说清 Foundry 与 Hardhat 的选型、fork test 与 fuzz test 的区别、invariant test 怎么写、以及 CI 集成。本节解决四个具体问题:一是分清 Foundry 与 Hardhat 的架构差异(Foundry 用 Rust 写测试,Hardhat 用 JS/TS);二是讲清 fork test(复刻主网状态)与 fuzz test(随机输入);三是把 invariant test(性质测试)与 unit test 串起来;四是说明部署脚本与多签治理的流程。
学习目标
学完本节,你应当能够:
- 对比 Foundry 与 Hardhat 的优缺点,说明什么时候用哪个。
- 写出 fork test(复刻主网状态)与 fuzz test(随机输入)。
- 解释 invariant test(性质测试)的原理,以及怎么写。
- 说明部署脚本与多签治理的流程。
先修与前置
- 建议先读 15.3.5 节点客户端、RPC 与索引 的 RPC 与节点。
- 本节是 15.5.4 审计流程与工具链 的前置。
知识地图
测试框架:
Foundry:Rust 写测试,快,内置 fuzz/invariant
Hardhat:JS/TS 写测试,生态成熟
测试类型:
unit test:单个函数测试
fork test:复刻主网状态测试
fuzz test:随机输入测试
invariant test:性质测试(永远不变的属性)
工程化:
覆盖率:测试覆盖的代码百分比
CI:自动跑测试
部署脚本:自动化部署
多签治理:部署后用多签管理
核心术语
- Foundry:Rust 写的合约测试框架,快,内置 fuzz/invariant。
- Hardhat:JS/TS 写的合约测试框架,生态成熟。
- fork test:复刻主网状态测试,模拟主网环境。
- fuzz test:随机输入测试,自动生成大量输入。
- invariant test:性质测试,验证"永远不变的属性"。
- 覆盖率:测试覆盖的代码百分比。
- CI:持续集成,自动跑测试。
- 多签治理:部署后用多签管理合约(如 OpenZeppelin Defender)。
覆盖范围
- Foundry vs Hardhat 选型
- 测试类型:unit、fork、fuzz、invariant
- fork test 与主网状态复刻
- fuzz test 与随机输入
- invariant test 与性质测试
- 覆盖率与 CI 集成
- 部署脚本与多签治理
- 测试网与主网的环境隔离
高频题速览
| 编号 | 题目 | 难度 | 频率 |
|---|---|---|---|
| 15.4.3-001 | Foundry 和 Hardhat 怎么选? | 基础 | ★★★★★ |
| 15.4.3-002 | unit test、fork test、fuzz test、invariant test 有什么区别? | 基础 | ★★★★★ |
| 15.4.3-003 | fork test 是怎么复刻主网状态的? | 进阶 | ★★★★ |
| 15.4.3-004 | fuzz test 怎么写? | 进阶 | ★★★★ |
| 15.4.3-005 | invariant test 是什么? | 进阶 | ★★★★ |
| 15.4.3-006 | 测试中的 mock 怎么用? | 进阶 | ★★★ |
| 15.4.3-007 | 覆盖率怎么测?CI 怎么集成? | 进阶 | ★★★ |
| 15.4.3-008 | 调试技巧有哪些? | 高级 | ★★★ |
| 15.4.3-009 | 部署脚本与多签治理怎么搞? | 高级 | ★★★ |
| 15.4.3-010 | 测试网与主网怎么隔离? | 高级 | ★★★ |
15.4.3-001 Foundry 和 Hardhat 怎么选?
一句话结论
Foundry 用 Rust 写测试,快,内置 fuzz/invariant;Hardhat 用 JS/TS 写测试,生态成熟。选择取决于团队技术栈与性能需求。
概念解释
- Foundry:Rust 写的测试框架,快,内置 fuzz/invariant,测试用 Solidity 写。
- Hardhat:JS/TS 写的测试框架,生态成熟,插件多。
- 选择:Rust/Solidity 团队用 Foundry,JS/TS 团队用 Hardhat。
- 趋势:Foundry 越来越流行(快、内置 fuzz)。
原理流程
- Foundry:测试用 Solidity 写,跑在本地 EVM(revm),快。
- Hardhat:测试用 JS/TS 写,跑在 Hardhat Network(本地 EVM)。
- Foundry 内置 fuzz/invariant,不用额外插件。
- Hardhat 生态成熟,插件多(hardhat-deploy、hardhat-ethers)。
- 选择:取决于团队技术栈。
代码或图示
Foundry vs Hardhat:
Foundry:
测试语言:Solidity
性能:快(Rust EVM)
内置:fuzz、invariant
适合:Rust/Solidity 团队
Hardhat:
测试语言:JS/TS
性能:中等
生态:成熟,插件多
适合:JS/TS 团队
常见误区
- 误区:Foundry 比 Hardhat 好;正解:两者各有优劣,取决于团队技术栈。
- 误区:Foundry 测试用 JS 写;正解:Foundry 测试用 Solidity 写。
- 误区:Hardhat 不能 fuzz;正解:Hardhat 可以用插件(hardhat-fuzz-testing)。
追问
- Foundry 为什么快?答:因为用 Rust 写 EVM(revm),比 JS EVM 快很多;测试用 Solidity 写,不用跨语言。机制上 Foundry 是原生 EVM。边界在于:这也是 Foundry 越来越流行的原因。延伸:这是测试框架的性能。
- Hardhat 有什么优点?答:生态成熟,插件多(hardhat-deploy、hardhat-ethers、hardhat-upgrades);JS/TS 团队熟悉。机制上 Hardhat 是 JS 生态。边界在于:性能不如 Foundry。延伸:这是工程生态的选择。
- 怎么选?答:取决于团队技术栈——Rust/Solidity 团队用 Foundry,JS/TS 团队用 Hardhat。机制上选择取决于团队熟悉度。边界在于:这是工程决策。延伸:这是测试框架的选型。
15.4.3-002 unit test、fork test、fuzz test、invariant test 有什么区别?
一句话结论
unit test 测试单个函数,fork test 复刻主网状态测试,fuzz test 用随机输入测试,invariant test 验证"永远不变的属性"。
概念解释
- unit test:测试单个函数,给定输入验证输出。
- fork test:复刻主网状态,模拟主网环境测试。
- fuzz test:自动生成大量随机输入,验证不崩溃。
- invariant test:验证"永远不变的属性"(如"余额总和不变")。
原理流程
- unit test:给定输入,验证输出。
- fork test:从主网 fork 状态,模拟主网环境测试。
- fuzz test:自动生成随机输入,验证不崩溃。
- invariant test:验证"永远不变的属性"(如"总供应 = 所有用户余额之和")。
- 组合:unit + fork + fuzz + invariant 覆盖不同场景。
代码或图示
测试类型:
unit test:
function testTransfer() public {
token.transfer(alice, 100);
assertEq(token.balanceOf(alice), 100);
}
fork test:
function testFork() public {
// 从主网 fork 状态
vm.createSelectFork("mainnet");
// 测试主网交互
}
fuzz test:
function testFuzz(uint amount) public {
token.transfer(alice, amount);
// 验证不崩溃
}
invariant test:
function invariant_totalSupply() public {
assertEq(token.totalSupply(), sumOfBalances());
}
常见误区
- 误区:unit test 就够了;正解:unit + fork + fuzz + invariant 覆盖不同场景。
- 误区:fuzz test 就是随机测试;正解:fuzz test 自动生成大量随机输入,验证不崩溃。
- 误区:invariant test 就是 unit test;正解:invariant test 验证"永远不变的属性"。
追问
- 为什么需要 fork test?答:因为合约要与主网交互(如 Uniswap 池子),fork test 复刻主网状态,模拟真实环境。机制上 fork test 从主网拉取状态。边界在于:fork test 依赖 RPC 节点。延伸:这是 DApp 测试的重点。
- fuzz test 有什么用?答:自动生成大量随机输入,发现边界情况与崩溃;比手动测试覆盖更多场景。机制上 fuzz test 自动生成输入。边界在于:fuzz test 不验证业务逻辑,只验证不崩溃。延伸:这是测试自动化。
- invariant test 有什么用?答:验证"永远不变的属性"(如"余额总和不变"),发现意外状态不一致。机制上 invariant test 在每次操作后验证属性。边界在于:要识别哪些属性是不变的。延伸:这是 15.5 审计的重点。
15.4.3-003 fork test 是怎么复刻主网状态的?
一句话结论
fork test 通过 RPC 节点拉取主网状态(区块号、账户、存储),在本地 EVM 里模拟;可以测试与主网交互的场景(如 Uniswap 池子)。
概念解释
- fork test:从主网 fork 状态,在本地 EVM 模拟。
- RPC 节点:从主网拉取状态(账户、存储、合约代码)。
- 用途:测试与主网交互的场景。
- 例子:测试在 Uniswap 池子上 swap。
原理流程
- 指定主网 RPC 与区块号:
vm.createSelectFork("https://mainnet.infura.io/v3/...", 18000000)。 - 测试框架从 RPC 拉取该区块的状态(账户、存储、合约代码)。
- 在本地 EVM 里模拟,可以修改状态(如
vm.prank)。 - 测试与主网交互的场景(如 Uniswap swap)。
- 不影响主网状态(只在本地模拟)。
代码或图示
// Foundry fork test
import "forge-std/Test.sol";
contract ForkTest is Test {
function setUp() public {
// 从主网 fork 区块 18000000
vm.createSelectFork("https://mainnet.infura.io/v3/...", 18000000);
}
function testSwap() public {
// 模拟用户
address user = address(0x1234);
vm.prank(user);
// 与主网 Uniswap 池子交互
IUniswapV2Router router = IUniswapV2Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
router.swapExactTokensForTokens(...);
}
}
常见误区
- 误区:fork test 会影响主网;正解:fork test 只在本地模拟,不影响主网。
- 误区:fork test 不需要 RPC;正解:fork test 从 RPC 拉取状态。
- 误区:fork test 就是主网测试;正解:fork test 是本地模拟主网状态。
追问
- fork test 有什么用?答:测试与主网交互的场景(如 Uniswap 池子、预言机),模拟真实环境。机制上 fork test 复刻主网状态。边界在于:fork test 依赖 RPC 节点(要 archive 节点查历史状态)。延伸:这是 DApp 测试的重点。
- 怎么 fork 历史状态?答:指定区块号,从 RPC 拉取该区块的状态;需要 archive 节点。机制上 fork test 从 RPC 拉取状态。边界在于:archive 节点成本高。延伸:这是 15.3.5 的主题。
- fork test 与主网测试的区别?答:fork test 是本地模拟,不影响主网;主网测试是真实交易,影响主网。机制上 fork test 是本地 EVM。边界在于:fork test 更快、更便宜。延伸:这是测试的分层。
15.4.3-004 fuzz test 怎么写?
一句话结论
fuzz test 就是在测试函数里加参数,测试框架自动生成随机输入,验证不崩溃。
概念解释
- fuzz test:测试函数带参数,测试框架自动生成随机输入。
- 验证:不崩溃(不 revert、不 OOG)。
- Foundry 内置 fuzz,Hardhat 用插件。
- 用途:发现边界情况与崩溃。
原理流程
- 写测试函数带参数:
function testFuzz(uint amount) public { ... }。 - 测试框架自动生成大量随机 amount(如 256 次)。
- 每次运行测试,验证不崩溃。
- 如果崩溃,测试框架报告输入与堆栈。
- 用途:发现边界情况。
代码或图示
// Foundry fuzz test
function testFuzz_Transfer(uint amount) public {
// 假设:amount <= balance
vm.assume(amount < token.balanceOf(address(this)));
token.transfer(alice, amount);
assertEq(token.balanceOf(alice), amount);
}
常见误区
- 误区:fuzz test 验证业务逻辑;正解:fuzz test 只验证不崩溃。
- 误区:fuzz test 手动生成输入;正解:测试框架自动生成。
- 误区:fuzz test 不需要断言;正解:fuzz test 可以加断言(如 invariant)。
追问
- fuzz test 有什么用?答:自动生成大量随机输入,发现边界情况与崩溃;比手动测试覆盖更多场景。机制上 fuzz test 自动生成输入。边界在于:fuzz test 不验证业务逻辑(只验证不崩溃)。延伸:这是测试自动化。
- 怎么限制输入空间?答:用
vm.assume限制输入(如vm.assume(amount < balance))。机制上 fuzz test 自动过滤不符合假设的输入。边界在于:太严格的假设会让 fuzz 无效。延伸:这是 fuzz 测试的技巧。 - fuzz test 与 invariant test 的区别?答:fuzz test 自动生成输入,验证不崩溃;invariant test 验证"永远不变的属性"。机制上 fuzz 是随机输入,invariant 是属性验证。边界在于:两者配合使用。延伸:这是测试的分层。
15.4.3-005 invariant test 是什么?
一句话结论
invariant test 验证"永远不变的属性"(如"总供应 = 所有用户余额之和");测试框架自动生成操作,每次操作后验证属性。
概念解释
- invariant:永远不变的属性(如"余额总和不变")。
- invariant test:自动生成操作,每次操作后验证 invariant。
- 用途:发现意外状态不一致。
- Foundry 内置 invariant,Hardhat 用插件。
原理流程
- 定义 invariant:
function invariant_totalSupply() public { assertEq(token.totalSupply(), sumOfBalances()); } - 定义 handler:自动生成操作(如 transfer、approve)。
- 测试框架自动生成操作序列,每次操作后验证 invariant。
- 如果 invariant 被破坏,测试报告操作序列。
- 用途:发现意外状态不一致。
代码或图示
// Foundry invariant test
function invariant_totalSupply() public {
uint sum = 0;
for (uint i = 0; i < users.length; i++) {
sum += token.balanceOf(users[i]);
}
assertEq(token.totalSupply(), sum);
}
// Handler:自动生成操作
contract Handler is Test {
function transfer(uint amount) public {
token.transfer(alice, amount);
}
}
常见误区
- 误区:invariant test 就是 unit test;正解:invariant test 验证"永远不变的属性"。
- 误区:invariant test 手动写操作;正解:测试框架自动生成操作。
- 误区:invariant test 只验证不崩溃;正解:invariant test 验证属性。
追问
- invariant test 有什么用?答:发现意外状态不一致(如"余额总和不变"被破坏);比 unit test 覆盖更多场景。机制上 invariant test 自动生成操作,验证属性。边界在于:要识别哪些属性是不变的。延伸:这是 15.5 审计的重点。
- 怎么写 invariant?答:识别"永远不变的属性"(如"总供应 = 余额总和"、"价格 = 储备比例");写断言。机制上 invariant test 在每次操作后验证。边界在于:不是所有属性都不变(如"余额会变")。延伸:这是测试设计的重点。
- invariant test 与 fuzz test 的区别?答:fuzz test 自动生成输入,验证不崩溃;invariant test 验证属性。机制上两者配合使用。边界在于:fuzz 是随机输入,invariant 是属性验证。延伸:这是测试的分层。
15.4.3-006 测试中的 mock 怎么用?
一句话结论
mock 是替身合约,模拟外部合约的行为;用于测试不依赖真实外部合约的场景。
概念解释
- mock:替身合约,模拟外部合约行为。
- 用途:测试不依赖真实外部合约(如预言机、Uniswap 池子)。
- 例子:MockOracle 模拟 Chainlink 价格。
- Foundry/Hardhat 都支持 mock。
原理流程
- 写 mock 合约:
contract MockOracle { int256 price = 100; function latestRoundData() external view returns (...) { return (0, price, 0, 0, 0); } } - 测试时用 mock 代替真实合约。
- 可以设置 mock 的行为(如
mockOracle.setPrice(200))。 - 用途:测试不依赖真实外部合约。
- 配合 fork test:fork test 用真实合约,mock 用于单元测试。
代码或图示
// Mock 预言机
contract MockOracle {
int256 public price = 100;
function setPrice(int256 _price) external {
price = _price;
}
function latestRoundData() external view returns (
uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound
) {
return (0, price, 0, 0, 0);
}
}
// 测试
function testPrice() public {
MockOracle mock = new MockOracle();
mock.setPrice(200);
MyContract c = new MyContract(address(mock));
assertEq(c.getPrice(), 200);
}
常见误区
- 误区:mock 就是真实合约;正解:mock 是替身,模拟行为。
- 误区:mock 用于生产;正解:mock 只用于测试。
- 误区:mock 与 fork test 一样;正解:fork test 用真实合约,mock 用于单元测试。
追问
- mock 有什么用?答:测试不依赖真实外部合约(如预言机、Uniswap 池子);可以控制 mock 行为。机制上 mock 是替身。边界在于:mock 不能替代 fork test(真实交互)。延伸:这是测试分层。
- 怎么写 mock?答:写一个合约,实现与真实合约相同的接口,但行为可控制。机制上 mock 实现接口。边界在于:mock 要与真实合约接口一致。延伸:这是测试设计。
- mock 与 fork test 的区别?答:fork test 用真实合约,mock 用于单元测试;两者配合使用。机制上 fork 是真实交互,mock 是隔离测试。边界在于:两者互补。延伸:这是测试分层。
15.4.3-007 覆盖率怎么测?CI 怎么集成?
一句话结论
覆盖率测试用工具统计测试覆盖的代码百分比;CI 集成让测试自动跑(每次提交)。
概念解释
- 覆盖率:测试覆盖的代码百分比(行、分支)。
- 工具:Foundry(forge coverage)、Hardhat(solidity-coverage)。
- CI:持续集成,每次提交自动跑测试。
- 例子:GitHub Actions 跑 Foundry 测试。
原理流程
- 跑覆盖率工具:
forge coverage统计覆盖的代码百分比。 - CI 配置:每次提交自动跑测试(GitHub Actions、GitLab CI)。
- 覆盖率报告:查看哪些代码没被测试覆盖。
- 目标:覆盖率 > 90%。
- CI 失败:测试失败时阻止合并。
代码或图示
# GitHub Actions 示例
name: CI
on: [push]
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- uses: foundry-rs/foundry-toolchain@v1
- run: forge test
- run: forge coverage
常见误区
- 误区:覆盖率 100% 就够了;正解:覆盖率只是参考,关键是测试质量。
- 误区:CI 手动跑;正解:CI 自动跑(每次提交)。
- 误区:覆盖率不重要;正解:覆盖率帮助发现未测试的代码。
追问
- 覆盖率有什么用?答:发现未测试的代码,提高测试质量。机制上覆盖率工具统计执行过的代码。边界在于:覆盖率只是参考,不是目标。延伸:这是工程质量。
- CI 有什么用?答:每次提交自动跑测试,防止引入 bug。机制上 CI 自动跑测试。边界在于:CI 失败时阻止合并。延伸:这是工程实践。
- 怎么提高覆盖率?答:写更多测试(unit、fork、fuzz、invariant);覆盖边界情况。机制上覆盖率是结果。边界在于:不要为了覆盖率而写无意义测试。延伸:这是测试设计。
15.4.3-008 调试技巧有哪些?
一句话结论
调试技巧:console.log(打印变量)、trace(交易执行轨迹)、debugger(断点)。
概念解释
- console.log:在测试里打印变量。
- trace:交易执行轨迹(操作码、Gas)。
- debugger:断点调试。
- Foundry:console.log、forge trace。
原理流程
- console.log:在测试里打印变量(
console.log("balance:", balance))。 - trace:查看交易执行轨迹(操作码、Gas、栈状态)。
- debugger:断点调试(Hardhat Network 支持)。
- 用途:定位 bug。
- Foundry 有 console.log 与 forge trace。
代码或图示
// Foundry console.log
function testDebug() public {
token.transfer(alice, 100);
console.log("alice balance:", token.balanceOf(alice)); // 打印变量
}
// forge trace:查看交易执行轨迹
// $ forge test -vvvv
常见误区
- 误区:调试只能用 console.log;正解:trace 与 debugger 更强大。
- 误区:trace 是生产用;正解:trace 用于调试。
- 误区:console.log 影响 Gas;正解:console.log 只在测试里,不影响生产。
追问
- trace 有什么用?答:查看交易执行轨迹(操作码、Gas、栈状态),定位 bug。机制上 trace 记录每步执行。边界在于:trace 很长,要过滤。延伸:这是调试的重点。
- 怎么调试?答:先用 console.log 打印变量,再用 trace 查看执行轨迹,最后用 debugger 断点。机制上分层调试。边界在于:这是工程实践。延伸:这是开发者的技能。
- Foundry 有什么调试工具?答:console.log、forge trace(-vvvv)、forge debug。机制上 Foundry 内置调试工具。边界在于:Hardhat 也有调试工具。延伸:这是测试框架的功能。
15.4.3-009 部署脚本与多签治理怎么搞?
一句话结论
部署脚本自动化部署流程;多签治理让部署后用多签管理(如 OpenZeppelin Defender)。
概念解释
- 部署脚本:自动化部署(Foundry script、Hardhat deploy)。
- 多签治理:部署后用多签管理(如 OpenZeppelin Defender、Safe)。
- 流程:部署 → 验证源码 → 多签接管。
- 例子:Foundry script 部署 ERC20。
原理流程
- 写部署脚本:Foundry script(Solidity)或 Hardhat deploy(JS)。
- 跑脚本:部署合约、初始化。
- 验证源码:Etherscan 验证合约源码。
- 多签接管:把 admin 转给多签(Safe)。
- 流程:部署 → 验证 → 多签接管。
代码或图示
// Foundry 部署脚本
import "forge-std/Script.sol";
contract DeployScript is Script {
function run() public {
vm.startBroadcast(privateKey);
MyToken token = new MyToken("MyToken", "MTK", 1000000);
vm.stopBroadcast();
}
}
常见误区
- 误区:部署手动搞;正解:部署脚本自动化。
- 误区:部署后用 EOA 管理;正解:部署后用多签管理。
- 误区:验证源码不重要;正解:验证源码让用户信任合约。
追问
- 部署脚本有什么用?答:自动化部署流程,减少人为错误。机制上部署脚本可重复。边界在于:部署脚本要安全(私钥管理)。延伸:这是工程实践。
- 多签治理有什么用?答:部署后用多签管理(如升级、暂停),减少单点风险。机制上多签需要多个签名才能执行。边界在于:这是协议治理。延伸:这是 15.4.2 的主题。
- 怎么验证源码?答:用 Etherscan 验证合约源码,让用户可以查看代码。机制上验证源码让用户信任。边界在于:这是协议透明度。延伸:这是工程实践。
15.4.3-010 测试网与主网怎么隔离?
一句话结论
测试网与主网隔离:用不同的 RPC、不同的私钥、不同的配置;测试网用于测试,主网用于生产。
概念解释
- 测试网:Sepolia、Holesky,用于测试。
- 主网:以太坊主网,生产环境。
- 隔离:不同 RPC、不同私钥、不同配置。
- 流程:测试网测试 → 主网部署。
原理流程
- 测试网:用 Sepolia/Holesky 测试,用测试网 ETH。
- 主网:用主网部署,用主网 ETH。
- 隔离:不同 RPC、不同私钥、不同配置(.env 文件)。
- 流程:测试网测试通过 → 主网部署。
- 注意:测试网与主网的合约地址不同。
代码或图示
测试网 vs 主网隔离:
测试网(Sepolia):
RPC:https://sepolia.infura.io
私钥:测试网私钥
配置:.env.sepolia
ETH:测试网 ETH(免费)
主网:
RPC:https://mainnet.infura.io
私钥:主网私钥(硬件钱包)
配置:.env.mainnet
ETH:主网 ETH(真实)
流程:
测试网测试通过 → 主网部署
常见误区
- 误区:测试网与主网用同一私钥;正解:测试网与主网用不同私钥。
- 误区:测试网与主网合约地址相同;正解:测试网与主网合约地址不同。
- 误区:测试网测试通过就一定安全;正解:测试网与主网环境不同(Gas、合约)。
追问
- 为什么要隔离?答:防止测试网私钥泄露影响主网;测试网与主网环境不同。机制上隔离减少风险。边界在于:这是工程实践。延伸:这是安全的重点。
- 测试网与主网有什么区别?答:测试网用测试 ETH(免费),主网用真实 ETH;测试网与主网合约地址不同。机制上环境隔离。边界在于:测试网测试通过不代表主网安全。延伸:这是测试分层。
- 怎么隔离?答:用不同 RPC、不同私钥、不同配置文件(.env)。机制上环境变量隔离。边界在于:这是工程实践。延伸:这是开发者的技能。
动手练习
练习 1:用 Foundry 写一个完整测试套件
- 任务:为一个 ERC20 合约写 unit test、fuzz test、invariant test。
- 验收标准:
- 能写出 unit test。
- 能写出 fuzz test。
- 能写出 invariant test。
练习 2:写一个 fork test
- 任务:从主网 fork Uniswap 状态,测试 swap 操作。
- 验收标准:
- 能写出 fork test。
- 能模拟用户交互。
- 能验证 swap 结果。
自检清单
- [ ] 能对比 Foundry 与 Hardhat?
- [ ] 能区分四种测试类型?
- [ ] 能写出 fork test?
- [ ] 能写出 fuzz test?
- [ ] 能写出 invariant test?
- [ ] 能使用 mock?
- [ ] 能配置覆盖率与 CI?
- [ ] 能使用调试技巧?
- [ ] 能写部署脚本与多签治理?
- [ ] 能隔离测试网与主网?
延伸阅读
- Foundry 官方文档:测试、fork、fuzz、invariant。
- Hardhat 官方文档:测试、部署。
- OpenZeppelin Defender:多签治理。
- 《Foundry Book》:测试与部署。
待整理清单
- [ ] 补充 Foundry 最新版本特性(待确认)
- [ ] 补充 CI 配置的最佳实践
- [ ] 补充多签治理的实际案例