El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Pruebas

Siguiente ►
►

Las pruebas son una parte esencial del desarrollo de software, ya que aseguran que el código funcione como se espera y ayuda a prevenir errores en el futuro. Rust proporciona un marco de pruebas integrado que facilita la creación y ejecución de pruebas. En esta sección, aprenderemos cómo escribir y ejecutar pruebas en Rust.

Contenido

  1. Introducción a las Pruebas en Rust
  2. Escribiendo Pruebas
  3. Organización de Pruebas
  4. Pruebas de Integración
  5. Ejecutando Pruebas
  6. Errores Comunes y Consejos
  7. Ejercicios Prácticos

Introducción a las Pruebas en Rust

Rust incluye un marco de pruebas en su herramienta de construcción cargo. Las pruebas se escriben en el mismo archivo que el código fuente o en archivos separados y se ejecutan usando el comando cargo test.

Tipos de Pruebas

  • Pruebas Unitarias: Verifican el comportamiento de funciones individuales.
  • Pruebas de Integración: Verifican cómo interactúan varias partes del código.

Escribiendo Pruebas

Las pruebas en Rust se definen usando la macro #[test]. Aquí hay un ejemplo básico:

// src/lib.rs

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

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

    #[test]
    fn test_suma() {
        assert_eq!(suma(2, 2), 4);
    }
}

Explicación del Código

  • #[cfg(test)]: Indica que el módulo tests solo debe compilarse cuando se ejecutan las pruebas.
  • mod tests: Define un módulo de pruebas.
  • use super::*;: Importa todas las funciones y estructuras del módulo padre.
  • #[test]: Marca una función como una prueba.
  • assert_eq!: Macro que verifica que dos valores sean iguales.

Organización de Pruebas

Las pruebas unitarias suelen colocarse en el mismo archivo que el código fuente, mientras que las pruebas de integración se colocan en el directorio tests.

Ejemplo de Pruebas Unitarias

// src/lib.rs

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

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

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

Ejemplo de Pruebas de Integración

// tests/integration_test.rs

extern crate my_crate;

#[test]
fn test_suma_integration() {
    assert_eq!(my_crate::suma(2, 3), 5);
}

Pruebas de Integración

Las pruebas de integración se colocan en el directorio tests y cada archivo en este directorio es un módulo separado. Estas pruebas verifican cómo interactúan diferentes partes del código.

Ejemplo

// tests/integration_test.rs

extern crate my_crate;

#[test]
fn test_resta_integration() {
    assert_eq!(my_crate::resta(10, 4), 6);
}

Ejecutando Pruebas

Para ejecutar todas las pruebas, usa el comando:

cargo test

Este comando compilará el código y ejecutará todas las pruebas definidas.

Salida de Ejemplo

running 2 tests
test tests::test_suma ... ok
test tests::test_resta ... ok

test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

Errores Comunes y Consejos

Errores Comunes

  • No usar #[cfg(test)]: Esto puede hacer que el código de prueba se compile en la versión de producción.
  • No importar correctamente: Asegúrate de usar use super::*; para importar funciones y estructuras del módulo padre.

Consejos

  • Escribe pruebas pequeñas y específicas: Esto facilita la identificación de errores.
  • Usa assert! y assert_eq!: Estas macros son útiles para verificar condiciones y valores esperados.
  • Ejecuta pruebas frecuentemente: Esto ayuda a detectar errores temprano en el proceso de desarrollo.

Ejercicios Prácticos

Ejercicio 1: Prueba de Función de Multiplicación

Escribe una función multiplica que multiplique dos números y una prueba para verificar su funcionamiento.

// src/lib.rs

pub fn multiplica(a: i32, b: i32) -> i32 {
    a * b
}

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

    #[test]
    fn test_multiplica() {
        assert_eq!(multiplica(3, 4), 12);
    }
}

Ejercicio 2: Prueba de Función de División

Escribe una función divide que divida dos números y una prueba para verificar su funcionamiento. Asegúrate de manejar la división por cero.

// src/lib.rs

pub fn divide(a: i32, b: i32) -> Option<i32> {
    if b == 0 {
        None
    } else {
        Some(a / b)
    }
}

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

    #[test]
    fn test_divide() {
        assert_eq!(divide(10, 2), Some(5));
        assert_eq!(divide(10, 0), None);
    }
}

Conclusión

En esta sección, hemos aprendido cómo escribir y ejecutar pruebas en Rust. Hemos cubierto tanto las pruebas unitarias como las pruebas de integración, y hemos visto cómo organizar nuestras pruebas de manera efectiva. Las pruebas son una herramienta poderosa para asegurar la calidad del código y deben ser una parte integral de cualquier proyecto de software.

En el siguiente tema, exploraremos cómo documentar nuestro código de manera efectiva para que sea fácil de entender y mantener.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados