TDD en Rust: desarrollo guiado por pruebas para código confiable

¿Por qué TDD en Rust no es aburrido, sino ventajoso?

¿Alguna vez ha escrito código que funcionaba "más o menos bien" y luego encontró un error en el lugar más inesperado? Le resulta familiar. El desarrollo guiado por pruebas (TDD) es un método que pone el proceso habitual patas arriba. En lugar de escribir primero el código y luego preguntarse si funciona, primero escribe una prueba que debería fallar, y luego escribe exactamente la cantidad de código necesaria para que la prueba pase.

Rust es un lenguaje que ya a nivel de compilador lo protege de toda una clase de errores (¡fuera segfaults y condiciones de carrera!). Pero incluso el compilador no garantiza que su lógica sea correcta. TDD en Rust agrega a esta seguridad otra capa: no solo escribe código, sino que documenta el comportamiento esperado directamente en las pruebas. Y esto es increíblemente genial.

En este artículo, analizaremos TDD en Rust con ejemplos prácticos. Verá cómo escribir pruebas antes de la implementación, cómo ejecutarlas con cargo test y cómo refactorizar código sin miedo a romper algo. ¡Vamos allá!

¿Qué es TDD y por qué Rust es ideal para ello?

TDD significa Test-Driven Development (desarrollo guiado por pruebas). El ciclo es simple y elegante:

\n
1. Rojo — escribimos una prueba que describe una nueva funcionalidad. La ejecutamos — la prueba falla (lógico, aún no hay código).
\n
2. Verde — escribimos el código mínimo para que la prueba pase. No pensamos en la estética, solo en que la prueba pase.
\n
3. Refactorización — mejoramos el código sin cambiar su comportamiento. Las pruebas permanecen en verde.
\n

Rust es ideal para TDD por varias razones:

\n
• Sistema de pruebas integrado — cargo test funciona de fábrica, no es necesario instalar frameworks externos.
\n
• Tipado fuerte — el compilador detecta errores de tipo, y las pruebas detectan errores lógicos. Juntos son invencibles.
\n
• Propiedad y préstamo — las pruebas ayudan a asegurarse de que trabaja correctamente con la memoria, sin crear copias innecesarias.
\n
• Comunidad y documentación — la comunidad de Rust promueve activamente las pruebas, hay muchos ejemplos.
\n

Configuración del proyecto para TDD

Creemos un nuevo proyecto:

cargo new tdd_rust_example\ncd tdd_rust_example

Por defecto, cargo new crea un archivo src/main.rs con un programa muy simple. Escribiremos una biblioteca, por lo que lo renombraremos a src/lib.rs (o simplemente eliminamos main.rs y creamos lib.rs). En Cargo.toml no es necesario cambiar nada — las pruebas ya están incluidas.

Por cierto, si solo escribe una biblioteca (sin un archivo ejecutable), use cargo new --lib.

Primera prueba: rojo

Imagine que queremos escribir una función que sume dos números. Según TDD, primero escribimos la prueba. Abrimos src/lib.rs y agregamos:

#[cfg(test)]\nmod tests {\n    #[test]\n    fn test_add() {\n        let result = add(2, 3);\n        assert_eq!(result, 5);\n    }\n}

Ejecutamos:

cargo test

Verá un error de compilación — la función add no está definida. Esto es normal. Estamos en la zona roja.

Verde: implementación mínima

Ahora escribimos exactamente la cantidad de código necesaria para que la prueba pase. Agregamos la función add encima del módulo de pruebas:

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        let result = add(2, 3);\n        assert_eq!(result, 5);\n    }\n}

Observe el use super::*; — esto importa todo del módulo padre (nuestro código) al módulo de pruebas.

Ejecutamos cargo test nuevamente. ¡Verde! La prueba pasa. Hicimos el mínimo — devolvimos la suma. Parece