Learn Rust Coding · Lección

Pruebas unitarias

Atributo test

Pruebas unitarias es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn Rust Coding, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn Rust Coding incluye 4 lecciones en total.

Pruebas en Rust

Rust incluye pruebas integradas; no necesita ningún framework externo. Las pruebas son funciones normales anotadas con #[test] y se ejecutan mediante cargo test.

Su primera prueba

Una función de prueba no recibe argumentos y utiliza aserciones. Si devuelve el control normalmente, la prueba se supera; si entra en pánico, falla.

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

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

fn main() {
    println!("{}", add(2, 3));
}

Macros de aserción

Las aserciones estándar son:

assert!(cond) — falla si la condición es falsa
assert_eq!(a, b) — falla si los valores no son iguales
assert_ne!(a, b) — falla si los valores son iguales

fn main() {
    let x = 4;
    assert!(x > 0);
    assert_eq!(x, 4);
    assert_ne!(x, 5);
    println!("All assertions passed");
}

El módulo tests

Por convención, las pruebas unitarias se encuentran en un módulo anotado con #[cfg(test)] para que solo se compile durante las pruebas.

fn square(n: i32) -> i32 {
    n * n
}

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

    #[test]
    fn squares_correctly() {
        assert_eq!(square(5), 25);
    }
}

fn main() {
    println!("{}", square(5));
}

use super::*

Como el módulo de pruebas está anidado, use super::* incorpora al ámbito los elementos del módulo principal (las funciones que desea probar).

Ejecutar pruebas

cargo test compila y ejecuta todas las pruebas. Informa de cuántas se superaron, fallaron o se ignoraron.

cargo test

Probar pánicos

Use #[should_panic] para afirmar que una función entra en pánico en determinadas condiciones.

fn checked_div(a: i32, b: i32) -> i32 {
    if b == 0 {
        panic!("division by zero");
    }
    a / b
}

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

    #[test]
    #[should_panic(expected = "division by zero")]
    fn panics_on_zero() {
        checked_div(10, 0);
    }
}

fn main() {}

Pruebas que devuelven Result

Una prueba puede devolver Result, lo que permite usar el operador ?. Devolver Err hace que la prueba falle.

fn parse(s: &str) -> Result<i32, std::num::ParseIntError> {
    s.parse::<i32>()
}

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

    #[test]
    fn parses_number() -> Result<(), std::num::ParseIntError> {
        let n = parse("42")?;
        assert_eq!(n, 42);
        Ok(())
    }
}

fn main() {}

Ignorar pruebas

Marque las pruebas lentas o específicas del entorno con #[ignore]. Ejecútelas explícitamente con cargo test -- --ignored.

#[test]
#[ignore]
fn expensive_test() {
    // long-running work
}

fn main() {}

Indicadores útiles para las pruebas

Opciones útiles al ejecutar pruebas:

cargo test name — ejecuta las pruebas cuyo nombre coincide
cargo test -- --nocapture — muestra la salida de println
cargo test -- --test-threads=1 — ejecuta las pruebas en serie

Probar funciones privadas

Como el módulo de pruebas está anidado en el mismo archivo, puede acceder a funciones privadas, algo que las pruebas de integración no pueden hacer. Esta es una ventaja clave de las pruebas unitarias.

fn internal(n: i32) -> i32 {
    n + 1
}

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

    #[test]
    fn tests_private() {
        assert_eq!(internal(4), 5);
    }
}

fn main() {
    println!("{}", internal(4));
}

Comprobación rápida

¿Qué atributo marca una función como una prueba que Cargo debe ejecutar?

Resumen

Ha aprendido las pruebas integradas de Rust:

#[test] marca las funciones de prueba
Aserciones: assert!, assert_eq!, assert_ne!
Las pruebas se encuentran en un módulo #[cfg(test)] con use super::*
#[should_panic] y las pruebas que devuelven Result gestionan los errores
cargo test ejecuta todo

Preguntas frecuentes

¿La lección «Pruebas unitarias» es gratis?

Sí — el texto completo de «Pruebas unitarias» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn Rust Coding, actualiza a CoddyKit PRO. El curso de Learn Rust Coding incluye 4 lecciones en total.

¿Qué aprenderé en «Pruebas unitarias»?

Atributo test Practicas Learn Rust Coding con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Learn Rust Coding?

No se requiere experiencia previa. Learn Rust Coding en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Pruebas unitarias»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Learn Rust Coding?

Sí. Cada lección de Learn Rust Coding incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Learn Rust Coding