Integration Testing

// tests/integration_test.rs
use autumn_web::prelude::*;
use autumn_web::test::TestApp;

#[get("/hello")]
async fn hello() -> &'static str { "Hello, Autumn!" }

#[tokio::test]
async fn hello_returns_200() {
    let client = TestApp::new()
        .routes(routes![hello])
        .build();

    client.get("/hello").send().await
        .assert_ok()
        .assert_body_contains("Autumn");
}

cargo test

#[tokio::test]
async fn autumn_attaches_request_id_to_every_response() {
    let client = TestApp::new().routes(routes![hello]).build();
    let resp = client.get("/hello").send().await;

    assert!(
        resp.header("x-request-id").is_some(),
        "Autumn's RequestIdLayer must attach X-Request-Id to every response"
    );
}

resp
    .assert_ok()                                   // 200 OK
    .assert_status(201)                            // specific status
    .assert_success()                              // any 2xx
    .assert_header("content-type", "text/plain")   // exact header value
    .assert_header_contains("content-type", "json") // substring
    .assert_body_contains("Alice")                 // body substring
    .assert_body_eq("pong")                        // exact body
    .assert_body_empty()                           // empty body
    .assert_json::<MyType, _>(|val| {              // deserialize + check
        assert_eq!(val.name, "Alice");
    });

#[post("/notes")]
async fn create_note(State(state): State<AppState>) -> &'static str {
    state.broadcast().publish("notes", "created").unwrap();
    "ok"
}

#[tokio::test]
async fn publishing_broadcasts_on_create() {
    let client = TestApp::new()
        .routes(routes![create_note])
        .record_broadcasts()          // opt in
        .build();

    client.post("/notes").send().await.assert_ok();

    client
        .assert_broadcast_count("notes", 1)                       // exactly one publish
        .assert_broadcast("notes", |b| b.payload() == "created")  // a matching payload
        .assert_no_broadcasts("audit");                           // nothing elsewhere
}

#[post("/signup/{id}")]
async fn signup(Path(id): Path<i64>) -> &'static str {
    SendWelcomeJob::enqueue(WelcomeArgs { user_id: id }).await.unwrap();
    "ok"
}

#[tokio::test]
async fn signup_enqueues_and_runs_welcome() {
    let client = TestApp::new()
        .plugin(MyJobs)                 // registers the #[job]s
        .routes(routes![signup])
        .build();

    client.post("/signup/7").send().await.assert_ok();

    // Assert the enqueue (name only, or name + exact payload):
    client.assert_job_enqueued_with("send_welcome", json!({ "user_id": 7 }));

    // Drain the captured queue and run each handler synchronously; the report
    // surfaces per-job errors instead of swallowing them.
    client.perform_enqueued_jobs().await.assert_all_succeeded();
}

// POST /login writes the session; GET /dashboard reuses the cookie automatically.
client.post("/login").form("email=alice@example.com&password=secret").send().await.assert_ok();
client.get("/dashboard").send().await.assert_ok();

let client = TestApp::new().routes(routes![dashboard]).build();
client.acting_as(42).await;                       // authenticated as user 42
client.get("/dashboard").send().await.assert_ok();

client.acting_as(42).await;
client.get("/admin").send().await.assert_status(403); // has no `admin` role
client.log_out();
client.get("/dashboard").send().await.assert_status(401); // session gone

#[tokio::test]
async fn notes_index_renders_one_row_per_note() {
    let client = TestApp::new().routes(routes![notes_index]).build();

    client.get("/notes").send().await
        .assert_ok()
        .assert_selector("table.notes")                  // the table is present
        .assert_selector_count("tbody tr.note-row", 3)   // exactly three rows
        .assert_attr("tr.note-row a", "href", "/notes/1") // first row's link target
        .assert_text("tr.note-row a", "First note")      // …and its visible text
        .assert_no_selector(".flash--error");            // no error flash rendered
}

let hrefs = resp.selector_attr("tbody tr.note-row a", "href");
assert_eq!(hrefs, vec![Some("/notes/1".into()), Some("/notes/2".into())]);

# Cargo.toml  — use the same version as your [dependencies] entry
[dev-dependencies]
autumn-web = { version = "0.5", features = ["test-support"] }
serde_json = "1"

// tests/integration_test.rs
use autumn_web::prelude::*;
use autumn_web::test::{TestApp, TestDb};
use diesel::prelude::*;
use diesel_async::RunQueryDsl;
use serde::{Deserialize, Serialize};

diesel::table! {
    posts (id) {
        id -> Int8,
        title -> Text,
        slug -> Text,
        body -> Text,
        published -> Bool,
    }
}

#[derive(Queryable, Selectable, Serialize)]
#[diesel(table_name = posts)]
struct Post { id: i64, title: String, slug: String, body: String, published: bool }

#[derive(Insertable, Deserialize)]
#[diesel(table_name = posts)]
struct NewPost { title: String, slug: String, body: String, #[serde(default)] published: bool }

#[get("/api/posts")]
async fn list_published(mut db: Db) -> AutumnResult<Json<Vec<Post>>> {
    let rows = posts::table
        .filter(posts::published.eq(true))
        .select(Post::as_select())
        .load(&mut *db).await?;
    Ok(Json(rows))
}

#[post("/api/posts")]
async fn create_post(mut db: Db, Json(body): Json<NewPost>) -> AutumnResult<Json<Post>> {
    let created = diesel::insert_into(posts::table)
        .values(&body)
        .returning(Post::as_returning())
        .get_result(&mut *db).await?;
    Ok(Json(created))
}

async fn setup() -> diesel_async::pooled_connection::deadpool::Pool<
    diesel_async::AsyncPgConnection
> {
    let db = TestDb::shared().await;           // shared container — starts once
    db.execute_sql(
        "CREATE TABLE IF NOT EXISTS posts (
            id BIGSERIAL PRIMARY KEY,
            title TEXT NOT NULL,
            slug  TEXT NOT NULL DEFAULT '',
            body  TEXT NOT NULL DEFAULT '',
            published BOOLEAN NOT NULL DEFAULT false
        )",
    ).await;
    db.execute_sql("TRUNCATE posts RESTART IDENTITY").await;
    db.pool()
}

/// DB round-trip: create a post, then verify it appears in the listing.
#[tokio::test]
#[ignore = "requires Docker (testcontainers)"]
async fn create_post_round_trip() {
    let pool = setup().await;
    let client = TestApp::new()
        .routes(routes![list_published, create_post])
        .with_db(pool)
        .build();

    // Initially empty
    client.get("/api/posts").send().await.assert_ok().assert_body_eq("[]");

    // DB write
    client
        .post("/api/posts")
        .json(&serde_json::json!({
            "title": "Hello from Autumn tests",
            "slug":  "hello-autumn-tests",
            "body":  "Created in an integration test.",
            "published": true
        }))
        .send().await
        .assert_ok()
        .assert_header_contains("content-type", "application/json")
        .assert_json::<serde_json::Value, _>(|post| {
            assert_eq!(post["title"], "Hello from Autumn tests");
            assert!(post["id"].as_i64().unwrap() > 0);
        });

    // DB read — confirm the write persisted
    client.get("/api/posts").send().await
        .assert_ok()
        .assert_json::<Vec<serde_json::Value>, _>(|posts| {
            assert_eq!(posts.len(), 1);
            assert_eq!(posts[0]["title"], "Hello from Autumn tests");
        });
}

# smoke tests only (instant, no Docker)
cargo test

# include Docker-backed DB tests
cargo test -- --include-ignored

# or opt-in via an env var in CI
cargo test -- --include-ignored   # set DOCKER_HOST or TESTCONTAINERS_HOST

cargo test --doc -p autumn-web

// src/models.rs
use crate::schema::posts;

#[autumn_web::model]
pub struct Post {
    #[id]
    pub id: i64,
    pub title: String,
    pub slug: String,
    pub body: String,
    pub published: bool,
    pub views: i32,
}

// Zero required args — only override what your test cares about
let draft: NewPost = Post::factory().build();
assert_eq!(draft.title, "");

// Override one field; all others stay at default
let draft = Post::factory().title("Hello TDD").build();
assert_eq!(draft.title, "Hello TDD");
assert_eq!(draft.views, 0);            // untouched

