Pruebas en Rust: unit, integration, e2e — guía completa

Introducción a las pruebas en Rust

Rust es un lenguaje de programación de sistemas conocido por su seguridad y rendimiento. Sin embargo, incluso el código más confiable necesita verificación. Las pruebas en Rust no son solo una opción, sino una parte integral del proceso de desarrollo. Gracias al soporte integrado de pruebas en Cargo, puedes escribir y ejecutar fácilmente pruebas unit, integration y e2e. En este artículo, analizaremos los tres niveles de pruebas con ejemplos prácticos.

Pruebas unitarias en Rust: la base de la confiabilidad

Las pruebas unitarias verifican funciones y métodos individuales de forma aislada. En Rust, se colocan directamente en el archivo de código, en un módulo especial tests.

Estructura de una prueba unitaria

Cada prueba unitaria es una función marcada con el atributo #[test]. Dentro de ella, usas las macros assert!, assert_eq! y assert_ne! para verificar los resultados.

// src/math.rspub fn add(a: i32, b: i32) -> i32 {    a + b}

pub fn divide(a: f64, b: f64) -> Result<f64, String> {    if b == 0.0 {        Err(String::from("División por cero"))    } else {        Ok(a / b)    }}

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

    #[test]    fn test_add() {        assert_eq!(add(2, 3), 5);    }

    #[test]    fn test_divide_success() {        let result = divide(10.0, 2.0);        assert!(result.is_ok());        assert_eq!(result.unwrap(), 5.0);    }

    #[test]    fn test_divide_by_zero() {        let result = divide(10.0, 0.0);        assert!(result.is_err());        assert_eq!(result.unwrap_err(), "División por cero");    }}

Observa el atributo #[cfg(test)]. Le indica al compilador que incluya este módulo solo al compilar las pruebas. Esto ahorra tiempo de compilación del binario final.

Ejecución de pruebas unitarias

Para ejecutar todas las pruebas en el proyecto, usa el comando:

cargo test

También puedes ejecutar una prueba específica por su nombre:

cargo test test_add

O filtrar pruebas por una palabra clave:

cargo test divide

Pruebas de integración en Rust: verificación de interacción

Las pruebas de integración verifican cómo diferentes módulos de tu aplicación funcionan juntos. A diferencia de las pruebas unitarias, se encuentran en una carpeta separada tests/ a nivel de la raíz del proyecto.

Estructura de una prueba de integración

Crea un archivo tests/integration_test.rs:

// tests/integration_test.rsuse my_project::math; // asumimos que la biblioteca se llama my_project

#[test]fn test_add_and_divide() {    let sum = math::add(10, 5);    let result = math::divide(sum as f64, 3.0).unwrap();    assert_eq!(result, 5.0);}

#[test]fn test_complex_calculation() {    let a = math::add(100, 200);    let b = math::add(50, 50);    let result = math::divide(a as f64, b as f64).unwrap();    assert_eq!(result, 3.0);}

Cada archivo en tests/ se compila como un crate independiente. Esto significa que puedes tener varios archivos con pruebas para diferentes escenarios.

Módulo común para pruebas de integración

Si necesitas utilidades comunes para todas las pruebas de integración, crea una subcarpeta tests/common/ con un archivo mod.rs:

// tests/common/mod.rspub fn setup() {    // Inicialización del entorno de pruebas    println!("Configurando el entorno de pruebas...");}

Y úsalo en las pruebas:

// tests/integration_test.rsmod common;

#[test]fn test_with_setup() {    common::setup();    // Tu prueba}

Pruebas E2E en Rust: inmersión completa

Las pruebas E2E (end-to-end) verifican el funcionamiento de toda la aplicación de principio a fin. En Rust, para esto a menudo se utilizan herramien