🚀 快速安装

复制以下命令并运行，立即安装此 Skill：

npx skills add https://skills.sh/affaan-m/everything-claude-code/rust-testing

💡 提示：需要 Node.js 和 NPM

Rust 测试模式

全面的 Rust 测试模式，用于编写遵循 TDD 方法论的可靠、可维护的测试。

使用时机

  • 编写新的 Rust 函数、方法或 trait
  • 为现有代码添加测试覆盖
  • 为性能关键代码创建基准测试
  • 为输入验证实现基于属性的测试
  • 在 Rust 项目中遵循 TDD 工作流

工作原理

  1. 确定目标代码 — 找到要测试的函数、trait 或模块
  2. 编写测试 — 在 #[cfg(test)] 模块中使用 #[test]，使用 rstest 进行参数化测试，或使用 proptest 进行基于属性的测试
  3. 模拟依赖项 — 使用 mockall 隔离被测试单元
  4. 运行测试 (RED) — 验证测试以预期的错误失败
  5. 实现 (GREEN) — 编写最少的代码使其通过
  6. 重构 — 在保持测试通过的情况下改进代码
  7. 检查覆盖率 — 使用 cargo-llvm-cov，目标达到 80%+

Rust 的 TDD 工作流

红-绿-重构循环

RED     → 首先编写一个失败的测试
GREEN   → 编写最少的代码使测试通过
REFACTOR → 在保持测试通过的情况下改进代码
REPEAT  → 继续下一个需求

Rust 中逐步 TDD

// RED: 先编写测试，使用 todo!() 作为占位符
pub fn add(a: i32, b: i32) -> i32 { todo!() }

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_add() { assert_eq!(add(2, 3), 5); }
}
// cargo test → panics at 'not yet implemented'

// GREEN: 用最简实现替换 todo!()
pub fn add(a: i32, b: i32) -> i32 { a + b }
// cargo test → PASS, 然后 REFACTOR，同时保持测试通过

单元测试

模块级测试组织

// src/user.rs
pub struct User {
    pub name: String,
    pub email: String,
}

impl User {
    pub fn new(name: impl Into<String>, email: impl Into<String>) -> Result<Self, String> {
        let email = email.into();
        if !email.contains('@') {
            return Err(format!("无效的邮箱: {email}"));
        }
        Ok(Self { name: name.into(), email })
    }

