Rust Testing

作者 affaan-mef648e01899b无许可证275K 个星标收录于 2026年10月8日更新于 2026年10月8日仓库3天前更新

Patrones de pruebas en Rust incluyendo pruebas unitarias, de integración, async, basadas en propiedades, mocking y cobertura. Sigue la metodología TDD.

仅含说明Software Development
AI 生成的概览

Rust 测试模式，涵盖 TDD 下的单元、集成、异步、属性测试、mock、基准测试与覆盖率。

功能
该技能提供编写 Rust 测试的参考指导与代码示例：#[cfg(test)] 模块中的单元测试、tests/ 下的集成测试、使用 tokio 的异步测试、使用 proptest 的属性测试、使用 mockall 的 mock、文档测试以及 Criterion 基准测试。它还说明 TDD 的红-绿-重构流程、使用 cargo-llvm-cov 测量覆盖率、常用 cargo test 命令、最佳实践和一个 CI 示例。它产出的是说明与示例代码，而不是可运行脚本。
适用场景
在为 Rust 代码添加或改进测试、在 Rust 项目中遵循 TDD，或为 Rust crate 配置覆盖率与基准测试时使用。
运行要求
不附带脚本，仅为说明文档。实践示例需要 Rust 工具链与 cargo，可选依赖 tokio、rstest、proptest、mockall 和 criterion 等 crate，以及用于覆盖率的 cargo-llvm-cov。

Patrones de Pruebas Rust

Patrones completos de pruebas en Rust para escribir pruebas confiables y mantenibles siguiendo la metodología TDD.

Cuándo Usar

  • Escribir nuevas funciones, métodos o traits en Rust
  • Agregar cobertura de pruebas a código existente
  • Crear benchmarks para código con requisitos de rendimiento
  • Implementar pruebas basadas en propiedades para validación de entrada
  • Seguir el flujo de trabajo TDD en proyectos Rust

Cómo Funciona

  1. Identificar el código objetivo — Encontrar la función, trait o módulo a probar
  2. Escribir una prueba — Usar #[test] en un módulo #[cfg(test)], rstest para pruebas parametrizadas, o proptest para pruebas basadas en propiedades
  3. Mockear dependencias — Usar mockall para aislar la unidad bajo prueba
  4. Ejecutar pruebas (ROJO) — Verificar que la prueba falla con el error esperado
  5. Implementar (VERDE) — Escribir el código mínimo para que pase
  6. Refactorizar — Mejorar mientras se mantienen las pruebas en verde
  7. Verificar cobertura — Usar cargo-llvm-cov, objetivo 80%+

Flujo de Trabajo TDD en Rust

El Ciclo ROJO-VERDE-REFACTORIZAR

ROJO        → Escribir primero una prueba que falleVERDE       → Escribir el código mínimo para que paseREFACTORIZAR → Mejorar el código manteniendo las pruebas en verdeREPETIR     → Continuar con el siguiente requisito

TDD Paso a Paso en Rust

rust
// ROJO: Escribir la prueba primero, usar todo!() como placeholderpub 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 → panic en 'not yet implemented'
rust
// VERDE: Reemplazar todo!() con implementación mínimapub fn add(a: i32, b: i32) -> i32 { a + b }// cargo test → PASS, luego REFACTORIZAR manteniendo pruebas en verde

Pruebas Unitarias

Organización de Pruebas a Nivel de Módulo

rust
// src/user.rspub 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!("invalid email: {email}"));        }        Ok(Self { name: name.into(), email })    }
    pub fn display_name(&self) -> &str {        &self.name    }}
#[cfg(test)]mod tests {    use super::*;
    #[test]    fn creates_user_with_valid_email() {        let user = User::new("Alice", "[email protected]").unwrap();        assert_eq!(user.display_name(), "Alice");        assert_eq!(user.email, "[email protected]");    }
    #[test]    fn rejects_invalid_email() {        let result = User::new("Bob", "not-an-email");        assert!(result.is_err());        assert!(result.unwrap_err().contains("invalid email"));    }}

Macros de Aserción

rust
assert_eq!(2 + 2, 4);                                    // Igualdadassert_ne!(2 + 2, 5);                                    // Desigualdadassert!(vec![1, 2, 3].contains(&2));                     // Booleanoassert_eq!(value, 42, "expected 42 but got {value}");    // Mensaje personalizadoassert!((0.1_f64 + 0.2 - 0.3).abs() < f64::EPSILON);   // Comparación de flotantes

Pruebas de Errores y Panics

Probar Retornos de Result

