Aplicaciones con Rullst I · Lección 12 / 14

Pruebas que investigan el contrato

Ver una página abrir es solo el comienzo de la verificación.

Vamos a descubrir juntos

1
src/validation.rs prueba una función sin red ni base. tests/contract.rs usa TestApp de Rullst para enviar peticiones al enrutador y verificar estados y datos. La prueba de persistencia cierra conexiones y abre archivos nuevos. Cada tipo responde preguntas diferentes.
2
Ejecuta cargo test --locked. Lee nombres, no solo el total verde. Rechazo exige estado correcto y base sin cambios. Texto parametrizado se verifica con entrada inusual y tabla aún funcional. Evita pruebas que solo repitan constantes de implementación.
3
Elige un error plausible: sustituye WHERE id por UPDATE sin filtro en una copia descartable. Una prueba con dos misiones debe detectar que la otra no debía cambiar. Después revierte el error y conserva la prueba. No experimentes en una base ajena.
4
El proyecto final pide un caso nuevo escrito por ti y una explicación de lo que no cubre. TestApp no prueba navegador real, instalación limpia, carga ni lectores de pantalla. Una revisión útil combina pruebas apropiadas, observación y feedback de otra persona.

Tu mesa de aplicaciones

El kit incluye la aplicación completa para investigar y modificar. El fragmento explica esta etapa; el editor contiene el archivo indicado. Rullst Academy no compila ni ejecuta este servidor en el navegador.

Archivo para estudiar y modificar

tests/contract.rs

cargo test --locked
cargo test --locked title_and_priority_boundaries
cargo test --locked http_contract_validation_and_parameterized_data

Extrae el kit en una carpeta nueva y abre el terminal junto a Cargo.toml. Usa Rust 1.96+; la primera compilación puede descargar dependencias y tardar. Abre http://127.0.0.1:3010. Detén con Ctrl+C y ejecuta de nuevo tras editar.

cargo test --locked
cargo run --locked

Mis archivos y GitHub

Descarga tu borrador y sustituye el archivo indicado en tu copia extraída. El editor guarda un archivo en este navegador; tu cuenta guarda evaluaciones y XP. El ZIP excluye tus cambios. GitHub envía solo el archivo confirmado; usa Git manual para la aplicación entera, sin bases, respaldos ni secretos.

Enlaces oficiales y siguiente paso

Rust: escribir pruebas

✦

TU MISIÓN

Distinguir pruebas de función, HTTP y recuperación; agregar una regresión útil.

Ahora te toca

Taller de descubrimientos

Decide antes de ejecutar

Distinguir pruebas de función, HTTP y recuperación; agregar una regresión útil.

01¿Qué prueba sirve para comprobar 422 por la ruta completa?02Tras rechazar una entrada en una base con dos misiones, ¿qué conteo esperamos?

Prepara tus respuestas y comprueba cuando estés listo.

Una pausa para entender

¿Qué permite afirmar un conjunto de pruebas aprobado?

Ningún fallo es posibleLa autonomía profesional ya está demostradaLos casos ejercitados pasaron en ese entorno

Necesito una pista

La evidencia tiene límites. Un caso nuevo y feedback independiente ayudan a descubrir lo que no cubrían las pruebas anteriores.

Cargando tu camino…

Llévatelo contigo

Agrega una prueba que complete una misión y verifique que otra sigue pendiente. Hazla fallar con un defecto deliberado en una copia, corrige y registra antes/después.

A tu ritmo

Mis archivos y GitHub

Cada lección puede convertirse en un registro propio: código, notas o un plan de práctica. Guardar un archivo en GitHub es opcional y no cambia tus XP.

Manual del alumno

El editor y las descargas se abren cuando esta lección esté disponible para tu cuenta. Revisa el acceso indicado abajo o vuelve al mapa de la ruta.

Comprobando tu acceso a esta lección…

Tu camino, paso a paso

Descargar material de la actividad

Descarga el ejemplo de la lección y un cuaderno para tus notas. El ZIP incluye una guía para organizar actividades en uno o varios repositorios. Publicar es opcional; las cuentas habilitadas también pueden usar el botón de envío a GitHub.

Tu archivo de esta lección

Edita el ejemplo o registra lo aprendido. Este espacio no ejecuta código ni corrige respuestas. El borrador se guarda solo en este navegador, separado por cuenta; tú decides cuándo descargar o enviar a GitHub.

El ejemplo puede ser solo un fragmento o una guía. Cambiar la extensión no lo convierte en un programa completo. El ZIP de la actividad contiene material inicial; el botón de archivo editado descarga tu texto.

Mi código o mis notas

use mission_board::{recovery, routes, store::Store};
use rullst::{orm::sqlx, testing::TestApp};
use serde_json::{Value, json};
use std::{
    path::{Path, PathBuf},
    sync::atomic::{AtomicUsize, Ordering},
};

fn directory() -> PathBuf {
    static NUMBER: AtomicUsize = AtomicUsize::new(0);
    let name = format!(
        "mission-board-test-{}-{}-{}",
        std::process::id(),
        NUMBER.fetch_add(1, Ordering::Relaxed),
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
    );
    let dir = std::env::temp_dir().join(name);
    std::fs::create_dir(&dir).unwrap();
    dir
}
async fn count(store: &Store) -> i64 {
    sqlx::query_scalar("SELECT COUNT(*) FROM missions")
        .fetch_one(&store.pool)
        .await
        .unwrap()
}