    pub fn display_name(&self) -> &str {
        &self.name
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn 使用有效邮箱创建用户() {
        let user = User::new("Alice", "alice@example.com").unwrap();
        assert_eq!(user.display_name(), "Alice");
        assert_eq!(user.email, "alice@example.com");
    }

    #[test]
    fn 拒绝无效邮箱() {
        let result = User::new("Bob", "not-an-email");
        assert!(result.is_err());
        assert!(result.unwrap_err().contains("无效的邮箱"));
    }
}

断言宏

assert_eq!(2 + 2, 4);                                    // 相等
assert_ne!(2 + 2, 5);                                    // 不相等
assert!(vec![1, 2, 3].contains(&2));                     // 布尔值
assert_eq!(value, 42, "期望 42 但得到 {value}");    // 自定义消息
assert!((0.1_f64 + 0.2 - 0.3).abs() < f64::EPSILON);   // 浮点数比较

错误和 Panic 测试

测试 Result 返回

#[test]
fn 解析无效输入时返回错误() {
    let result = parse_config("}{invalid");
    assert!(result.is_err());

    // 断言特定错误变体
    let err = result.unwrap_err();
    assert!(matches!(err, ConfigError::ParseError(_)));
}

#[test]
fn 解析有效输入时成功() -> Result<(), Box<dyn std::error::Error>> {
    let config = parse_config(r#"{"port": 8080}"#)?;
    assert_eq!(config.port, 8080);
    Ok(()) // 如果任何 ? 返回 Err，测试将失败
}

测试 Panic

#[test]
#[should_panic]
fn 空输入时触发 panic() {
    process(&[]);
}

#[test]
#[should_panic(expected = "索引超出范围")]
fn 带特定消息触发 panic() {
    let v: Vec<i32> = vec![];
    let _ = v[0];
}

集成测试

文件结构

my_crate/
├── src/
│   └── lib.rs
├── tests/              # 集成测试
│   ├── api_test.rs     # 每个文件是一个独立的测试二进制文件
│   ├── db_test.rs
│   └── common/         # 共享测试工具
│       └── mod.rs

编写集成测试

// tests/api_test.rs
use my_crate::{App, Config};

#[test]
fn 完整请求生命周期() {
    let config = Config::test_default();
    let app = App::new(config);

    let response = app.handle_request("/health");
    assert_eq!(response.status, 200);
    assert_eq!(response.body, "OK");
}

异步测试

使用 Tokio

#[tokio::test]
async fn 成功获取数据() {
    let client = TestClient::new().await;
    let result = client.get("/data").await;
    assert!(result.is_ok());
    assert_eq!(result.unwrap().items.len(), 3);
}

#[tokio::test]
async fn 处理超时() {
    use std::time::Duration;
    let result = tokio::time::timeout(
        Duration::from_millis(100),
        slow_operation(),
    ).await;

    assert!(result.is_err(), "应该超时");
}

测试组织模式

使用 rstest 的参数化测试

use rstest::{rstest, fixture};

#[rstest]
#[case("hello", 5)]
#[case("", 0)]
#[case("rust", 4)]
fn 测试字符串长度(#[case] input: &str, #[case] expected: usize) {
    assert_eq!(input.len(), expected);
}

// Fixtures
#[fixture]
fn test_db() -> TestDb {
    TestDb::new_in_memory()
}

#[rstest]
fn 测试插入(test_db: TestDb) {
    test_db.insert("key", "value");
    assert_eq!(test_db.get("key"), Some("value".into()));
}

测试辅助函数

#[cfg(test)]
mod tests {
    use super::*;

    /// 创建带有合理默认值的测试用户。
    fn make_user(name: &str) -> User {
        User::new(name, &format!("{name}@test.com")).unwrap()
    }

    #[test]
    fn 用户显示名称() {
        let user = make_user("alice");
        assert_eq!(user.display_name(), "alice");
    }
}

使用 proptest 的基于属性测试

基本属性测试

use proptest::prelude::*;

proptest! {
    #[test]
    fn 编解码往返(input in ".*") {
        let encoded = encode(&input);
        let decoded = decode(&encoded).unwrap();
        assert_eq!(input, decoded);
    }

    #[test]
    fn 排序保持长度(mut vec in prop::collection::vec(any::<i32>(), 0..100)) {
        let original_len = vec.len();
        vec.sort();
        assert_eq!(vec.len(), original_len);
    }

    #[test]
    fn 排序产生有序输出(mut vec in prop::collection::vec(any::<i32>(), 0..100)) {
        vec.sort();
        for window in vec.windows(2) {
            assert!(window[0] <= window[1]);
        }
    }
}

自定义策略

use proptest::prelude::*;

fn valid_email() -> impl Strategy<Value = String> {
    ("[a-z]{1,10}", "[a-z]{1,5}")
        .prop_map(|(user, domain)| format!("{user}@{domain}.com"))
}

proptest! {
    #[test]
    fn 接受有效邮箱(email in valid_email()) {
        assert!(User::new("Test", &email).is_ok());
    }
}

使用 mockall 进行模拟

基于 Trait 的模拟

use mockall::{automock, predicate::eq};

#[automock]
trait UserRepository {
    fn find_by_id(&self, id: u64) -> Option<User>;
    fn save(&self, user: &User) -> Result<(), StorageError>;
}

#[test]
fn 找到用户时服务返回用户() {
    let mut mock = MockUserRepository::new();
    mock.expect_find_by_id()
        .with(eq(42))
        .times(1)
        .returning(|_| Some(User { id: 42, name: "Alice".into() }));

    let service = UserService::new(Box::new(mock));
    let user = service.get_user(42).unwrap();
    assert_eq!(user.name, "Alice");
}

#[test]
fn 未找到用户时服务返回空() {
    let mut mock = MockUserRepository::new();
    mock.expect_find_by_id()
        .returning(|_| None);

    let service = UserService::new(Box::new(mock));
    assert!(service.get_user(99).is_none());
}

文档测试

可执行的文档

/// 将两个数相加。
///
/// # 示例
///
/// ```
/// use my_crate::add;
///
/// assert_eq!(add(2, 3), 5);
/// assert_eq!(add(-1, 1), 0);
/// ```
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

/// 解析配置字符串。
///
/// # 错误
///
/// 如果输入不是有效的 TOML，则返回 `Err`。
///
/// ```no_run
/// use my_crate::parse_config;
///
/// let config = parse_config(r#"port = 8080"#).unwrap();
/// assert_eq!(config.port, 8080);
/// ```
///
/// ```no_run
/// use my_crate::parse_config;
///
/// assert!(parse_config("}{invalid").is_err());
/// ```
pub fn parse_config(input: &str) -> Result<Config, ParseError> {
    todo!()
}

使用 Criterion 进行基准测试

# Cargo.toml
[dev-dependencies]
criterion = { version = "0.5", features = ["html_reports"] }

[[bench]]
name = "benchmark"
harness = false

// benches/benchmark.rs
use criterion::{black_box, criterion_group, criterion_main, Criterion};

fn fibonacci(n: u64) -> u64 {
    match n {
        0 | 1 => n,
        _ => fibonacci(n - 1) + fibonacci(n - 2),
    }
}

fn bench_fibonacci(c: &mut Criterion) {
    c.bench_function("fib 20", |b| b.iter(|| fibonacci(black_box(20))));
}

criterion_group!(benches, bench_fibonacci);
criterion_main!(benches);

测试覆盖率

运行覆盖率

# 安装：cargo install cargo-llvm-cov（或在 CI 中使用 taiki-e/install-action）
cargo llvm-cov                    # 摘要
cargo llvm-cov --html             # HTML 报告
cargo llvm-cov --lcov > lcov.info # LCOV 格式，用于 CI
cargo llvm-cov --fail-under-lines 80  # 低于阈值则失败

覆盖率目标

代码类型 目标
关键业务逻辑 100%
公共 API 90%+
一般代码 80%+
生成代码 / FFI 绑定 排除

测试命令

cargo test                        # 运行所有测试
cargo test -- --nocapture         # 显示 println 输出
cargo test 测试名称              # 运行匹配模式的测试
cargo test --lib                  # 仅单元测试
cargo test --test api_test        # 仅集成测试
cargo test --doc                  # 仅文档测试
cargo test --no-fail-fast         # 不因首次失败而停止
cargo test -- --ignored           # 运行忽略的测试

最佳实践

应该做：

  • 先写测试（TDD）
  • 使用 #[cfg(test)] 模块进行单元测试
  • 测试行为，而不是实现
  • 使用描述性的测试名称来解释场景
  • 优先使用 assert_eq! 而不是 assert! 以获得更好的错误消息
  • 在返回 Result 的测试中使用 ? 以获得更清晰的错误输出
  • 保持测试独立 —— 不共享可变状态

不应该做：

  • 在可以用 Result::is_err() 测试时使用 #[should_panic]
  • 模拟所有内容 —— 尽可能优先使用集成测试
  • 忽略不稳定的测试 —— 修复或隔离它们
  • 在测试中使用 sleep() —— 使用通道、屏障或 tokio::time::pause()
  • 跳过错误路径测试

CI 集成

# GitHub Actions
test:
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v4
    - uses: dtolnay/rust-toolchain@stable
      with:
        components: clippy, rustfmt

    - name: 检查格式
      run: cargo fmt --check

    - name: Clippy
      run: cargo clippy -- -D warnings

    - name: 运行测试
      run: cargo test

    - uses: taiki-e/install-action@cargo-llvm-cov

    - name: 覆盖率
      run: cargo llvm-cov --fail-under-lines 80

记住：测试就是文档。它们展示了代码的预期用法。清晰地编写它们并保持更新。

📄 原始文档

完整文档（英文）：

https://skills.sh/affaan-m/everything-claude-code/rust-testing

💡 提示：点击上方链接查看 skills.sh 原始英文文档，方便对照翻译。

声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。