Pruebas en Rust: frameworks y herramientas

Rust es un lenguaje de programación de sistemas que presta gran atención a la fiabilidad y la seguridad. El sistema de pruebas integrado es una de las características clave que permite escribir código de calidad sin necesidad de instalar frameworks de terceros. En este artículo, analizaremos en detalle las principales herramientas para pruebas en Rust: desde pruebas unitarias simples hasta pruebas basadas en propiedades complejas y benchmarks.

Framework de pruebas integrado

En Rust, las pruebas se ejecutan con el comando cargo test. Las pruebas son funciones normales marcadas con el atributo #[test]. El framework recopila automáticamente todas estas funciones en su proyecto y las ejecuta.

Pruebas unitarias

Las pruebas unitarias generalmente se ubican en el mismo archivo que el código bajo prueba, en un módulo separado tests. Esto permite probar funciones privadas.

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

fn private_helper(x: i32) -> i32 {    x * 2}

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

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

    #[test]    fn test_private_helper() {        assert_eq!(private_helper(5), 10);    }}

Ejecución: cargo test

Pruebas de integración

Las pruebas de integración se encuentran en el directorio tests/ a nivel de la raíz del proyecto. Cada archivo en esta carpeta es un crate separado que prueba su API pública.

// tests/integration_test.rsuse my_crate::add;

#[test]fn test_add_integration() {    assert_eq!(add(10, 20), 30);}

Macros para verificaciones

Rust proporciona varias macros integradas para escribir verificaciones:

assert!(expression) — entra en pánico si la expresión es falsa.
assert_eq!(left, right) — verifica la igualdad usando PartialEq.
assert_ne!(left, right) — verifica la desigualdad.
debug_assert!() — funciona solo en compilaciones de depuración.

#[test]fn test_with_assert() {    let result = some_function();    assert!(result.is_ok(), "Se esperaba Ok, se obtuvo: {:?}", result);    assert_eq!(result.unwrap(), 42);}

Doctests

Una de las características más potentes de Rust es la posibilidad de escribir pruebas directamente en la documentación. El código dentro de los bloques /// o //! se compila y ejecuta automáticamente como una prueba.

/// Suma dos números.////// # Ejemplos////// ```/// use my_crate::add;/// assert_eq!(add(1, 2), 3);/// ```pub fn add(a: i32, b: i32) -> i32 {    a + b}

Ejecución: cargo test — los doctests se ejecutarán junto con las pruebas normales.

Pruebas basadas en propiedades con proptest

La biblioteca proptest (análoga a Hypothesis en Python o QuickCheck en Haskell) permite generar datos de entrada aleatorios y verificar invariantes.

use proptest::prelude::*;

fn reverse_string(s: &str) -> String {    s.chars().rev().collect()}

proptest! {    #[test]    fn test_reverse_twice(s in ".*") {        let reversed = reverse_string(&s);        let double_reversed = reverse_string(&reversed);        assert_eq!(s, double_reversed);    }}

Instalación: cargo add proptest

Benchmarks

Para medir el rendimiento en Rust, existen benchmarks estables (a partir de Rust 1.78) mediante cargo bench y el crate criterion para escenarios más complejos.

Benchmarks integrados (nightly)

#![feature(test)]extern crate test;

#[bench]fn bench_add(b: &mut test::Bencher) {    b.iter(|| add(1, 2));}

Benchmarks con criterion

También en la biblioteca

Bibliotecas WebSocket de Rust: tokio-tungstenite y async-tungstenite

Event Bus y el patrón Observer en Kotlin: guía con ejemplos

wiremock-rs para Rust: guía completa con ejemplos

Aprendizaje automático en Java: revisión de las principales bibliotecas para desarrollo

multierr en Go: guía completa con ejemplos prácticos

Pruebas en Rust: frameworks y herramientas