Rust, un vistazo más (6)

Realizar pruebas unitarias es de gran ayuda para encontrar errores o depurar nuestro código. El Test Driven Development (TDD) o Desarrollo Guiado por Pruebas es una metodología para la realización de pruebas automatizadas.

Rust al ser un lenguaje moderno nos permite hacer pruebas de nuestro código.

El flujo de una prueba, basándonos en a lógica TDD, incluye:

1. Pruebas que fallen (RED). 
2. Pruebas que pasen (GREEN). 
3. Refactorización (BLUE).

Crearemos un proyecto con Rust:

$ cargo new pruebas-unitarias && cd pruebas-unitarias

Modificamos el archivo ``main.rs``

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

}

Con esto indicamos que estamos creando un módulo denominado ``tests``.

La palabra clave ``use`` importa elementos al ámbito actual.

``super::*`` importa todo (el comodín *) desde el módulo padre (super) del módulo tests.

Esto permite que las pruebas dentro del módulo tests accedan a las funciones, estructuras u otros elementos definidos en el módulo padre (el módulo que contiene mod tests).

Agregaremos una función que sume dos números de manera incorrecta (RED):

#[allow(dead_code)]
fn bad_add(a: i32, b: i32) -> i32 {
    a - b
}


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

}

Ahora, dentro del módulo ``tests`` agregaremos una función de prueba para la función ``bad_add`` denominada ``test_bad_add``:

#[allow(dead_code)]
fn bad_add(a: i32, b: i32) -> i32 {
    a - b
}


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

     #[test]
    fn test_bad_add() {
        assert_eq!(bad_add(1, 2), 3);
    }

}

Ejecutamos el test con este comando:

$ cargo test

Al ejecutar mostrará el resultado:

test tests::test_bad_add ... FAILED

La prueba ha fallado correctamente, pues la función ``bad_add`` tiene un comportamiento incorrecto (resta en vez de sumar).

Volvemos a modificar el archivo ``main.rs`` agregando una función que realice correctamente la suma de dos números y además agregaremos su test.

pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

#[allow(dead_code)]
fn bad_add(a: i32, b: i32) -> i32 {
    a - b
}


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

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

    #[test]
    fn test_bad_add() {
        assert_eq!(bad_add(1, 2), 3);
    }

    
}

Ejecutamos el test:

$ cargo test

Salida:

running 2 tests
test tests::test_add ... ok
test tests::test_bad_add ... FAILED

Uno de los test nos dará ok (GREEN) y el otro fallará (RED).

El uso de pruebas en nuestro código sirve para prevenir errores futuros que no vislumbramos a la hora del desarrollo.

Enlaces:

https://www.rust-lang.org/