Rust测试工具库bp-test-utils使用指南

bp-test-utils是一个旨在简化Rust测试流程的工具库，提供了高效编写单元测试和集成测试的实用功能。

主要功能

1. 简化测试用例编写
2. 提供常用测试断言扩展
3. 支持测试数据生成
4. 包含测试环境管理工具

安装

在Cargo.toml中添加依赖：

[dev-dependencies]
bp-test-utils = "0.1"  # 请使用最新版本号

基本使用方法

1. 扩展断言功能

use bp_test_utils::assertions::*;

#[test]
fn test_extended_assertions() {
    let s = "hello world";
    
    // 字符串包含断言
    assert_contains!(s, "hello");
    
    // 近似相等断言(浮点数比较)
    assert_approx_eq!(0.1 + 0.2, 0.3, 1e-10);
}

2. 测试数据生成

use bp_test_utils::generators::*;

#[test]
fn test_data_generation() {
    // 生成随机字符串
    let random_str = random_string(10);
    assert_eq!(random_str.len(), 10);
    
    // 生成随机数字
    let random_num = random_number(1..=100);
    assert!(random_num >= 1 && random_num <= 100);
}

3. 测试夹具(Test Fixtures)

use bp_test_utils::fixture;

#[fixture]
struct TestDatabase {
    connection: DatabaseConnection,
}

impl TestDatabase {
    fn new() -> Self {
        // 初始化测试数据库连接
        let connection = DatabaseConnection::in_memory().unwrap();
        Self { connection }
    }
}

#[test]
fn test_database_operations(test_db: TestDatabase) {
    // 使用自动初始化的测试数据库
    test_db.connection.execute("CREATE TABLE test(id INTEGER)");
    // ...测试逻辑
}

4. 并行测试支持

use bp_test_utils::parallel;

#[parallel]  // 并行执行标记
#[test]
fn test_parallel_1() {
    // 测试代码
}

#[parallel]
#[test]
fn test_parallel_2() {
    // 测试代码
}

5. 性能测试辅助

use bp_test_utils::bench;

#[bench]
fn benchmark_test(b: &mut Bencher) {
    b.iter(|| {
        // 需要测试性能的代码
        expensive_operation();
    });
}

高级功能

1. 测试覆盖率收集

use bp_test_utils::coverage;

#[test]
fn test_with_coverage() {
    coverage::start();
    
    // 测试代码
    
    let coverage_data = coverage::collect();
    assert!(coverage_data.rate() > 0.8);
}

2. 模拟(Mock)支持

use bp_test_utils::mock;

#[test]
fn test_with_mock() {
    let mock_service = mock!(MyService, {
        get_data: |_| Ok("mocked data".to_string())
    });
    
    let result = mock_service.get_data("input");
    assert_eq!(result.unwrap(), "mocked data");
}

最佳实践

1. 对于需要共享的测试资源，使用#[fixture]来管理生命周期
2. 独立测试可以使用#[parallel]加速执行
3. 复杂断言使用库提供的扩展断言提高可读性
4. 性能敏感测试使用#[bench]标记

注意事项

1. 测试代码仍然应该保持简单清晰
2. 避免过度依赖测试工具库而降低测试可读性
3. 生产代码不应依赖测试工具库中的功能

bp-test-utils通过提供这些实用功能，可以显著提高Rust项目的测试效率和测试代码质量。

完整示例demo

// 测试模块
#[cfg(test)]
mod tests {
    use super::*;
    use bp_test_utils::{assertions::*, generators::*, fixture, parallel, bench};
    
    // 1. 扩展断言测试
    #[test]
    fn test_assertions() {
        let vec = vec![1, 2, 3];
        assert_contains!(vec, 2);  // 集合包含断言
        assert_approx_eq!(0.1 + 0.2, 0.3, 1e-10);  // 浮点数近似相等
    }
    
    // 2. 测试数据生成
    #[test]
    fn test_generators() {
        let email = random_email();  // 生成随机邮箱
        assert_contains!(email, "@");
        
        let age = random_number(18..=60);  // 生成18-60的随机年龄
        assert!(age >= 18 && age <= 60);
    }
    
    // 3. 测试夹具
    #[fixture]
    struct TestConfig {
        timeout: u64,
    }
    
    impl Default for TestConfig {
        fn default() -> Self {
            Self { timeout: 30 }
        }
    }
    
    #[test]
    fn test_with_fixture(config: TestConfig) {
        assert!(config.timeout > 0);
    }
    
    // 4. 并行测试
    #[parallel]
    #[test]
    fn parallel_test_1() {
        assert_eq!(1 + 1, 2);
    }
    
    #[parallel]
    #[test]
    fn parallel_test_2() {
        assert_eq!(2 * 2, 4);
    }
    
    // 5. 性能测试
    #[bench]
    fn bench_sort(b: &mut Bencher) {
        let mut data = vec![3, 1, 4, 1, 5, 9, 2, 6];
        b.iter(|| {
            data.sort();
        });
    }
    
    // 6. 模拟测试
    #[test]
    fn test_mock_service() {
        let mock_db = mock!(Database, {
            query: |_| Ok(vec![1, 2, 3]),
            execute: |_| Ok(1)
        });
        
        assert_eq!(mock_db.query("SELECT * FROM table").unwrap(), vec![1, 2, 3]);
    }
    
    // 7. 覆盖率测试
    #[test]
    fn test_coverage() {
        coverage::start();
        
        let result = some_function();
        assert!(result.is_ok());
        
        let coverage = coverage::collect();
        assert!(coverage.rate() > 0.5);
    }
}