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 用于暂停时间。

toml
[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,它验证的是异步并发,而不是多线程并行。

rust
#[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):

text
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 运行时并设计同步点,而不要把“并发”和“并行”混为一谈。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

编写 Tokio 异步测试

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通