Applications with Rullst I · Lesson 12 / 14

Tests that investigate the contract

Seeing a page open is only the start of verification.

Let's discover together

1
src/validation.rs tests a function without network or database. tests/contract.rs uses Rullst TestApp to send requests through the router and check status and data. The persistence test closes connections and opens new files. Each type answers different questions.
2
Run cargo test --locked. Read names, not only the green total. Rejection evidence needs the correct status and an unchanged database. Parameterized-text evidence includes unusual input and a still-working table. Avoid tests that merely repeat an implementation constant.
3
Choose a plausible bug: replace WHERE id with an unfiltered UPDATE in a disposable copy. A two-mission test should detect that the other must not change. Then revert the bug and keep the test. Do not run this experiment on someone’s database.
4
The final project asks for a new case you write and an explanation of what it does not cover. TestApp does not test a real browser, clean installation, load or screen readers. Useful review combines suitable tests with observation and another person’s feedback.

Your application workbench

The kit includes a complete app to investigate and modify. The excerpt below explains this step; the editor contains the indicated file. Rullst Academy does not compile or run this server in your browser.

File to study and modify

tests/contract.rs

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

Extract the kit to a new folder and open a terminal beside Cargo.toml. Use Rust 1.96+; the first build may download dependencies and take time. Then open http://127.0.0.1:3010. Stop with Ctrl+C and run again after editing.

cargo test --locked
cargo run --locked

My files and GitHub

Download your draft and replace the indicated file in your extracted copy. The editor saves one file in this browser; your account saves assessments and XP. The ZIP excludes your edits. GitHub sends only the confirmed file; use Git manually for the whole app, excluding databases, backups and secrets.

Official links and next step

Rust: writing tests

✦

YOUR MISSION

Distinguish function, HTTP and recovery tests; add a useful regression.

Take it with you

Add a test that completes one mission and verifies another stays pending. Make it fail with a deliberate bug in a copy, fix it and record before/after.

At your own pace

My files and GitHub

Every lesson can become your own record: code, notes or a practice plan. Saving a file to GitHub is optional and does not change your XP.

Student guide

The editor and downloads open when this lesson is available to your account. Check access below or return to the track map.

Checking your access to this lesson…

Your path, step by step

Download activity materials

Download the lesson example and a workbook for your notes. The ZIP includes a guide to organizing activities in one or more repositories. Publishing is optional; eligible accounts can also use the GitHub upload button.

Your file for this lesson

Edit the example or record what you learned. This space does not run code or grade answers. The draft is saved only in this browser, separately per account; you choose when to download or upload to GitHub.

The example may be only a snippet or outline. Changing the extension does not make it a complete program. The activity ZIP contains starting material; the edited-file button downloads your text.

My code or notes

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();
}

File format

Your text will be saved in this browser when you edit it. On a shared computer, clear your drafts when finished.

Direct upload accepts up to 8 KiB of text in one file. Use downloads and the manual guide for projects with multiple files.

Tests that investigate the contract

Let's discover together

Your application workbench

File to study and modify

Official links and next step

Now it's your turn

Decide before running

Take it with you

My files and GitHub

Your file for this lesson

Save to my GitHub

Rullstpetbot