Rust / 系统课时
编写 Tokio 异步测试
编写 Tokio 异步测试
异步代码的测试重点不只是“能否返回正确值”,还要覆盖错误、超时和并发路径,并避免真实网络与真实等待让测试变慢或不稳定。本节用 #[tokio::test]、暂停时间和假客户端构造一组可重复执行的 Tokio 测试。
学习目标
- 为异步测试选择明确的 Tokio 运行时配置
- 覆盖成功、错误、超时和并发四类关键路径
- 用虚拟时间与假依赖替代真实外部服务和真实等待
让每个测试拥有独立运行时
#[tokio::test] 会为测试函数建立 Tokio 运行时,因此测试体可以直接 .await。这里显式选择 current_thread,并通过 start_paused = true 从暂停的 Tokio 时钟开始;当运行时没有其他可执行工作时,时间会推进到下一个 Tokio 定时器,所以几十毫秒甚至几秒的逻辑延迟不必真的等待同样长的墙上时间。
暂停时间只影响 tokio::time 的时钟和定时器,不会让 std::thread::sleep 变快。测试超时逻辑时应使用 tokio::time::sleep,并启用 test-util;不要在异步测试里用阻塞睡眠模拟慢服务。
用假依赖覆盖四条路径
下面的 Cargo.toml 是完整最小配置。测试使用单线程运行时,因此只需要 rt;test-util 用于暂停时间。
[package]
name = "tokio-test-demo"
version = "0.1.0"
edition = "2021"
[dependencies]
tokio = { version = "1", features = ["macros", "rt", "time", "test-util"] }保存下面代码为 src/lib.rs。FakeClient 不访问网络,只用固定延迟和固定结果模拟外部服务;原子计数器用于验证调用次数。并发测试用 tokio::join! 同时推进两个 Future,它验证的是异步并发,而不是多线程并行。
#[cfg(test)]
mod tests {
use std::sync::atomic::{AtomicUsize, Ordering};
use tokio::time::{sleep, timeout, Duration, Instant};
struct FakeClient {
delay: Duration,
result: Result<&'static str, &'static str>,
calls: AtomicUsize,
}
impl FakeClient {
fn new(delay: Duration, result: Result<&'static str, &'static str>) -> Self {
Self {
delay,
result,
calls: AtomicUsize::new(0),
}
}
async fn fetch(&self) -> Result<&'static str, &'static str> {
self.calls.fetch_add(1, Ordering::SeqCst);
sleep(self.delay).await;
self.result
}
fn calls(&self) -> usize {
self.calls.load(Ordering::SeqCst)
}
}
async fn load(
client: &FakeClient,
budget: Duration,
) -> Result<&'static str, &'static str> {
match timeout(budget, client.fetch()).await {
Ok(result) => result,
Err(_) => Err("timeout"),
}
}
#[tokio::test(flavor = "current_thread", start_paused = true)]
async fn success_path() {
let client = FakeClient::new(Duration::from_millis(10), Ok("pong"));
assert_eq!(load(&client, Duration::from_millis(50)).await, Ok("pong"));
assert_eq!(client.calls(), 1);
}
#[tokio::test(flavor = "current_thread", start_paused = true)]
async fn error_path() {
let client = FakeClient::new(
Duration::from_millis(10),
Err("upstream rejected"),
);
assert_eq!(
load(&client, Duration::from_millis(50)).await,
Err("upstream rejected")
);
assert_eq!(client.calls(), 1);
}
#[tokio::test(flavor = "current_thread", start_paused = true)]
async fn timeout_path() {
let client = FakeClient::new(Duration::from_millis(100), Ok("late"));
assert_eq!(
load(&client, Duration::from_millis(20)).await,
Err("timeout")
);
assert_eq!(client.calls(), 1);
}
#[tokio::test(flavor = "current_thread", start_paused = true)]
async fn concurrent_path() {
let client = FakeClient::new(Duration::from_millis(50), Ok("ok"));
let started = Instant::now();
// 两个 Future 同时等待同一个虚拟时钟,而不是串行等待 100 ms。
let (left, right) = tokio::join!(
load(&client, Duration::from_millis(100)),
load(&client, Duration::from_millis(100))
);
assert_eq!(left, Ok("ok"));
assert_eq!(right, Ok("ok"));
assert_eq!(client.calls(), 2);
assert_eq!(started.elapsed(), Duration::from_millis(50));
}
}预期输出(执行 cargo test --lib --quiet):
running 4 tests
....
test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in <TIME>s<TIME> 是实际测试耗时,机器不同会有差异。四个测试虽然都包含 Tokio 定时器,但暂停时间让逻辑延迟通过虚拟时钟推进,而不需要真实等待 10、20、50 或 100 ms。
避免异步测试里的假稳定
真实外部服务不适合承担单元测试依赖:DNS、网络、限流、账号状态和测试数据都会引入随机失败。更稳妥的做法是把 I/O 边界抽象出来,在单元测试中注入 fake 或 mock,只在少量集成测试里连接真实服务。
另一个常见错误是在已经运行于 #[tokio::test] 的函数中再次创建运行时并 block_on。测试函数本身已经处于 Tokio 运行时,直接 .await 即可。涉及定时器时优先使用 Tokio 的虚拟时间;涉及真正的多线程竞争时,再单独使用 multi_thread 运行时并设计同步点,而不要把“并发”和“并行”混为一谈。