Pruebas en Rust: unit, integration, e2e de la A a la Z

Introducción: Por qué las pruebas en Rust no solo están de moda, sino que son necesarias

Rust es un lenguaje que se destaca por su seguridad de memoria y alto rendimiento. Sin embargo, incluso el compilador más estricto no garantiza la corrección de la lógica de negocio. Aquí es donde entran en escena las pruebas. En Rust, el sistema de tipos y propiedad ya elimina toda una clase de errores en la etapa de compilación, pero las pruebas unitarias, de integración y de extremo a extremo (e2e) permiten asegurarse de que su código hace exactamente lo que usted planeó.

En este artículo, analizaremos tres niveles de pruebas en Rust: desde pruebas unitarias aisladas hasta escenarios e2e completos. Aprenderá a escribir pruebas efectivas, qué herramientas utilizar y cómo organizar la infraestructura de pruebas. El material será útil tanto para principiantes que recién comienzan a estudiar Rust, como para desarrolladores experimentados que deseen sistematizar sus conocimientos.

1. Pruebas unitarias: la base fundamental

Las pruebas unitarias son el nivel de verificación más rápido y aislado. Prueban funciones, métodos o módulos pequeños individuales, separados de las dependencias externas. En Rust, las pruebas unitarias se colocan normalmente en el mismo archivo que el código a probar, dentro del módulo tests.

1.1. Estructura y atributos

Para crear una prueba unitaria se utiliza el atributo #[test]. La función marcada con él no acepta argumentos y no devuelve nada (o devuelve un Result). Si dentro de la función ocurre un pánico (panic), la prueba se considera fallida.

// src/lib.rs\npub fn add(a: i32, b: i32) -> i32 {\n    a + b\n}\n\n#[cfg(test)]\nmod tests {\n    use super::*;\n\n    #[test]\n    fn test_add() {\n        assert_eq!(add(2, 2), 4);\n    }\n\n    #[test]\n    fn test_add_negative() {\n        assert_eq!(add(-1, -1), -2);\n    }\n}

Observe #[cfg(test)]. Este atributo garantiza que el módulo con pruebas se compile solo al ejecutar las pruebas (cargo test). No se incluirá en la compilación de producción.

1.2. Macros para verificaciones

Rust proporciona varias macros para verificar afirmaciones:

\n
• assert!(expr) — verifica que la expresión sea verdadera.
\n
• assert_eq!(left, right) — verifica la igualdad (requiere PartialEq y Debug).
\n
• assert_ne!(left, right) — verifica la desigualdad.
\n
• panic!("message") — provoca un pánico forzado (se usa para probar errores).
\n

1.3. Pruebas de pánicos con should_panic

Si su función debe entrar en pánico con datos de entrada incorrectos, use el atributo #[should_panic]:

pub fn divide(a: f64, b: f64) -> f64 {\n    if b == 0.0 {\n        panic!("Division by zero");\n    }\n    a / b\n}\n\n#[cfg(test)]\nmod tests {\n    use super::*;\n\n    #[test]\n    #[should_panic(expected = "Division by zero")]\n    fn test_divide_by_zero() {\n        divide(10.0, 0.0);\n    }\n}

El parámetro expected no es obligatorio, pero hace la prueba más precisa: el pánico debe contener la cadena especificada.

2. Pruebas de integración: verificación de la interacción de módulos

Las pruebas de integración verifican cómo funcionan juntas las diferentes partes de su aplicación. A diferencia de las pruebas unitarias, se encuentran en un directorio separado tests/ al nivel de la raíz del proyecto (junto a src/). Cada archivo en esta carpeta se compila como un crate de biblioteca independiente.

2.1. Creación de una prueba de integración

Cree un archivo tests/integration_test.rs:

// tests/integration_test.rs\nuse my_crate::add; // asumimos que su crate se llama my_crate\n\n#[test]\nfn test_add_integration() {\n    let result = add(5, 10);\n    assert_eq!(result, 15);\n}

Para ejecutar solo las pruebas de integración