#[tokio::test]
async fn http_contract_validation_and_parameterized_data() {
    let store = Store::open(Path::new(":memory:")).await.unwrap();
    let app = TestApp::new(routes::app(store.clone()).into_axum());
    app.get("/")
        .await
        .assert_status(200)
        .assert_see("aria-live=\"polite\"");
    app.get("/api/missions")
        .await
        .assert_status(200)
        .assert_header("cache-control", "no-store");
    for input in [
        json!({"title":" ","priority":1}),
        json!({"title":"x".repeat(81),"priority":1}),
        json!({"title":"a\nb","priority":1}),
        json!({"title":"Orbit","priority":4}),
        json!({"title":"Orbit","priority":0}),
        json!({"title":"Orbit","priority":"1"}),
        json!({"title":"Orbit","priority":1,"admin":true}),
    ] {
        app.post("/api/missions")
            .json(&input)
            .await
            .assert_status(422);
    }
    assert_eq!(count(&store).await, 0);
    app.post("/api/missions")
        .header("content-type", "application/json")
        .body("{")
        .await
        .assert_status(400);
    app.post("/api/missions")
        .json(&json!({"title":"x".repeat(5000),"priority":1}))
        .await
        .assert_status(413);
    app.post("/api/missions")
        .header("origin", "https://example.invalid")
        .json(&json!({"title":"Orbit","priority":1}))
        .await
        .assert_status(403);
    let title = "O'Brien <em>Orbit</em>'); DROP TABLE missions;--";
    let response = app
        .post("/api/missions")
        .json(&json!({"title":title,"priority":1}))
        .await;
    response.assert_status(201);
    let first: Value = response.json();
    assert_eq!(first["title"], title);
    let second: Value = app
        .post("/api/missions")
        .json(&json!({"title":" Orbit ","priority":3}))
        .await
        .json();
    assert_eq!(second["title"], "Orbit");
    assert_ne!(first["id"], second["id"]);
    let items: Vec<Value> = app.get("/api/missions").await.json();
    assert_eq!(items[0]["id"], second["id"]);
    assert_eq!(count(&store).await, 2);
    for _ in 0..2 {
        app.put(&format!("/api/missions/{}/completion", first["id"]))
            .json(&json!({"done":true}))
            .await
            .assert_status(204);
    }
    assert!(
        store
            .list()
            .await
            .unwrap()
            .iter()
            .find(|m| m.id == first["id"].as_i64().unwrap())
            .unwrap()
            .done
    );
    assert_eq!(count(&store).await, 2);
    app.put("/api/missions/999999/completion")
        .json(&json!({"done":true}))
        .await
        .assert_status(404);
    app.get("/missing").await.assert_status(404);
    store.pool.close().await;
    let failed = app.get("/api/missions").await;
    failed.assert_status(503).assert_dont_see("SELECT");
    assert_eq!(failed.json::<Value>()["error"], "storage_unavailable");
}

#[tokio::test]
async fn restart_backup_restore_and_refuse_overwrite() {
    let dir = directory();
    let database = dir.join("missions.db");
    let backup = dir.join("backup.db");
    let restored = dir.join("restored.db");
    let store = Store::open(&database).await.unwrap();
    let app = TestApp::new(routes::app(store.clone()).into_axum());
    app.post("/api/missions")
        .json(&json!({"title":"Repair a fictional rover","priority":2}))
        .await
        .assert_status(201);
    recovery::snapshot(&database, &backup).await.unwrap();
    app.post("/api/missions")
        .json(&json!({"title":"Added after the backup","priority":1}))
        .await
        .assert_status(201);
    store.pool.close().await;
    drop(app);
    let reopened = Store::open(&database).await.unwrap();
    assert_eq!(count(&reopened).await, 2);
    reopened.pool.close().await;
    assert!(recovery::snapshot(&database, &backup).await.is_err());
    recovery::snapshot(&backup, &restored).await.unwrap();
    recovery::verify(&restored).await.unwrap();
    let recovered = Store::open(&restored).await.unwrap();
    assert_eq!(count(&recovered).await, 1);
    assert_eq!(
        recovered.list().await.unwrap()[0].title,
        "Repair a fictional rover"
    );
    recovered.pool.close().await;
    assert!(
        recovery::snapshot(&dir.join("missing.db"), &dir.join("must-not-exist.db"))
            .await
            .is_err()
    );
    assert!(!dir.join("missing.db").exists() && !dir.join("must-not-exist.db").exists());
    assert_eq!(dir.parent(), Some(std::env::temp_dir().as_path()));
    assert!(
        dir.file_name()
            .unwrap()
            .to_str()
            .unwrap()
            .starts_with("mission-board-test-")
    );
    std::fs::remove_dir_all(dir).unwrap();
}

Formato del archivo

Tu texto se guardará en este navegador al editarlo. En un equipo compartido, borra los borradores al terminar.

El envío directo acepta hasta 8 KiB de texto en un archivo. Usa las descargas y la guía manual para proyectos con varios archivos.

Pruebas que investigan el contrato

Vamos a descubrir juntos

Tu mesa de aplicaciones

Archivo para estudiar y modificar

Enlaces oficiales y siguiente paso

Ahora te toca

Decide antes de ejecutar

Llévatelo contigo

Mis archivos y GitHub

Tu archivo de esta lección

Guardar en mi GitHub

Rullstpetbot