Aplicações com Rullst I · Lição 12 / 14

Testes que investigam o contrato

Ver uma página abrir é só o começo da verificação.

Vamos descobrir juntos

1
src/validation.rs testa uma função sem rede nem banco. tests/contract.rs usa TestApp do Rullst para enviar pedidos ao roteador e verificar status e dados. O teste de persistência fecha conexões e abre arquivos novos. Cada tipo responde a perguntas diferentes.
2
Execute cargo test --locked. Observe os nomes, não só o total verde. A prova de rejeição exige status correto e banco sem alteração. A prova de texto parametrizado inclui dado incomum e tabela ainda funcional. Evite testes que apenas repitam uma constante da implementação.
3
Escolha um erro plausível: trocar WHERE id por um UPDATE sem filtro em uma cópia descartável. Um teste com duas missões deve detectar que a outra não poderia mudar. Depois reverta a alteração e mantenha o teste. Não faça esse experimento no banco de alguém.
4
O projeto final pede um caso novo, escrito por você, e uma explicação do que ele não cobre. TestApp não testa um navegador real, instalação limpa, carga ou leitores de tela. Uma revisão útil combina testes adequados com observação e feedback de outra pessoa.

Sua bancada de aplicações

O kit inclui o aplicativo completo para investigar e modificar. O trecho abaixo explica esta etapa; o editor contém o arquivo indicado. A Rullst Academy não compila nem executa esse servidor no navegador.

Arquivo para estudar e modificar

tests/contract.rs

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

Extraia o kit numa pasta nova e abra o terminal junto a Cargo.toml. Use Rust 1.96+; o primeiro build pode baixar dependências e demorar. Depois abra http://127.0.0.1:3010. Pare com Ctrl+C e execute novamente após editar.

cargo test --locked
cargo run --locked

Meus arquivos e GitHub

Baixe seu rascunho e substitua o arquivo indicado na sua cópia extraída. O editor guarda um arquivo neste navegador; a conta guarda avaliações e XP. O ZIP não contém suas alterações. GitHub envia só o arquivo confirmado; para o aplicativo completo use Git manual, sem bancos, backups ou segredos.

Links oficiais e próximo passo

Rust: escrever testes

✦

SUA MISSÃO

Distinguir teste de função, de HTTP e de recuperação; acrescentar uma regressão útil.

Agora é a sua vez

Oficina de descobertas

Decida antes de executar

Distinguir teste de função, de HTTP e de recuperação; acrescentar uma regressão útil.

01Qual teste é adequado para verificar 422 pela rota inteira?02Após rejeitar uma entrada num banco com duas missões, qual contagem esperamos?

Monte suas respostas e confira quando estiver pronto.

Uma pausa para entender

O que um conjunto de testes aprovado permite afirmar?

Nenhuma falha é possívelJá há autonomia profissional comprovadaOs casos exercitados passaram naquele ambiente

Preciso de uma pista

Evidência tem limites. Um caso novo e feedback independente ajudam a descobrir o que o conjunto anterior não cobria.

Carregando sua jornada…

Leve com você

Adicione um teste que conclui uma missão e verifica que outra continua pendente. Faça-o falhar com um defeito deliberado na cópia, corrija e registre antes/depois.

No seu ritmo

Meus arquivos e GitHub

Toda lição pode virar um registro seu: código, anotações ou um plano de prática. Guardar um arquivo no GitHub é opcional e não altera seu XP.

Manual do aluno

O editor e os downloads abrem quando esta lição estiver liberada para sua conta. Confira o acesso abaixo ou volte ao mapa da trilha.

Conferindo seu acesso à lição…

Seu caminho, passo a passo

Baixar material da atividade

Baixe o exemplo da lição e um caderno para suas anotações. O ZIP inclui um guia para organizar atividades em um ou mais repositórios. Publicar é opcional; contas elegíveis também podem usar o botão de envio ao GitHub.

Seu arquivo desta lição

Edite o exemplo ou registre o que aprendeu. Este espaço não executa código nem corrige respostas. O rascunho é salvo apenas neste navegador, separado por conta; baixar e enviar ao GitHub são ações suas.

O exemplo pode ser apenas um trecho ou roteiro. Mudar a extensão não o transforma em programa completo. O ZIP da atividade contém material inicial; o botão de arquivo editado baixa o seu texto.

Meu código ou minhas anotações

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 do arquivo

Seu texto será guardado neste navegador ao editar. Em computador compartilhado, limpe os rascunhos ao terminar.

O envio direto aceita até 8 KiB de texto em um arquivo. Use o download e o guia manual para projetos com vários arquivos.

Testes que investigam o contrato

Vamos descobrir juntos

Sua bancada de aplicações

Arquivo para estudar e modificar

Links oficiais e próximo passo

Agora é a sua vez

Decida antes de executar

Leve com você

Meus arquivos e GitHub

Seu arquivo desta lição

Guardar no meu GitHub

Rullstpetbot