rust
#[test]fn parse_returns_error_for_invalid_input() {    let result = parse_config("}{invalid");    assert!(result.is_err());
    // Verificar variante de error específica    let err = result.unwrap_err();    assert!(matches!(err, ConfigError::ParseError(_)));}
#[test]fn parse_succeeds_for_valid_input() -> Result<(), Box<dyn std::error::Error>> {    let config = parse_config(r#"{"port": 8080}"#)?;    assert_eq!(config.port, 8080);    Ok(()) // La prueba falla si algún ? retorna Err}

Probar Panics

rust
#[test]#[should_panic]fn panics_on_empty_input() {    process(&[]);}
#[test]#[should_panic(expected = "index out of bounds")]fn panics_with_specific_message() {    let v: Vec<i32> = vec![];    let _ = v[0];}

Pruebas de Integración

Estructura de Archivos

text
my_crate/├── src/│   └── lib.rs├── tests/              # Pruebas de integración│   ├── api_test.rs     # Cada archivo es un binario de prueba separado│   ├── db_test.rs│   └── common/         # Utilidades de prueba compartidas│       └── mod.rs

Escribir Pruebas de Integración

rust
// tests/api_test.rsuse my_crate::{App, Config};
#[test]fn full_request_lifecycle() {    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");}

Pruebas Async

Con Tokio

rust
#[tokio::test]async fn fetches_data_successfully() {    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 handles_timeout() {    use std::time::Duration;    let result = tokio::time::timeout(        Duration::from_millis(100),        slow_operation(),    ).await;
    assert!(result.is_err(), "should have timed out");}

Patrones de Organización de Pruebas

Pruebas Parametrizadas con rstest

rust
use rstest::{rstest, fixture};
#[rstest]#[case("hello", 5)]#[case("", 0)]#[case("rust", 4)]fn test_string_length(#[case] input: &str, #[case] expected: usize) {    assert_eq!(input.len(), expected);}
// Fixtures#[fixture]fn test_db() -> TestDb {    TestDb::new_in_memory()}
#[rstest]fn test_insert(test_db: TestDb) {    test_db.insert("key", "value");    assert_eq!(test_db.get("key"), Some("value".into()));}

Helpers de Prueba

rust
#[cfg(test)]mod tests {    use super::*;
    /// Crea un usuario de prueba con valores predeterminados sensatos.    fn make_user(name: &str) -> User {        User::new(name, &format!("{name}@test.com")).unwrap()    }
    #[test]    fn user_display() {        let user = make_user("alice");        assert_eq!(user.display_name(), "alice");    }}

Pruebas Basadas en Propiedades con proptest

Pruebas de Propiedades Básicas

rust
use proptest::prelude::*;
proptest! {    #[test]    fn encode_decode_roundtrip(input in ".*") {        let encoded = encode(&input);        let decoded = decode(&encoded).unwrap();        assert_eq!(input, decoded);    }
    #[test]    fn sort_preserves_length(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 sort_produces_ordered_output(mut vec in prop::collection::vec(any::<i32>(), 0..100)) {        vec.sort();        for window in vec.windows(2) {            assert!(window[0] <= window[1]);        }    }}

Estrategias Personalizadas

rust
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 accepts_valid_emails(email in valid_email()) {        assert!(User::new("Test", &email).is_ok());    }}

Mocking con mockall

Mocking Basado en Traits

rust
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 service_returns_user_when_found() {    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 service_returns_none_when_not_found() {    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());}

Pruebas de Documentación

Documentación Ejecutable

rust
/// Suma dos números.////// # Examples////// ```/// 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}
/// Parsea una cadena de configuración.////// # Errors////// Retorna `Err` si la entrada no es TOML válido.////// ```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!()}

Benchmarks con Criterion

toml
# Cargo.toml[dev-dependencies]criterion = { version = "0.5", features = ["html_reports"] }
[[bench]]name = "benchmark"harness = false
rust
// benches/benchmark.rsuse 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);

Cobertura de Pruebas

Ejecutar Cobertura

bash
# Instalar: cargo install cargo-llvm-cov (o usar taiki-e/install-action en CI)cargo llvm-cov                    # Resumencargo llvm-cov --html             # Reporte HTMLcargo llvm-cov --lcov > lcov.info # Formato LCOV para CIcargo llvm-cov --fail-under-lines 80  # Fallar si está por debajo del umbral

Objetivos de Cobertura

Tipo de CódigoObjetivo
Lógica de negocio crítica100%
API pública90%+
Código general80%+
Bindings generados / FFIExcluir

Comandos de Prueba