// Override several fields
let draft = Post::factory()
    .title("Published piece")
    .slug("published-piece")
    .published(true)
    .build();
assert!(draft.published);
assert_eq!(draft.body, "");            // untouched

#[tokio::test]
#[ignore = "requires Docker (testcontainers)"]
async fn post_appears_in_listing() {
    let db = TestDb::shared().await;
    // (run CREATE TABLE ... first)

    let post = Post::factory()
        .title("TDD post")
        .published(true)
        .create(&db.pool())
        .await;

    assert!(post.id > 0);
    assert_eq!(post.title, "TDD post");
}

// 1. Persist the parent
let post = Post::factory().title("Parent").create(&db.pool()).await;

// 2. Build the child referencing the parent's id
let comment = Comment::factory()
    .post_id(post.id)
    .body("Great read!")
    .create(&db.pool())
    .await;

assert_eq!(comment.post_id, post.id);

// Before: 25+ lines of NewUser { id: 1, email: "a@b.c".into(), ... }
// After factory pattern:
let user    = User::factory().email("alice@example.com").create(&pool).await;
let post    = Post::factory().user_id(user.id).title("Hello").published(true).create(&pool).await;
let comment = Comment::factory().post_id(post.id).body("Nice!").create(&pool).await;

use autumn_web::prelude::*;
use autumn_web::time::Clock;

#[get("/token-age")]
async fn token_age(clock: Clock) -> String {
    format!("current time: {}", clock.now())
}

use autumn_web::test::TestApp;
use autumn_web::time::FixedClock;
use chrono::{TimeZone, Utc};

#[tokio::test]
async fn token_is_fresh_at_issue_time() {
    let issued_at = Utc.with_ymd_and_hms(2025, 1, 1, 0, 0, 0).unwrap();
    let client = TestApp::new()
        .routes(routes![token_age])
        .with_clock(FixedClock::at(issued_at))
        .build();

    client.get("/token-age").send().await.assert_ok();
}

use autumn_web::test::TestApp;
use autumn_web::time::{Clock, TickingClock};
use chrono::{TimeZone, Utc};
use std::time::Duration;

#[get("/token")]
async fn check_token(clock: Clock) -> axum::http::StatusCode {
    let issued = Utc.with_ymd_and_hms(2025, 1, 1, 0, 0, 0).unwrap();
    if clock.now() < issued + chrono::Duration::days(30) {
        axum::http::StatusCode::OK
    } else {
        axum::http::StatusCode::UNAUTHORIZED
    }
}

#[tokio::test]
async fn token_expires_after_30_days() {
    let issued = Utc.with_ymd_and_hms(2025, 1, 1, 0, 0, 0).unwrap();
    let client = TestApp::new()
        .routes(routes![check_token])
        .with_clock(TickingClock::starting_at(issued))
        .build();

    client.get("/token").send().await.assert_status(200); // valid at issue

    client.advance_clock(Duration::from_secs(29 * 24 * 3600));
    client.get("/token").send().await.assert_status(200); // still valid

    client.advance_clock(Duration::from_secs(2 * 24 * 3600));
    client.get("/token").send().await.assert_status(401); // expired!
}

let clock = TickingClock::starting_at(Utc::now());
let client = TestApp::new()
    .with_clock(clock.clone())  // shares state with `clock`
    .build();

clock.advance(Duration::from_secs(3600)); // or: client.advance_clock(...)

use autumn_web::time::{TickingClock, clock_unix_secs};
use autumn_web::storage::local::{SigningKey, sign, verify_with_now};

let clock = TickingClock::starting_at(Utc::now());
let key = SigningKey::new(b"my-signing-key".to_vec());
let blob_key = "uploads/file.png";

let now = clock_unix_secs(&clock);
let expires_at = now + 300; // 5 minutes
let sig = sign(key.as_bytes(), blob_key, expires_at);

// Advance past expiry without sleeping:
clock.advance(Duration::from_secs(400));
assert!(verify_with_now(key.as_bytes(), blob_key, expires_at, &sig, clock_unix_secs(&clock)).is_err());