Rust 异步测试与调试实战指南

// tests/lib.rs
use my_crate::read_file;
use tokio::test;
use std::io;

#[tokio::test]
async fn test_read_file_success() {
    let result = read_file("valid.txt").await;
    assert!(result.is_ok());
    assert_eq!(result.unwrap(), "Hello, World!");
}

#[tokio::test]
async fn test_read_file_error() {
    let result = read_file("invalid").await;
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().kind(), io::ErrorKind::NotFound);
}

对于耗时操作，务必加上超时保护：

// tests/lib.rs
use my_crate::long_running_task;
use tokio::test;
use tokio::time::timeout;
use std::time::Duration;

#[tokio::test]
async fn test_long_running_task_timeout() {
    let result = timeout(Duration::from_secs(3), long_running_task()).await;
    assert!(result.is_err());
}

集成测试实践

当多个服务协同工作时，集成测试必不可少。这包括服务间通信、数据库交互以及外部依赖的处理。

服务间通信

通过 HTTP 客户端直接调用服务接口，验证健康状态或业务逻辑：

// tests/integration.rs
use tokio::test;
use reqwest::Client;

#[tokio::test]
async fn test_user_sync_service() {
    let client = Client::new();
    let response = client.get("http://localhost:3000/health").send().await.unwrap();
    assert_eq!(response.status(), 200);
}

数据库与缓存

连接池管理是数据库测试的重点，Redis 操作也需类似处理。

// tests/integration.rs
use tokio::test;
use sqlx::PgPool;
use my_crate::db;

#[tokio::test]
async fn test_create_pool() {
    let config = db::DbConfig {
        url: "postgresql://test:test@localhost:5432/test_db".to_string(),
    };
    let pool = db::create_pool(config).await.unwrap();
    assert!(pool.is_connected().await);
}

外部依赖模拟

直接调用第三方 API 既慢又不稳定，推荐使用 wiremock 进行本地模拟。

// tests/integration.rs
use tokio::test;
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
use my_crate::http::UserApiClient;

#[tokio::test]
async fn test_get_user() {
    let mock_server = MockServer::start().await;
    let client = UserApiClient::new(&mock_server.uri());
    let user_id = 1;
    let mock_response = serde_json::json!({"id": user_id, "name": "Test User", "email": "[email protected]"});
    
    Mock::given(method("GET"))
        .and(path(format!("/users/{}", user_id)))
        .respond_with(ResponseTemplate::new(200).set_body_json(mock_response))
        .mount(&mock_server)
        .await;

    let user = client.get_user(user_id).await.unwrap();
    assert_eq!(user.id, user_id);
    assert_eq!(user.name, "Test User");
}

性能测试工具

除了功能正确性，系统的吞吐量与延迟同样重要。

常用工具

• Wrk：适合高并发 HTTP 压测。
• K6：脚本化强，支持实时监控。
• Locust：分布式 Python 压测。

实战示例

使用 Wrk 测试 API 接口：

wrk -t12 -c100 -d10s "http://localhost:3000/api/users"

使用 K6 脚本进行更细粒度的控制：

import http from 'k6/http';
import { check, group } from 'k6';

export let options = {
    vus: 100,
    duration: '10s',
};

export default function() {
    group('Test Users API', function() {
        let response = http.get('http://localhost:3000/api/users');
        check(response, {
            'status is 200': (r) => r.status === 200,
            'response time < 500ms': (r) => r.timings.duration < 500,
        });
    });
}

调试技巧与工具

异步程序的调试比同步更棘手，因为涉及堆栈切换和事件循环。

日志系统

配置 log 和 env_logger 是第一步。在生产环境中，建议结合 tracing 获取更详细的上下文信息。

// src/main.rs
use log::{info, error};
use simple_logger::SimpleLogger;
use log::LevelFilter;

#[tokio::main]
async fn main() {
    SimpleLogger::new().with_level(LevelFilter::Info).init().unwrap();
    // ...
}

Tokio Console

这是观察 Tokio 运行时内部状态的利器，能看到任务排队、时长等信息。启动时需要开启未稳定特性：

RUSTFLAGS="--cfg tokio_unstable" RUST_LOG=info cargo run -- tokio-console

内存与崩溃分析

GDB 和 LLDB 依然可用，但要注意异步上下文。Valgrind 和 AddressSanitizer 则能有效检测内存泄漏。

# Valgrind
cargo run --release -- --test valgrind --leak-check=yes target/release/my_crate

# ASan
RUSTFLAGS="-Z sanitizer=address" cargo run --release

最佳实践总结

1. TDD 驱动：先写测试再实现，尤其是异步边界条件。
2. 覆盖率统计：利用 cargo-tarpaulin 确保关键路径被覆盖。
3. 隔离问题：复现问题时尽量缩小范围，定位到最小代码片段。
4. 资源优化：合理配置线程数，避免频繁内存分配。

掌握这些方法，能让你的 Rust 异步应用更加健壮可靠。