{"id":29944,"date":"2024-10-08T16:00:13","date_gmt":"2024-10-08T14:00:13","guid":{"rendered":"https:\/\/www.codemotion.com\/magazine\/?p=29944"},"modified":"2024-10-08T16:00:15","modified_gmt":"2024-10-08T14:00:15","slug":"testing-en-rust","status":"publish","type":"post","link":"https:\/\/www.codemotion.com\/magazine\/es\/devops-es\/testeo\/testing-en-rust\/","title":{"rendered":"Testing en Rust"},"content":{"rendered":"\n

En Rust<\/strong>, hacer pruebas est\u00e1 integrado directamente en el lenguaje, lo que facilita verificar el comportamiento del c\u00f3digo sin necesidad de frameworks externos. Esto, si aplicas t\u00e9cnicas como TDD<\/strong>, te permite mantener el ciclo de desarrollo \u00e1gil y enfocado en la calidad desde el principio.<\/p>\n\n\n\n

Para ejecutar un test en Rust, solo necesitas marcar una funci\u00f3n como prueba usando el atributo #[test]<\/code>. Al usar este atributo, Rust sabe que esa funci\u00f3n debe ejecutarse cuando corres el comando cargo test<\/code> , que es la herramienta para gestionar pruebas en Rust.<\/p>\n\n\n

#[test]<\/span>\nfn<\/span> foo<\/span><\/span>() {\n    \/\/ some code...<\/span>\n}<\/code><\/span>Code language:<\/span> Rust<\/span> (<\/span>rust<\/span>)<\/span><\/small><\/pre>\n\n\n
Funciones de ejemplo<\/h2>\n\n\n\n
Para mostrar las diferentes aserciones disponibles en Rust, vamos a usar dos funciones sencillas: una que suma dos n\u00fameros y otra que verifica si un n\u00famero es par.
<\/p>\n\n\n
fn<\/span> sum<\/span><\/span>(a: i32<\/span>, b: i32<\/span>) -> i32<\/span> {\n    a + b\n}\n\nfn<\/span> is_even<\/span><\/span>(a: i32<\/span>) -> bool<\/span> {\n    a % 2<\/span> == 0<\/span>\n}<\/code><\/span>Code language:<\/span> Rust<\/span> (<\/span>rust<\/span>)<\/span><\/small><\/pre>\n\n\n
Con estas funciones, podr\u00e1s ver c\u00f3mo se usan los distintos macros de aserciones.<\/p>\n\n\n\n
Aserciones<\/h2>\n\n\n\n
En Rust, existen varios macros nativos que puedes usar para hacer pruebas. A continuaci\u00f3n, te muestro los m\u00e1s comunes:<\/p>\n\n\n\n
assert!<\/h3>\n\n\n\n
El macro assert!<\/code> es el m\u00e1s b\u00e1sico y se usa para verificar que una expresi\u00f3n booleana sea verdadera. Si la expresi\u00f3n es falsa, la prueba fallar\u00e1 con un panic<\/em>.<\/p>\n\n\n
#[test]<\/span>\nfn<\/span> check_if_a_number_is_even<\/span><\/span>() {\n    assert!<\/span>(is_even(6<\/span>));\n}<\/code><\/span>Code language:<\/span> Rust<\/span> (<\/span>rust<\/span>)<\/span><\/small><\/pre>\n\n\n
Este macro es ideal cuando solo necesitas verificar que una condici\u00f3n se cumpla, sin comparar valores espec\u00edficos.<\/p>\n\n\n\n
assert_eq!<\/h3>\n\n\n\n
El macro assert_eq!<\/code> compara dos valores para verificar que sean iguales. Si no lo son, la prueba fallar\u00e1 mostrando ambos valores, lo que facilita depurar el problema.<\/p>\n\n\n
#[test]<\/span>\nfn<\/span> calculate_the_sum_of_two_numbers<\/span><\/span>() {\n    assert_eq!<\/span>(sum(3<\/span>, 3<\/span>), 6<\/span>);\n}<\/code><\/span>Code language:<\/span> Rust<\/span> (<\/span>rust<\/span>)<\/span><\/small><\/pre>\n\n\n
Funciona para cualquier tipo que implemente el trait PartialEq<\/code>. Por ejemplo:<\/p>\n\n\n
#[derive(Debug, PartialEq)]<\/span>\npub<\/span> struct<\/span> Point<\/span><\/span> {\n    pub<\/span> x: i32<\/span>,\n    pub<\/span> y: i32<\/span>,\n}\n\n#[test]<\/span>\nfn<\/span> two_points_are_equal<\/span><\/span>() {\n    let<\/span> point1 = Point { x: 1<\/span>, y: 2<\/span> };\n    let<\/span> point2 = Point { x: 1<\/span>, y: 2<\/span> };\n    assert_eq!<\/span>(point1, point2);\n}<\/code><\/span>Code language:<\/span> Rust<\/span> (<\/span>rust<\/span>)<\/span><\/small><\/pre>\n\n\n
assert_ne!<\/h3>\n\n\n\n
Este macro es el inverso de assert_eq!<\/code>: compara dos valores y verifica que no<\/strong> sean iguales. Si los valores son iguales, la prueba fallar\u00e1.<\/p>\n\n\n
#[test]<\/span>\nfn<\/span> calculate_the_sum_of_two_numbers_fail<\/span><\/span>() {\n    assert_ne!<\/span>(sum(3<\/span>, 3<\/span>), 5<\/span>);\n}<\/code><\/span>Code language:<\/span> Rust<\/span> (<\/span>rust<\/span>)<\/span><\/small><\/pre>\n\n\n
Aserciones de depuraci\u00f3n<\/h3>\n\n\n\n
Rust tambi\u00e9n tiene macros de depuraci\u00f3n como debug_assert!<\/code>, debug_assert_eq!<\/code> y debug_assert_ne!<\/code>. Estos funcionan igual que los macros anteriores, pero solo se ejecutan en modo debug, no en compilaciones de release<\/code>. Esto puede ser \u00fatil para optimizar el rendimiento.<\/p>\n\n\n
#[test]<\/span>\nfn<\/span> calculate_the_sum_of_two_numbers_with_debug<\/span><\/span>() {\n    debug_assert_eq!<\/span>(sum(3<\/span>, 3<\/span>), 6<\/span>);\n}\n\n#[test]<\/span>\nfn<\/span> calculate_the_sum_of_two_numbers_fail_with_debug<\/span><\/span>() {\n    debug_assert_ne!<\/span>(sum(3<\/span>, 3<\/span>), 5<\/span>);\n}\n\n#[test]<\/span>\nfn<\/span> check_if_a_number_is_even_with_debug<\/span><\/span>() {\n    debug_assert!<\/span>(is_even(6<\/span>));\n}<\/code><\/span>Code language:<\/span> Rust<\/span> (<\/span>rust<\/span>)<\/span><\/small><\/pre>\n\n\n
Otros macros<\/h3>\n\n\n\n
Adem\u00e1s de los macros nativos, puedes usar librer\u00edas externas para ampliar las aserciones. Por ejemplo, la librer\u00eda matches<\/a> permite verificar si una expresi\u00f3n coincide con un patr\u00f3n.<\/p>\n\n\n
use<\/span> matches::assert_matches;\n\n#[test]<\/span>\nfn<\/span> check_an_specific_pattern<\/span><\/span>() {\n    let<\/span> resultado: Result<\/span><i32<\/span>, &str<\/span>> = Ok<\/span>(10<\/span>);\n    assert_matches!(resultado, Ok<\/span>(10<\/span>));\n}<\/code><\/span>Code language:<\/span> Rust<\/span> (<\/span>rust<\/span>)<\/span><\/small><\/pre>\n\n\n
Organizaci\u00f3n de tests en Rust<\/h2>\n\n\n\n
Hay dos maneras principales de organizar tus pruebas en Rust: dentro del mismo m\u00f3dulo que el c\u00f3digo productivo o en una carpeta separada llamada tests<\/code>.<\/p>\n\n\n\n
Pruebas en el mismo m\u00f3dulo<\/h3>\n\n\n\n
Si colocas las pruebas en el mismo m\u00f3dulo, puedes probar funciones privadas y mantener las pruebas cerca del c\u00f3digo que validan. Esto es \u00fatil en proyectos peque\u00f1os o para pruebas r\u00e1pidas.<\/p>\n\n\n
#[cfg(test)]<\/span>\nfn<\/span> sum<\/span><\/span>(a: i32<\/span>, b: i32<\/span>) -> i32<\/span> {\n    a + b\n}\n\n#[cfg(test)]<\/span>\nmod<\/span> tests {\n    use<\/span> super::*;\n\n    #[test]<\/span>\n    fn<\/span> calculate_the_sum_of_two_numbers<\/span><\/span>() {\n        assert_eq!<\/span>(sum(3<\/span>, 3<\/span>), 6<\/span>);\n    }\n}<\/code><\/span>Code language:<\/span> Rust<\/span> (<\/span>rust<\/span>)<\/span><\/small><\/pre>\n\n\n
Pruebas en archivos separados<\/h3>\n\n\n\n
Para proyectos m\u00e1s grandes, es mejor organizar las pruebas en una carpeta  tests<\/code>. Esto te permite mantener el c\u00f3digo de producci\u00f3n separado del c\u00f3digo de prueba.<\/p>\n\n\n
use<\/span> testing_rust::testing_rust::sum;\n\n#[test]<\/span>\nfn<\/span> calculate_the_sum_of_two_numbers<\/span><\/span>() {\n    assert_eq!<\/span>(sum(3<\/span>, 3<\/span>), 6<\/span>);\n}<\/code><\/span>Code language:<\/span> Rust<\/span> (<\/span>rust<\/span>)<\/span><\/small><\/pre>\n\n\n
Es una buena pr\u00e1ctica nombrar estos archivos con el sufijo _test.rs<\/code>, por ejemplo: foo_test.rs<\/code>.<\/p>\n\n\n\n
Mocks en Rust<\/h2>\n\n\n\n
Aunque Rust no tiene un sistema de mocks integrado, librer\u00edas como mockall<\/a> permiten crear mocks f\u00e1cilmente. Los mocks son \u00fatiles para simular dependencias externas, como bases de datos o servicios remotos.<\/p>\n\n\n\n
Definici\u00f3n de la interfaz<\/h3>\n\n\n
#[derive(Debug, PartialEq)]<\/span>\npub<\/span> struct<\/span> User<\/span><\/span> {\n    pub<\/span> user_id: i32<\/span>,\n    pub<\/span> name: String<\/span>,\n    pub<\/span> age: i32<\/span>,\n}\n\npub<\/span> trait<\/span> DatabaseRepository<\/span><\/span> {\n    fn<\/span> find_by_id<\/span><\/span>(&self<\/span>, user_id: &i32<\/span>) -> bool<\/span>;\n}<\/code><\/span>Code language:<\/span> Rust<\/span> (<\/span>rust<\/span>)<\/span><\/small><\/pre>\n\n\n
Uso de mockall para crear un mock<\/h3>\n\n\n
use<\/span> mockall::mock;\nuse<\/span> testing_rust::database::{DatabaseRepository, User};\n\nmock! {\n  pub<\/span> Database {}\n\n  impl<\/span> DatabaseRepository for<\/span> Database {\n        fn<\/span> find_by_id<\/span><\/span>(&self<\/span>, user: &i32<\/span>) -> bool<\/span>;\n  }\n}\n\n#[test]<\/span>\nfn<\/span> user_exist_in_database<\/span><\/span>() {\n    let<\/span> mut<\/span> mock_db = MockDatabase::new();\n    let<\/span> user = User { user_id: 1<\/span>, name: \"test data\"<\/span>.to_string(), age: 20<\/span> };\n    mock_db.expect_find_by_id()\n        .with(mockall::predicate::eq(user.user_id.clone()))\n        .times(1<\/span>)\n        .returning(|_| true<\/span>);\n\n    let<\/span> result = is_user_in_database(&mock_db, &user);\n\n    assert!<\/span>(result);\n}\n\nfn<\/span> is_user_in_database<\/span><\/span>(db: &dyn<\/span> DatabaseRepository, user: &User) -> bool<\/span> {\n    db.find_by_id(&user.user_id)\n}<\/code><\/span>Code language:<\/span> Rust<\/span> (<\/span>rust<\/span>)<\/span><\/small><\/pre>\n\n\n
En este caso, hemos utilizado el macro mock!<\/code> para generar un mock de nuestra interfaz DatabaseRepository<\/code>, y luego lo hemos utilizado para simular el comportamiento de nuestra base de datos.<\/p>\n\n\n\n
Si prefieres mantener los mocks dentro del mismo m\u00f3dulo que tu c\u00f3digo, puedes usar el atributo #[automock]<\/code> para generar los mocks directamente a partir de la interfaz:<\/p>\n\n\n
use<\/span> mockall::{automock, mock};\nuse<\/span> testing_rust::database::User;\n\n#[automock]<\/span>\ntrait<\/span> DatabaseRepository<\/span><\/span> {\n    fn<\/span> find_by_id<\/span><\/span>(&self<\/span>, user_id: &i32<\/span>) -> bool<\/span>;\n}<\/code><\/span>Code language:<\/span> Rust<\/span> (<\/span>rust<\/span>)<\/span><\/small><\/pre>\n\n\n
De esta forma, Rust te proporciona un mock autom\u00e1tico sin tener que crear uno manualmente.<\/p>\n\n\n\n
Conclusi\u00f3n<\/h2>\n\n\n\n
Rust proporciona una infraestructura robusta y flexible para pruebas, integrada directamente en el lenguaje. Ya sea que est\u00e9s escribiendo pruebas unitarias sencillas con assert!<\/code> o pruebas m\u00e1s complejas con mocks usando mockall<\/code>, el ecosistema de pruebas en Rust te permite asegurarte de que tu c\u00f3digo es confiable y robusto.<\/p>\n\n\n\n
Existen muchas m\u00e1s herramientas externas para realizar otros tipos de tests, como proptest<\/a> para property based testing, o httpmock<\/a> para hacer tests de integraci\u00f3n con apis http. \u00a1Estas y otras herramientas pueden ser exploradas en un post futuro!<\/p>\n\n\n\n
Si quer\u00e9is revisar m\u00e1s cosillas sobre Rust, pod\u00e9is hecharle un ojo a estos art\u00edculos:<\/p>\n\n\n\n