bash
cargo test                        # Ejecutar todas las pruebascargo test -- --nocapture         # Mostrar salida de printlncargo test test_name              # Ejecutar pruebas que coincidan con el patróncargo test --lib                  # Solo pruebas unitariascargo test --test api_test        # Solo pruebas de integracióncargo test --doc                  # Solo pruebas de documentacióncargo test --no-fail-fast         # No detener al primer fallocargo test -- --ignored           # Ejecutar pruebas ignoradas

Buenas Prácticas

HACER:

  • Escribir pruebas PRIMERO (TDD)
  • Usar módulos #[cfg(test)] para pruebas unitarias
  • Probar comportamiento, no implementación
  • Usar nombres de prueba descriptivos que expliquen el escenario
  • Preferir assert_eq! sobre assert! para mejores mensajes de error
  • Usar ? en pruebas que retornan Result para salida de errores más limpia
  • Mantener las pruebas independientes — sin estado mutable compartido

NO HACER:

  • Usar #[should_panic] cuando se puede probar Result::is_err()
  • Mockear todo — preferir pruebas de integración cuando sea factible
  • Ignorar pruebas inestables — corregirlas o ponerlas en cuarentena
  • Usar sleep() en pruebas — usar canales, barreras o tokio::time::pause()
  • Omitir las pruebas de rutas de error

Integración con CI

yaml
# GitHub Actionstest:  runs-on: ubuntu-latest  steps:    - uses: actions/checkout@v4    - uses: dtolnay/rust-toolchain@stable      with:        components: clippy, rustfmt
    - name: Check formatting      run: cargo fmt --check
    - name: Clippy      run: cargo clippy -- -D warnings
    - name: Run tests      run: cargo test
    - uses: taiki-e/install-action@cargo-llvm-cov
    - name: Coverage      run: cargo llvm-cov --fail-under-lines 80

Recuerda: Las pruebas son documentación. Muestran cómo debe usarse tu código. Escríbelas con claridad y mantenlas actualizadas.

来源与署名

来源：affaan-m/ecc位于docs/es/skills/rust-testing提交ef648e0

许可证： 无许可证

内容归原作者所有。SourceWeft 从公开仓库中收录这些内容。

举报或申请下架

更多来自 affaan-m/ecc 的技能

Vue Patterns

affaan-m

Vue 3 Composition API、组件架构、Pinia 状态管理、Vue Router 与 Nuxt SSR 模式的参考指南。

Software Development275K3天前更新

Uncloud

affaan-m

使用 uc CLI 管理 Uncloud 集群的参考指南：部署服务、Caddy 入口、端口、扩缩容与日志。

DevOps & Cloud275K3天前更新

Team Agent Orchestration

affaan-m

以团队方式协调多个 AI 智能体，使用工作项、看板状态、分支隔离与合并门禁。

AI & Agents275K3天前更新

Tasteforge Video

affaan-m

Use for file-driven multimodal image, video, and 3D-asset discovery; taste interviews; distill or apply workflows; style-pack validation; editable EDL/FCPXML export; provenance audits; and offline planning that must fail closed before provider generation.

待分类275K3天前更新

Taste

affaan-m

为音乐视频和短视频剪辑定义 angelcore / cloud-trance / hyperpop 视觉方向，包含氛围、剪辑语法与按节拍映射的分镜方案。

Design & Creative275K3天前更新

Social Publisher

affaan-m

通过 SocialClaw 工作区 API 在 13 个平台上安排和发布社交媒体帖子。

Marketing & Sales275K3天前更新

更多Software Development技能

Playground

anthropics

精选

构建自包含的交互式 HTML 演练场，包含控件、实时预览和可复制的提示词输出。

Software Development37K今天更新

M5 Onboard

anthropics

精选

通过 USB 检测 M5Stack ESP32 开发板，刷写 UIFlow 2.0 固件并安装 MicroPython 应用包。

Software Development37K今天更新

Cardputer Buddy

anthropics

精选

指导迭代 Cardputer-Adv 的 MicroPython 应用包：添加应用、通过 USB 串口推送文件、查看日志并运行 REPL 命令。

Software Development37K今天更新

Testing Strategy

anthropics

精选

设计测试策略与测试计划，涵盖测试类型、覆盖率目标与示例测试用例。

Software Development27K今天更新

Tech Debt

anthropics

精选

识别、分类并排序技术债务，产出评分后的待办清单与分阶段整改计划。

Software Development27K今天更新

System Design

anthropics

精选

通过需求、高层设计、深入设计、扩展与权衡分析来指导系统与架构设计。

Software Development27K今天更新