jelq

public
an http based roguelike rpg about jelqing
Star0
Watch0
39 commits 1 branch 0 tags 0 releases1.3 MiB
use std::{
    sync::Arc,
    time::{Duration, Instant},
};

use axum::{
    Router,
    body::{Body, to_bytes},
    http::{Method, Request, StatusCode, Version, header},
    response::Response,
};
use serde_json::Value;
use tower::ServiceExt;

use crate::{
    AppState, Config,
    game::{
        Floor, MumVisit, Run, Story,
        balance::{BRANCH_TURN, STORAGE_GIRTH, SUSPICION_LIMIT},
    },
    router,
};

async fn send(
    app: &Router,
    method: &str,
    uri: &str,
    headers: &[(&str, &str)],
    body: &str,
) -> Response {
    let mut request = Request::builder()
        .method(Method::from_bytes(method.as_bytes()).unwrap())
        .uri(uri);
    for (name, value) in headers {
        request = request.header(*name, *value);
    }
    app.clone()
        .oneshot(request.body(Body::from(body.to_owned())).unwrap())
        .await
        .unwrap()
}

async fn json(response: Response) -> Value {
    serde_json::from_slice(&to_bytes(response.into_body(), usize::MAX).await.unwrap()).unwrap()
}

async fn text(response: Response) -> String {
    String::from_utf8(
        to_bytes(response.into_body(), usize::MAX)
            .await
            .unwrap()
            .to_vec(),
    )
    .unwrap()
}

fn header<'a>(response: &'a Response, name: &str) -> &'a str {
    response.headers()[name].to_str().unwrap()
}

fn fixture() -> Run {
    Run::new("cafebabe".into(), "cafe".into(), 69)
}

fn seeded_with(floor: Floor, setup: impl FnOnce(&mut Run)) -> Router {
    let state = Arc::new(AppState::default());
    let mut run = fixture();
    run.floor = floor;
    setup(&mut run);
    state.insert(run);
    router(state)
}

fn seeded(floor: Floor) -> (Router, String) {
    let state = Arc::new(AppState::default());
    let mut run = fixture();
    run.floor = floor;
    let etag = run.origin_etag();
    state.insert(run);
    (router(state), etag)
}

fn app() -> Router {
    crate::app(Config::default())
}

fn mum_at_the_door(run: &mut Run) {
    run.mum = Some(MumVisit {
        errand: "She heard a noise.",
        nonce: "abc".into(),
        strikes: 0,
        knocked: false,
    });
}

#[tokio::test]
async fn creating_a_run_returns_location_and_etag() {
    let response = send(&app(), "POST", "/runs?seed=1", &[], "").await;
    assert_eq!(response.status(), StatusCode::CREATED);
    assert!(header(&response, "location").starts_with("/runs/"));
    assert!(response.headers().contains_key(header::ETAG));
    assert_eq!(header(&response, "server"), "jelqd/0.6.9");
}

#[tokio::test]
async fn bodies_do_not_repeat_the_headers() {
    let (app, _) = seeded(Floor::Bedroom);
    let response = send(&app, "GET", "/runs/cafebabe", &[], "").await;
    assert!(response.headers().contains_key("x-eq"));
    let body = json(response).await;
    for stat in [
        "eq",
        "girth",
        "foreskin",
        "stamina",
        "cash",
        "self_reported_length",
    ] {
        assert!(body.get(stat).is_none(), "{stat} is already a header");
    }
}

#[tokio::test]
async fn jelqing_cold_fails_the_precondition() {
    let (app, _) = seeded(Floor::Bedroom);
    let response = send(&app, "JELQ", "/runs/cafebabe?technique=stretch", &[], "").await;
    assert_eq!(response.status(), StatusCode::PRECONDITION_FAILED);
    assert_eq!(
        header(&response, "content-type"),
        "application/problem+json"
    );
}

#[tokio::test]
async fn wet_without_lube_is_unsupported_media() {
    let (app, _) = seeded(Floor::Bedroom);
    send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
    let response = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &[], "").await;
    assert_eq!(response.status(), StatusCode::UNSUPPORTED_MEDIA_TYPE);
    let images = send(
        &app,
        "JELQ",
        "/runs/cafebabe?technique=wet",
        &[("content-type", "image/jpeg")],
        "",
    )
    .await;
    assert_eq!(json(images).await["detail"], "No.");
}

#[tokio::test]
async fn unknown_methods_are_not_implemented() {
    let (app, _) = seeded(Floor::Bedroom);
    let response = send(&app, "MILK", "/runs/cafebabe", &[], "").await;
    assert_eq!(response.status(), StatusCode::NOT_IMPLEMENTED);
    let teapot = send(&app, "BREW", "/runs/cafebabe", &[], "").await;
    assert_eq!(teapot.status(), StatusCode::IM_A_TEAPOT);
}

#[tokio::test]
async fn the_clinic_does_not_advertise_jelq() {
    let (app, _) = seeded(Floor::Clinic);
    let options = send(&app, "OPTIONS", "/runs/cafebabe", &[], "").await;
    assert!(!header(&options, "allow").contains("JELQ"));
    let jelq = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &[], "").await;
    assert_eq!(jelq.status(), StatusCode::METHOD_NOT_ALLOWED);
    assert!(!header(&jelq, "allow").contains("JELQ"));
    let (bedroom, _) = seeded(Floor::Bedroom);
    let options = send(&bedroom, "OPTIONS", "/runs/cafebabe", &[], "").await;
    assert!(header(&options, "allow").contains("JELQ"));
}

#[tokio::test]
async fn patch_only_accepts_the_truth() {
    let (app, _) = seeded(Floor::Bedroom);
    let patch = [("content-type", "application/json-patch+json")];
    let replace = send(
        &app,
        "PATCH",
        "/runs/cafebabe",
        &patch,
        r#"[{"op":"replace","path":"/length","value":12}]"#,
    )
    .await;
    assert_eq!(replace.status(), StatusCode::UNPROCESSABLE_ENTITY);
    let lie = send(
        &app,
        "PATCH",
        "/runs/cafebabe",
        &patch,
        r#"[{"op":"test","path":"/length","value":40}]"#,
    )
    .await;
    assert_eq!(
        json(lie).await["type"],
        "https://jelq.dev/problems/exaggeration"
    );
}

#[tokio::test]
async fn deleting_the_foreskin_requires_certainty() {
    let (app, _) = seeded(Floor::Bedroom);
    let response = send(&app, "DELETE", "/runs/cafebabe/foreskin", &[], "").await;
    assert_eq!(response.status(), StatusCode::PRECONDITION_REQUIRED);
    let look = send(&app, "GET", "/runs/cafebabe/foreskin", &[], "").await;
    assert_eq!(look.status(), StatusCode::OK);
    let etag = header(&look, "etag").to_owned();
    assert!(text(look).await.contains('~'));
    let response = send(
        &app,
        "DELETE",
        "/runs/cafebabe/foreskin",
        &[("if-match", &etag)],
        "",
    )
    .await;
    assert_eq!(response.status(), StatusCode::NO_CONTENT);
    let response = send(&app, "GET", "/runs/cafebabe/foreskin", &[], "").await;
    assert_eq!(response.status(), StatusCode::GONE);
}

#[tokio::test]
async fn length_is_chunked_until_the_ruler() {
    let (app, _) = seeded(Floor::Bedroom);
    let lie = send(&app, "GET", "/runs/cafebabe/length", &[], "").await;
    assert!(!lie.headers().contains_key(header::CONTENT_LENGTH));
    let app = seeded_with(Floor::Bedroom, |run| run.items.ruler = true);
    let truth = send(&app, "GET", "/runs/cafebabe/length", &[], "").await;
    let declared: usize = header(&truth, "content-length").parse().unwrap();
    let body = text(truth).await;
    assert_eq!(body.len(), declared);
    assert!(body.starts_with("8=") && body.ends_with('D'));
}

#[tokio::test]
async fn length_supports_inch_ranges() {
    let (app, _) = seeded(Floor::Bedroom);
    let response = send(
        &app,
        "GET",
        "/runs/cafebabe/length",
        &[("range", "inches=0-1")],
        "",
    )
    .await;
    assert_eq!(response.status(), StatusCode::PARTIAL_CONTENT);
    assert!(header(&response, "content-range").starts_with("inches 0.00-1.00/"));
    assert_eq!(text(response).await.len(), 25);
    let absurd = send(
        &app,
        "GET",
        "/runs/cafebabe/length",
        &[("range", "inches=40-50")],
        "",
    )
    .await;
    assert_eq!(absurd.status(), StatusCode::RANGE_NOT_SATISFIABLE);
    let malformed = send(
        &app,
        "GET",
        "/runs/cafebabe/length",
        &[("range", "inches=6.17")],
        "",
    )
    .await;
    assert_eq!(malformed.status(), StatusCode::OK);
    let suffix = send(
        &app,
        "GET",
        "/runs/cafebabe/length",
        &[("range", "inches=-1")],
        "",
    )
    .await;
    assert_eq!(suffix.status(), StatusCode::PARTIAL_CONTENT);
    assert!(text(suffix).await.ends_with('D'));
    for (range, status) in [
        ("inches=1-", StatusCode::PARTIAL_CONTENT),
        ("inches=40-", StatusCode::RANGE_NOT_SATISFIABLE),
        ("inches=-0", StatusCode::RANGE_NOT_SATISFIABLE),
        ("inches=2-1", StatusCode::OK),
        ("inches=NaN-2", StatusCode::OK),
        ("inches=0-inf", StatusCode::OK),
    ] {
        let response = send(
            &app,
            "GET",
            "/runs/cafebabe/length",
            &[("range", range)],
            "",
        )
        .await;
        assert_eq!(response.status(), status, "{range}");
    }
}

#[tokio::test]
async fn the_clinic_escalates_toward_honesty() {
    let (app, _) = seeded(Floor::Clinic);
    let mut hints = Vec::new();
    for _ in 0..3 {
        let response = send(
            &app,
            "GET",
            "/runs/cafebabe/diagnosis",
            &[("authorization", "Excuse \"changing\"")],
            "",
        )
        .await;
        assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
        hints.push(header(&response, "www-authenticate").to_owned());
    }
    assert!(hints[2].contains("Be honest."));
}

#[tokio::test]
async fn the_true_ending_is_not_modified() {
    let (early, _) = seeded(Floor::Bedroom);
    let response = send(&early, "GET", "/runs/cafebabe/diagnosis", &[], "").await;
    assert_eq!(response.status(), StatusCode::TOO_EARLY);

    let (app, etag) = seeded(Floor::Clinic);
    assert!(
        !etag.contains("cafebabe"),
        "the origin ETag must not be derivable from the id"
    );
    let response = send(
        &app,
        "GET",
        "/runs/cafebabe/diagnosis",
        &[
            ("authorization", "Bearer honesty"),
            ("if-none-match", &etag),
        ],
        "",
    )
    .await;
    assert_eq!(response.status(), StatusCode::NOT_MODIFIED);
    assert_eq!(header(&response, "x-diagnosis"), "normal");
}

#[tokio::test]
async fn mum_accepts_a_known_excuse() {
    let app = seeded_with(Floor::Bedroom, mum_at_the_door);
    let response = send(&app, "GET", "/runs/cafebabe", &[], "").await;
    assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
    assert_eq!(header(&response, "via"), "1.1 mum");
    let response = send(
        &app,
        "GET",
        "/runs/cafebabe",
        &[("authorization", "Excuse \"homework\"")],
        "",
    )
    .await;
    assert_eq!(response.status(), StatusCode::OK);
}

#[tokio::test]
async fn mum_runs_out_of_patience() {
    let app = seeded_with(Floor::Bedroom, mum_at_the_door);
    let lie = [("authorization", "Excuse \"it is for science\"")];
    for _ in 0..2 {
        let response = send(&app, "GET", "/runs/cafebabe", &lie, "").await;
        assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
    }
    let caught = send(&app, "GET", "/runs/cafebabe", &lie, "").await;
    assert_eq!(caught.status(), StatusCode::GONE);
    assert_eq!(
        json(caught).await["type"],
        "https://jelq.dev/problems/caught"
    );
}

#[tokio::test]
async fn mum_remembers_excuses_by_christmas() {
    let app = seeded_with(Floor::Nans, |run| {
        mum_at_the_door(run);
        run.heard.push("homework".into());
    });
    let basic = send(
        &app,
        "GET",
        "/runs/cafebabe",
        &[("authorization", "Excuse \"changing\"")],
        "",
    )
    .await;
    assert_eq!(basic.status(), StatusCode::UNAUTHORIZED);
    assert!(header(&basic, "www-authenticate").starts_with("Digest"));
    let replay = send(
        &app,
        "GET",
        "/runs/cafebabe",
        &[(
            "authorization",
            "Digest username=\"homework\", nonce=\"abc\"",
        )],
        "",
    )
    .await;
    assert_eq!(
        json(replay).await["type"],
        "https://jelq.dev/problems/excuse-replayed"
    );
    let fresh = send(
        &app,
        "GET",
        "/runs/cafebabe",
        &[(
            "authorization",
            "Digest username=\"wrapping presents\", nonce=\"abc\"",
        )],
        "",
    )
    .await;
    assert_eq!(fresh.status(), StatusCode::OK);
}

#[tokio::test]
async fn a_pulled_muscle_is_a_true_excuse() {
    let app = seeded_with(Floor::Nans, |run| {
        mum_at_the_door(run);
        run.conditions.pulled_muscle = true;
        run.heard.push("pulled a muscle".into());
    });
    let response = send(
        &app,
        "GET",
        "/runs/cafebabe",
        &[(
            "authorization",
            "Digest username=\"pulled a muscle\", nonce=\"abc\"",
        )],
        "",
    )
    .await;
    assert_eq!(response.status(), StatusCode::OK);
    assert!(header(&response, "x-stamina").ends_with("/7"));
}

#[tokio::test]
async fn floors_end_when_they_end() {
    let app = seeded_with(Floor::Bedroom, |_| {});
    let early = send(&app, "POST", "/runs/cafebabe/floor", &[], "").await;
    assert_eq!(early.status(), StatusCode::TOO_EARLY);
    let app = seeded_with(Floor::Bedroom, |run| run.here.turns = 6);
    let next = send(&app, "POST", "/runs/cafebabe/floor", &[], "").await;
    assert!(
        next.status() == StatusCode::SEE_OTHER || next.status() == StatusCode::CONFLICT,
        "either the floor changed or the zip did"
    );
}

#[tokio::test]
async fn pump_bro_upsells() {
    let closed = seeded_with(Floor::Bedroom, |_| {});
    let response = send(&closed, "GET", "/runs/cafebabe/shop", &[], "").await;
    assert_eq!(response.status(), StatusCode::NOT_FOUND);

    let app = seeded_with(Floor::ChangingRoom, |_| {});
    let pump = send(&app, "POST", "/runs/cafebabe/shop/pump", &[], "").await;
    assert_eq!(pump.status(), StatusCode::UPGRADE_REQUIRED);
    assert_eq!(header(&pump, "upgrade"), "pump-pro/2.0");
    let pro = send(&app, "POST", "/runs/cafebabe/shop/pump-pro", &[], "").await;
    assert_eq!(pro.status(), StatusCode::CREATED);
    let broke = send(&app, "POST", "/runs/cafebabe/shop/extender", &[], "").await;
    assert_eq!(broke.status(), StatusCode::PAYMENT_REQUIRED);
}

#[tokio::test]
async fn only_the_key_opens_the_cage() {
    let app = seeded_with(Floor::ChangingRoom, |run| run.items.cage = true);
    send(&app, "POST", "/runs/cafebabe/shop/ice-pack", &[], "").await;
    let still = send(
        &app,
        "GET",
        "/runs/cafebabe/inventory/chastity-cage",
        &[],
        "",
    )
    .await;
    assert_eq!(still.status(), StatusCode::OK);
    send(&app, "POST", "/runs/cafebabe/shop/cage-key", &[], "").await;
    let gone = send(
        &app,
        "GET",
        "/runs/cafebabe/inventory/chastity-cage",
        &[],
        "",
    )
    .await;
    assert_eq!(gone.status(), StatusCode::NOT_FOUND);
}

#[tokio::test]
async fn combos_are_multi_status_xml() {
    let app = seeded_with(Floor::Bathroom, |run| {
        run.foreskin = Some(1.0);
        run.items.blinds = true;
    });
    send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
    let response = send(
        &app,
        "JELQ",
        "/runs/cafebabe?technique=wet,stretch",
        &[("content-type", "application/baby-oil")],
        "",
    )
    .await;
    assert_eq!(response.status(), StatusCode::MULTI_STATUS);
    assert!(text(response).await.contains("<D:multistatus"));
}

#[tokio::test]
async fn the_elder_is_stale() {
    let app = seeded_with(Floor::Forum, |run| run.length = 5.0);
    let unverified = send(&app, "GET", "/runs/cafebabe/elder", &[], "").await;
    assert_eq!(
        unverified.status(),
        StatusCode::PROXY_AUTHENTICATION_REQUIRED
    );
    let lie = send(
        &app,
        "GET",
        "/runs/cafebabe/elder",
        &[("proxy-authorization", "Ruler 9")],
        "",
    )
    .await;
    assert_eq!(lie.status(), StatusCode::BAD_REQUEST);
    let csv = send(
        &app,
        "GET",
        "/runs/cafebabe/elder",
        &[("proxy-authorization", "Ruler 5.0")],
        "",
    )
    .await;
    assert_eq!(csv.status(), StatusCode::OK);
    let stale = send(
        &app,
        "GET",
        "/runs/cafebabe/elder",
        &[("if-modified-since", "Mon, 15 Jun 2009 00:00:00 GMT")],
        "",
    )
    .await;
    assert_eq!(stale.status(), StatusCode::NOT_MODIFIED);
}

#[tokio::test]
async fn the_displayed_length_is_accepted_as_honest() {
    let app = seeded_with(Floor::Forum, |run| run.length = 5.2496);
    let response = send(
        &app,
        "GET",
        "/runs/cafebabe/elder",
        &[("proxy-authorization", "Ruler 5.25")],
        "",
    )
    .await;
    assert_eq!(response.status(), StatusCode::OK);
}

#[tokio::test]
async fn the_hotel_has_a_captive_portal() {
    let app = seeded_with(Floor::Hotel, |_| {});
    let blocked = send(&app, "GET", "/runs/cafebabe", &[], "").await;
    assert_eq!(
        blocked.status(),
        StatusCode::NETWORK_AUTHENTICATION_REQUIRED
    );
    let accepted = send(&app, "POST", "/runs/cafebabe/portal", &[], "").await;
    assert_eq!(accepted.status(), StatusCode::SEE_OTHER);
    let online = send(&app, "GET", "/runs/cafebabe", &[], "").await;
    assert_eq!(online.status(), StatusCode::OK);
}

#[tokio::test]
async fn the_internet_never_forgets() {
    let app = seeded_with(Floor::Bedroom, |run| {
        run.filmed_at = Some(std::time::SystemTime::now());
    });
    let footage = send(&app, "GET", "/runs/cafebabe/footage", &[], "").await;
    assert_eq!(footage.status(), StatusCode::OK);
    assert_eq!(
        header(&footage, "cache-control"),
        "public, max-age=31536000, immutable"
    );
    assert!(footage.headers().contains_key(header::AGE));
    let delete = send(&app, "DELETE", "/runs/cafebabe/footage", &[], "").await;
    assert_eq!(delete.status(), StatusCode::METHOD_NOT_ALLOWED);
    assert!(!header(&delete, "allow").contains("DELETE"));
}

#[tokio::test]
async fn forged_ruler_cookies_are_lies() {
    let forged = send(
        &app(),
        "GET",
        "/leaderboard?sort=content-length",
        &[("cookie", "ruler=1")],
        "",
    )
    .await;
    assert_eq!(forged.status(), StatusCode::BAD_REQUEST);
}

#[tokio::test]
async fn listings_never_reveal_the_private_id() {
    let app = app();
    let created = send(&app, "POST", "/runs", &[], "").await;
    let location = header(&created, "location").to_owned();
    let board = text(send(&app, "GET", "/leaderboard", &[], "").await).await;
    let private = location.trim_start_matches("/runs/");
    assert!(!board.contains(private));
    let entry: Value = serde_json::from_str(&board).unwrap();
    let public = entry["entries"][0]["public_id"].as_str().unwrap();
    let guess = send(&app, "DELETE", &format!("/runs/{public}"), &[], "").await;
    assert_eq!(guess.status(), StatusCode::NOT_FOUND);
}

#[tokio::test]
async fn seeded_runs_are_unranked() {
    let app = app();
    send(&app, "POST", "/runs?seed=7", &[], "").await;
    let board = json(send(&app, "GET", "/leaderboard", &[], "").await).await;
    assert_eq!(board["entries"].as_array().unwrap().len(), 0);
    let all = json(send(&app, "GET", "/leaderboard?seeded=include", &[], "").await).await;
    assert_eq!(all["entries"][0]["ranked"], false);
}

#[tokio::test]
async fn idle_runs_are_evicted_and_the_server_has_a_limit() {
    let forgetful = crate::app(Config {
        idle_ttl: Duration::ZERO,
        ..Config::default()
    });
    let first = send(&forgetful, "POST", "/runs", &[], "").await;
    let location = header(&first, "location").to_owned();
    send(&forgetful, "POST", "/runs", &[], "").await;
    let gone = send(&forgetful, "GET", &location, &[], "").await;
    assert_eq!(gone.status(), StatusCode::NOT_FOUND);

    let tiny = crate::app(Config {
        max_runs: 1,
        ..Config::default()
    });
    send(&tiny, "POST", "/runs", &[], "").await;
    let full = send(&tiny, "POST", "/runs", &[], "").await;
    assert_eq!(full.status(), StatusCode::SERVICE_UNAVAILABLE);
}

#[tokio::test]
async fn shame_from_two_runs_adds_up() {
    let state = Arc::new(AppState::default());
    state.insert(fixture());
    state.insert(Run::new("deadbeef".into(), "dead".into(), 7));
    let app = router(state);
    let first = send(&app, "TRACE", "/runs/cafebabe", &[], "").await;
    assert_eq!(header(&first, "x-shame"), "1");
    let cookie = header(&first, "set-cookie")
        .split(';')
        .next()
        .unwrap()
        .to_owned();
    let second = send(&app, "TRACE", "/runs/deadbeef", &[("cookie", &cookie)], "").await;
    assert_eq!(header(&second, "x-shame"), "2");
}

#[tokio::test]
async fn the_root_negotiates() {
    let app = app();
    let browser = send(&app, "GET", "/", &[("accept", "text/html,*/*")], "").await;
    assert_eq!(browser.status(), StatusCode::SEE_OTHER);
    assert_eq!(header(&browser, "location"), "/ui/");
    let curl = send(&app, "GET", "/", &[("accept", "*/*")], "").await;
    assert_eq!(json(curl).await["ui"], "/ui/");
    let page = send(&app, "GET", "/ui/", &[], "").await;
    assert_eq!(page.status(), StatusCode::OK);
}

#[tokio::test]
async fn the_ui_replays_what_browsers_cannot_send() {
    let app = app();
    let envelope =
        r#"{"method": "TRACE", "path": "/graveyard", "headers": [["X-Confession", "I did it"]]}"#;
    let traced = json(send(&app, "POST", "/ui/send", &[], envelope).await).await;
    assert_eq!(traced["status"], 405);
    let envelope = r#"{"method": "GET", "path": "/", "headers": [["Accept", "text/html"]]}"#;
    let redirected = json(send(&app, "POST", "/ui/send", &[], envelope).await).await;
    assert_eq!(redirected["status"], 303);
    assert_eq!(redirected["reason"], "See Other");
}

#[tokio::test]
async fn the_ui_decodes_gzip_for_display() {
    let app = seeded_with(Floor::Bedroom, |run| run.items.ring = true);
    let envelope =
        r#"{"method": "GET", "path": "/runs/cafebabe", "headers": [["Accept-Encoding", "gzip"]]}"#;
    let shown = json(send(&app, "POST", "/ui/send", &[], envelope).await).await;
    assert!(
        shown["body"]
            .as_str()
            .unwrap()
            .contains("\"public_id\":\"cafe\"")
    );
    let encoding = shown["headers"]
        .as_array()
        .unwrap()
        .iter()
        .any(|h| h[0] == "content-encoding" && h[1] == "gzip");
    assert!(encoding);
}

#[tokio::test]
async fn http_1_0_gets_the_pdf_treatment() {
    let request = Request::builder()
        .uri("/graveyard")
        .version(Version::HTTP_10)
        .body(Body::empty())
        .unwrap();
    let response = app().oneshot(request).await.unwrap();
    assert_eq!(response.status(), StatusCode::HTTP_VERSION_NOT_SUPPORTED);
}

#[tokio::test]
async fn mom_speaks_american() {
    let app = seeded_with(Floor::Nans, mum_at_the_door);
    let us = [("accept-language", "en-US")];
    let knock = send(&app, "GET", "/runs/cafebabe", &us, "").await;
    assert_eq!(header(&knock, "content-language"), "en-US");
    assert_eq!(header(&knock, "via"), "1.1 mom");
    assert!(
        json(knock).await["detail"]
            .as_str()
            .unwrap()
            .contains("Someone is at the door.")
    );
    let excuse = [
        ("accept-language", "en-US"),
        (
            "authorization",
            "Digest username=\"carving the turkey\", nonce=\"abc\"",
        ),
    ];
    let answered = send(&app, "GET", "/runs/cafebabe", &excuse, "").await;
    assert_eq!(answered.status(), StatusCode::OK);
    let floor = json(send(&app, "GET", "/runs/cafebabe/floor", &us, "").await).await;
    assert_eq!(floor["name"], "Grandma's house for Thanksgiving");
}

#[tokio::test]
async fn the_default_locale_is_british() {
    let (app, _) = seeded(Floor::Nans);
    let floor = send(&app, "GET", "/runs/cafebabe/floor", &[], "").await;
    assert_eq!(header(&floor, "content-language"), "en-GB");
    assert!(header(&floor, "vary").contains("Accept-Language"));
    assert_eq!(json(floor).await["name"], "Nan's house at Christmas");
}

fn advertised(response: &Response) -> Vec<String> {
    header(response, "link")
        .split(", <")
        .filter(|entry| entry.contains("rels/technique"))
        .filter_map(|entry| {
            entry
                .split("title=\"")
                .nth(1)?
                .split('"')
                .next()
                .map(str::to_owned)
        })
        .collect()
}

#[tokio::test]
async fn links_offer_only_usable_techniques() {
    let app = seeded_with(Floor::Bedroom, |run| run.foreskin = Some(1.0));
    let cold = send(&app, "GET", "/runs/cafebabe", &[], "").await;
    assert_eq!(advertised(&cold), ["warmup", "ice", "meditate"]);
    let warm = send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
    let usable = advertised(&warm);
    assert!(usable.contains(&"wet".to_owned()) && usable.contains(&"dry".to_owned()));
    assert!(!usable.contains(&"uli".to_owned()), "uli needs the forum");
    assert!(!usable.contains(&"pump".to_owned()), "pump needs a pump");
    assert!(
        header(&warm, "link").contains("title=\"wet\"; allow=\"JELQ\"; lubricant=\"required\"")
    );

    let (forum, _) = seeded(Floor::Forum);
    let response = send(&forum, "GET", "/runs/cafebabe", &[], "").await;
    assert!(advertised(&response).is_empty());
}

fn linked_rels(response: &Response) -> Vec<String> {
    header(response, "link")
        .split(", <")
        .filter_map(|entry| {
            entry
                .split("rels/")
                .nth(1)?
                .split('"')
                .next()
                .map(str::to_owned)
        })
        .filter(|rel| rel != "technique")
        .collect()
}

#[tokio::test]
async fn links_hide_resources_that_would_do_nothing() {
    let (bedroom, _) = seeded(Floor::Bedroom);
    let before = linked_rels(&send(&bedroom, "GET", "/runs/cafebabe", &[], "").await);
    assert!(before.contains(&"drawer".to_owned()));
    assert!(!before.contains(&"diagnosis".to_owned()));
    assert!(!before.contains(&"thread".to_owned()));
    let searched = send(&bedroom, "POST", "/runs/cafebabe/drawer", &[], "").await;
    assert!(!linked_rels(&searched).contains(&"drawer".to_owned()));

    let (clinic, _) = seeded(Floor::Clinic);
    let rels = linked_rels(&send(&clinic, "GET", "/runs/cafebabe", &[], "").await);
    assert!(rels.contains(&"diagnosis".to_owned()) && rels.contains(&"thread".to_owned()));
}

#[tokio::test]
async fn ignoring_mum_has_consequences() {
    let app = seeded_with(Floor::Bedroom, |run| {
        mum_at_the_door(run);
        run.here.turns = 6;
    });
    let knock = send(&app, "GET", "/runs/cafebabe", &[], "").await;
    assert_eq!(
        json(knock).await["type"],
        "https://jelq.dev/problems/someone-at-the-door"
    );
    let leave = send(&app, "POST", "/runs/cafebabe/floor", &[], "").await;
    assert_eq!(
        leave.status(),
        StatusCode::UNAUTHORIZED,
        "no leaving with Mum at the door"
    );
    send(&app, "GET", "/runs/cafebabe", &[], "").await;
    let opened = send(&app, "GET", "/runs/cafebabe", &[], "").await;
    assert_eq!(opened.status(), StatusCode::GONE);
    assert_eq!(
        json(opened).await["type"],
        "https://jelq.dev/problems/opened"
    );
}

#[tokio::test]
async fn caged_drawers_are_noisy_and_eventually_give_up_the_key() {
    let app = seeded_with(Floor::ChangingRoom, |run| run.items.cage = true);
    let mut statuses = Vec::new();
    for _ in 0..12 {
        let response = send(&app, "POST", "/runs/cafebabe/drawer", &[], "").await;
        statuses.push(response.status());
        if response.status() == StatusCode::OK {
            break;
        }
    }
    assert_eq!(statuses.last(), Some(&StatusCode::OK), "{statuses:?}");
    assert!(
        statuses[..statuses.len() - 1]
            .iter()
            .all(|s| *s == StatusCode::NO_CONTENT)
    );
}

#[tokio::test]
async fn the_ruler_replaces_the_self_report() {
    let app = seeded_with(Floor::Bedroom, |_| {});
    let before = send(&app, "GET", "/runs/cafebabe", &[], "").await;
    assert!(before.headers().contains_key("x-self-reported-length"));
    assert!(!before.headers().contains_key("x-length"));

    let app = seeded_with(Floor::Bedroom, |run| run.items.ruler = true);
    let after = send(&app, "GET", "/runs/cafebabe", &[], "").await;
    assert!(!after.headers().contains_key("x-self-reported-length"));
    assert!(after.headers().contains_key("x-length"));
}

#[tokio::test]
async fn an_open_tab_is_linked_and_jelq_still_answers_with_choices() {
    let app = seeded_with(Floor::Bathroom, |run| {
        run.story = Story::Pending;
        run.warmed_up = true;
    });
    let response = send(&app, "GET", "/runs/cafebabe", &[], "").await;
    let links = header(&response, "link");
    assert!(links.contains("/branches/forum>; rel=\"https://jelq.dev/rels/branch\""));
    assert!(links.contains("/branches/close-tab>; rel=\"https://jelq.dev/rels/branch\""));
    assert!(links.contains("?technique=wet>"));
    let jelq = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
    assert_eq!(jelq.status(), StatusCode::MULTIPLE_CHOICES);
}

#[tokio::test]
async fn either_story_choice_is_reachable_during_cooldown() {
    for choice in ["forum", "close-tab"] {
        let app = seeded_with(Floor::Bathroom, |run| {
            run.turn = 9;
            run.warmed_up = true;
            run.eq = 45;
            run.stamina = 1;
            run.items.door_locks = 1;
        });
        let tenth = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
        assert_eq!(tenth.status(), StatusCode::OK);
        let response = send(&app, "GET", "/runs/cafebabe", &[], "").await;
        assert!(!header(&response, "link").contains("?technique="));
        let path = format!("/runs/cafebabe/branches/{choice}");
        assert!(
            header(&response, "link")
                .contains(&format!("<{path}>; rel=\"https://jelq.dev/rels/branch\""))
        );
        let chosen = send(&app, "POST", &path, &[], "").await;
        assert_eq!(chosen.status(), StatusCode::SEE_OTHER);
        assert!(!header(&chosen, "link").contains("/branches/"));
        let repeated = send(&app, "POST", &path, &[], "").await;
        assert_eq!(repeated.status(), StatusCode::CONFLICT);
    }
}

#[tokio::test]
async fn a_door_lock_says_when_it_was_used() {
    let app = seeded_with(Floor::Bathroom, |run| {
        run.items.door_locks = 1;
        run.suspicion = SUSPICION_LIMIT;
        run.warmed_up = true;
    });
    let response = send(&app, "JELQ", "/runs/cafebabe?technique=dry", &[], "").await;
    assert_ne!(response.status(), StatusCode::CONFLICT);
    assert!(
        response
            .headers()
            .get_all("warning")
            .iter()
            .any(|w| w.to_str().unwrap().contains("your brother tried the door"))
    );
}

#[tokio::test]
async fn shopping_survives_browsing_but_not_jelqing() {
    let app = seeded_with(Floor::ChangingRoom, |run| run.cash = 50);
    send(&app, "GET", "/runs/cafebabe/shop", &[], "").await;
    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
    assert!(header(&view, "link").contains("shop-item"));
    let jelq = send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
    assert_ne!(jelq.status(), StatusCode::METHOD_NOT_ALLOWED);
    let after = send(&app, "GET", "/runs/cafebabe", &[], "").await;
    assert!(!header(&after, "link").contains("shop-item"));
}

#[tokio::test]
async fn the_thread_announces_itself_at_the_branch() {
    let app = seeded_with(Floor::Bathroom, |run| {
        run.turn = 8;
        run.warmed_up = true;
        run.items.baby_oil = 9;
    });
    send(
        &app,
        "JELQ",
        "/runs/cafebabe?technique=wet",
        &[("content-type", "application/baby-oil")],
        "",
    )
    .await;
    let ninth = send(&app, "GET", "/runs/cafebabe", &[], "").await;
    assert!(!header(&ninth, "link").contains("/forum/threads/2009"));
    let tenth = send(
        &app,
        "JELQ",
        "/runs/cafebabe?technique=wet",
        &[("content-type", "application/baby-oil")],
        "",
    )
    .await;
    assert!(
        tenth
            .headers()
            .get_all("warning")
            .iter()
            .any(|w| w.to_str().unwrap().contains("a forum thread from 2009"))
    );
    assert!(header(&tenth, "link").contains("/forum/threads/2009"));
    let announced = send(&app, "GET", "/runs/cafebabe", &[], "").await;
    assert!(header(&announced, "link").contains("/forum/threads/2009"));
}

#[tokio::test]
async fn rereading_the_thread_teaches_uli() {
    let mut taught_runs = 0;
    let mut ruptured = 0;
    for seed in 0..100u64 {
        let app = app_with(Floor::Bedroom, seed, |run| {
            run.turn = BRANCH_TURN;
            run.warmed_up = true;
            run.story = Story::ClosedTab;
        });
        let mut taught = false;
        for _ in 0..40 {
            let read = send(&app, "POST", "/runs/cafebabe/re-read", &[], "").await;
            match read.status() {
                StatusCode::NOT_MODIFIED => {
                    assert!(header(&read, "warning").contains("2009"));
                }
                StatusCode::MULTIPLE_CHOICES => {
                    send(&app, "POST", "/runs/cafebabe/branches/close-tab", &[], "").await;
                }
                StatusCode::OK => {
                    assert!(header(&read, "location").contains("/techniques"));
                    taught = true;
                    break;
                }
                StatusCode::INTERNAL_SERVER_ERROR => break,
                other => panic!("seed {seed} read the thread into {other}"),
            }
        }
        if taught {
            taught_runs += 1;
            let jelq = send(&app, "JELQ", "/runs/cafebabe?technique=uli", &[], "").await;
            assert_ne!(jelq.status(), StatusCode::FORBIDDEN);
        }
        ruptured += u32::from(!taught);
    }
    assert!(
        taught_runs >= 85,
        "{taught_runs}/100 learned uli, {ruptured} ruptured first"
    );
}

#[tokio::test]
async fn meditation_is_free_but_only_once_per_floor() {
    let app = seeded_with(Floor::Bedroom, |_| {});
    let response = send(&app, "JELQ", "/runs/cafebabe?technique=meditate", &[], "").await;
    assert_eq!(response.status(), StatusCode::OK);
    assert_eq!(header(&response, "x-eq"), "10");
    assert_eq!(header(&response, "x-stamina"), "10/10");
    let again = send(&app, "JELQ", "/runs/cafebabe?technique=meditate", &[], "").await;
    assert_eq!(again.status(), StatusCode::CONFLICT);
}

#[tokio::test]
async fn meditation_is_listed_from_the_start() {
    let app = seeded_with(Floor::Bedroom, |_| {});
    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
    assert!(header(&view, "link").contains("technique=meditate"));
    let jelq = send(&app, "JELQ", "/runs/cafebabe?technique=meditate", &[], "").await;
    assert_eq!(jelq.status(), StatusCode::OK);
}

fn app_with(floor: Floor, seed: u64, setup: impl FnOnce(&mut Run)) -> Router {
    let state = Arc::new(AppState::default());
    let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
    run.floor = floor;
    setup(&mut run);
    state.insert(run);
    router(state)
}

#[tokio::test]
async fn hold_is_offered_only_at_the_edges() {
    let calm = seeded_with(Floor::Bedroom, |_| {});
    let refused = send(&calm, "HOLD", "/runs/cafebabe", &[], "").await;
    assert_eq!(refused.status(), StatusCode::METHOD_NOT_ALLOWED);
    assert!(!header(&refused, "allow").contains("HOLD"));
    let view = send(&calm, "GET", "/runs/cafebabe", &[], "").await;
    assert!(!header(&view, "link").contains("HOLD"));
    let options = send(&calm, "OPTIONS", "/runs/cafebabe", &[], "").await;
    assert!(!header(&options, "allow").contains("HOLD"));

    let winded = seeded_with(Floor::Bedroom, |run| run.stamina = 2);
    let listed = send(&winded, "GET", "/runs/cafebabe", &[], "").await;
    assert!(header(&listed, "link").contains("HOLD"));
    let options = send(&winded, "OPTIONS", "/runs/cafebabe", &[], "").await;
    assert!(header(&options, "allow").contains("HOLD"));

    let hot = seeded_with(Floor::Bedroom, |run| {
        run.eq = 75;
        run.warmed_up = true;
    });
    let held = send(&hot, "HOLD", "/runs/cafebabe", &[], "").await;
    assert_eq!(held.status(), StatusCode::NO_CONTENT);
    assert_eq!(header(&held, "x-stamina"), "10/10");
}

#[tokio::test]
async fn holding_calms_and_sometimes_reflects() {
    let mut calmed = 0;
    let mut reflected = 0;
    let mut ruptured = 0;
    for seed in 0..120u64 {
        let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
        run.eq = 75;
        match run.hold(Instant::now()) {
            Ok(_) if run.eq == 0 => reflected += 1,
            Ok(_) => calmed += 1,
            Err(_) => ruptured += 1,
        }
    }
    assert!(
        calmed > 100 && reflected > 0,
        "one HOLD in twelve should reflect, got {calmed} calm and {reflected} reflective of 120"
    );
    assert!(
        calmed + reflected + ruptured == 120 && ruptured <= 4,
        "the flat 1 in 250 ruptured {ruptured} of 120 holds"
    );
}

#[tokio::test]
async fn leaving_the_band_warms_the_next_floor() {
    let app = seeded_with(Floor::Bedroom, |run| {
        run.eq = 60;
        run.warmed_up = true;
        run.here.turns = 6;
        run.items.baby_oil = 9;
    });
    let left = send(&app, "POST", "/runs/cafebabe/floor", &[], "").await;
    assert_eq!(left.status(), StatusCode::SEE_OTHER);
    let detail = json(left).await["detail"].as_str().unwrap().to_owned();
    assert!(detail.contains("the warmth came with you"));

    let lube = [("content-type", "application/baby-oil")];
    send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
    // The shower is a +35 warm-up, so EQ lands in the band and the band bonus rides along.
    // The arrival bonus is the one point the second jelq loses.
    let first = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;
    assert!(
        header(&first, "server-timing").contains("d20+4"),
        "the first jelq of a warm arrival rolls with +1, got {}",
        header(&first, "server-timing")
    );
    let second = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;
    assert!(header(&second, "server-timing").contains("d20+3"));
}

#[tokio::test]
async fn greed_multiplies_gains_above_the_band() {
    let lube = [("content-type", "application/baby-oil")];
    for seed in 0..60u64 {
        let app = app_with(Floor::Bedroom, seed, |run| {
            run.eq = 60;
            run.warmed_up = true;
        });
        let in_band = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;
        let app = app_with(Floor::Bedroom, seed, |run| {
            run.eq = 75;
            run.warmed_up = true;
        });
        let greedy = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;
        if in_band.status() != StatusCode::OK || greedy.status() != StatusCode::OK {
            continue;
        }
        let steady = json(in_band).await["length"].as_f64().unwrap();
        let eager = json(greedy).await["length"].as_f64().unwrap();
        assert!(
            (eager - steady * 1.5).abs() < 1e-9,
            "seed {seed} gained {eager} above the band against {steady} inside it"
        );
        return;
    }
    panic!("no seed in 60 produced two clean rolls to compare");
}

#[tokio::test]
async fn the_kitchen_is_only_on_the_home_floors() {
    let absent = seeded_with(Floor::Bathroom, |_| {});
    let no_kitchen = send(&absent, "POST", "/runs/cafebabe/kitchen", &[], "").await;
    assert_eq!(no_kitchen.status(), StatusCode::NOT_FOUND);
    let view = send(&absent, "GET", "/runs/cafebabe", &[], "").await;
    assert!(!header(&view, "link").contains("/kitchen"));

    let app = seeded_with(Floor::Bedroom, |_| {});
    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
    assert!(header(&view, "link").contains("/kitchen"));
    let raid = send(&app, "POST", "/runs/cafebabe/kitchen", &[], "").await;
    assert_ne!(raid.status(), StatusCode::NOT_FOUND);
}

#[tokio::test]
async fn raids_cost_the_turn_and_the_fridge_pays_out_sometimes() {
    let mut bounties = std::collections::BTreeSet::new();
    let mut told = 0;
    for seed in 0..80u64 {
        let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
        let Ok(outcome) = run.raid_kitchen() else {
            panic!("the first raid should never fail");
        };
        assert_eq!(run.turn, 1, "a raid costs the floor turn");
        assert!(!run.here.melon_offered, "no melon at starting EQ");
        if outcome.status == StatusCode::NO_CONTENT {
            bounties.insert("empty");
        } else {
            bounties.insert("loot");
        }
        told += u32::from(run.kitchen_tellings);
    }
    assert!(bounties.contains("loot") && bounties.contains("empty"));
    assert!(
        (0..80).any(|seed| {
            let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
            run.raid_kitchen().is_ok() && run.kitchen_tellings == 0
        }),
        "most raids go unremarked"
    );
    assert!(told > 0, "someone should have been told across 80 raids");
}

#[tokio::test]
async fn the_watermelon_offers_itself_above_ninety() {
    let mut offered = 0;
    let mut caught = 0;
    let mut survived = 0;
    for seed in 0..120u64 {
        let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
        run.eq = 95;
        let Ok(outcome) = run.raid_kitchen() else {
            continue;
        };
        if outcome.status != StatusCode::MULTIPLE_CHOICES {
            continue;
        }
        offered += 1;
        let gains = run.length;
        let disgrace = run.shame;
        if run.commit_melon().is_err() {
            caught += 1;
            assert_eq!(run.ended.as_ref().unwrap().cause.slug(), "watermelon");
        } else {
            survived += 1;
            assert_eq!(run.eq, 0);
            assert_eq!(run.shame, disgrace + 5);
            assert_eq!(run.length, gains, "the gains are kept");
        }
    }
    assert!(
        offered > 20,
        "the melon should appear in two fifths of raids"
    );
    assert!(caught > 0 && survived > 0, "caught is one in three");
}

#[tokio::test]
async fn a_melon_offer_does_not_survive_a_non_kitchen_turn() {
    for seed in 0..60u64 {
        let jelq_app = app_with(Floor::Bedroom, seed, |run| {
            run.warmed_up = true;
            run.here.melon_offered = true;
        });
        let stroked = send(
            &jelq_app,
            "JELQ",
            "/runs/cafebabe?technique=wet&intensity=2",
            &[],
            "",
        )
        .await;
        if stroked.status() != StatusCode::OK && stroked.status() != StatusCode::PARTIAL_CONTENT {
            continue;
        }
        let bite = send(
            &jelq_app,
            "POST",
            "/runs/cafebabe/kitchen/watermelon",
            &[],
            "",
        )
        .await;
        assert_eq!(
            bite.status(),
            StatusCode::CONFLICT,
            "seed {seed} kept the melon through a jelq"
        );

        let hold_app = app_with(Floor::Bedroom, seed, |run| {
            run.stamina = 2;
            run.here.melon_offered = true;
        });
        let held = send(&hold_app, "HOLD", "/runs/cafebabe", &[], "").await;
        if held.status() != StatusCode::NO_CONTENT {
            continue;
        }
        let bite = send(
            &hold_app,
            "POST",
            "/runs/cafebabe/kitchen/watermelon",
            &[],
            "",
        )
        .await;
        assert_eq!(
            bite.status(),
            StatusCode::CONFLICT,
            "seed {seed} kept the melon through a hold"
        );

        let read_app = app_with(Floor::Bedroom, seed, |run| {
            run.story = Story::ClosedTab;
            run.here.melon_offered = true;
        });
        let read = send(&read_app, "POST", "/runs/cafebabe/re-read", &[], "").await;
        if read.status() == StatusCode::INTERNAL_SERVER_ERROR {
            continue;
        }
        let bite = send(
            &read_app,
            "POST",
            "/runs/cafebabe/kitchen/watermelon",
            &[],
            "",
        )
        .await;
        assert_eq!(
            bite.status(),
            StatusCode::CONFLICT,
            "seed {seed} kept the melon through a re-read"
        );
    }

    let mut stood = 0;
    for seed in 0..60u64 {
        let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
        run.eq = 95;
        run.here.melon_offered = true;
        if run.raid_kitchen().is_err() {
            continue;
        }
        stood += 1;
        assert!(
            run.here.melon_offered,
            "seed {seed} lost the melon to another raid"
        );
    }
    assert!(stood > 40, "raids at eq 95 rarely rupture");
}

#[tokio::test]
async fn the_kitchen_closes_after_two_tellings() {
    let mut closed = None;
    for seed in 0..300u64 {
        let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
        let first = run.raid_kitchen();
        let second = run.raid_kitchen();
        if second.is_err() && first.is_ok() {
            assert_eq!(run.kitchen_tellings, 2);
            let Err(third) = run.raid_kitchen() else {
                panic!("the kitchen should be gone");
            };
            assert_eq!(third.status(), StatusCode::GONE);
            closed = Some(seed);
            break;
        }
    }
    assert!(
        closed.is_some(),
        "two tellings should occur within 300 seeds"
    );
}

#[tokio::test]
async fn lubes_run_out_but_spit_never_does() {
    let app = seeded_with(Floor::Bedroom, |run| {
        run.warmed_up = true;
        run.items.baby_oil = 1;
    });
    let lube = [("content-type", "application/baby-oil")];
    let first = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;
    assert_ne!(first.status(), StatusCode::PRECONDITION_FAILED);
    let second = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;
    assert_eq!(second.status(), StatusCode::UNSUPPORTED_MEDIA_TYPE);

    let spit = [("content-type", "text/plain; charset=spit")];
    for _ in 0..3 {
        let wet = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &spit, "").await;
        assert_ne!(wet.status(), StatusCode::PRECONDITION_FAILED);
    }
}

#[tokio::test]
async fn energy_drinks_add_three_stamina() {
    let app = seeded_with(Floor::Bedroom, |run| {
        run.stamina = 2;
        run.items.energy_drinks = 1;
    });
    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
    assert!(header(&view, "link").contains("technique=energy"));
    let drink = send(&app, "JELQ", "/runs/cafebabe?technique=energy", &[], "").await;
    assert_eq!(drink.status(), StatusCode::OK);
    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
    assert_eq!(header(&view, "x-stamina"), "5/10");
    let again = send(&app, "JELQ", "/runs/cafebabe?technique=energy", &[], "").await;
    assert_eq!(again.status(), StatusCode::FAILED_DEPENDENCY);
}

#[tokio::test]
async fn the_working_supplement_resets_stamina() {
    let mut worked = 0;
    let mut bunk = 0;
    for seed in 0..60u64 {
        let app = app_with(Floor::Bedroom, seed, |run| {
            run.stamina = 1;
            run.items.supplements = 1;
        });
        let taken = send(&app, "JELQ", "/runs/cafebabe?technique=supplement", &[], "").await;
        if taken.status() == StatusCode::OK {
            worked += 1;
            let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
            assert_eq!(header(&view, "x-stamina"), "10/10");
        } else {
            assert_eq!(taken.status(), StatusCode::BAD_GATEWAY);
            bunk += 1;
        }
    }
    assert!(worked > 0 && bunk > 0, "one in five should work too well");
}

#[tokio::test]
async fn dry_jelqs_build_friction_and_real_lube_does_not() {
    let app = seeded_with(Floor::Bedroom, |run| {
        run.warmed_up = true;
    });
    let dry = send(&app, "JELQ", "/runs/cafebabe?technique=dry", &[], "").await;
    assert_eq!(header(&dry, "x-friction"), "2/10");
    let lube = [("content-type", "application/baby-oil")];
    let wet = send(
        &app,
        "JELQ",
        "/runs/cafebabe?technique=wet&intensity=5",
        &lube,
        "",
    )
    .await;
    assert_eq!(header(&wet, "x-friction"), "2/10");
    let spit = [("content-type", "text/plain; charset=spit")];
    let glisten = send(
        &app,
        "JELQ",
        "/runs/cafebabe?technique=wet&intensity=5",
        &spit,
        "",
    )
    .await;
    assert_eq!(header(&glisten, "x-friction"), "3/10");
}

#[tokio::test]
async fn switching_grips_makes_the_friction_cheaper() {
    let app = seeded_with(Floor::Bedroom, |run| {
        run.warmed_up = true;
    });
    let dry = send(&app, "JELQ", "/runs/cafebabe?technique=dry", &[], "").await;
    assert_eq!(header(&dry, "x-friction"), "2/10");
    send(
        &app,
        "GET",
        "/runs/cafebabe/grip",
        &[("upgrade", "underhand"), ("connection", "upgrade")],
        "",
    )
    .await;
    let switched = send(&app, "JELQ", "/runs/cafebabe?technique=dry", &[], "").await;
    assert_eq!(header(&switched, "x-friction"), "3/10");
    let settled = send(&app, "JELQ", "/runs/cafebabe?technique=dry", &[], "").await;
    assert_eq!(header(&settled, "x-friction"), "5/10");
}

#[tokio::test]
async fn holding_and_meditating_shed_friction() {
    let app = seeded_with(Floor::Bedroom, |run| {
        run.eq = 80;
        run.friction = 5;
    });
    let held = send(&app, "HOLD", "/runs/cafebabe", &[], "").await;
    assert_eq!(held.status(), StatusCode::NO_CONTENT);
    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
    assert_eq!(header(&view, "x-friction"), "3/10");

    let taught = seeded_with(Floor::Bedroom, |run| {
        run.friction = 5;
    });
    let calmed = send(
        &taught,
        "JELQ",
        "/runs/cafebabe?technique=meditate",
        &[],
        "",
    )
    .await;
    assert_eq!(calmed.status(), StatusCode::OK);
    let view = send(&taught, "GET", "/runs/cafebabe", &[], "").await;
    assert_eq!(header(&view, "x-friction"), "3/10");
}

#[tokio::test]
async fn a_friction_burn_halves_the_gains() {
    let lube = [("content-type", "application/baby-oil")];
    let path = "/runs/cafebabe?technique=wet&intensity=5";
    for seed in 0..60u64 {
        let steady = app_with(Floor::Bedroom, seed, |run| {
            run.warmed_up = true;
            run.eq = 60;
            run.items.baby_oil = 9;
        });
        let hurt_app = app_with(Floor::Bedroom, seed, |run| {
            run.warmed_up = true;
            run.eq = 60;
            run.items.baby_oil = 9;
            run.conditions.friction_burn = true;
        });
        let calm = send(&steady, "JELQ", path, &lube, "").await;
        let hurt = send(&hurt_app, "JELQ", path, &lube, "").await;
        if calm.status() != StatusCode::OK || hurt.status() != StatusCode::OK {
            continue;
        }
        let calm_gain = json(calm).await["length"].as_f64().unwrap();
        let hurt_gain = json(hurt).await["length"].as_f64().unwrap();
        assert!(
            (hurt_gain * 2.0 - calm_gain).abs() < 1e-9,
            "seed {seed} burned {hurt_gain} against {calm_gain}"
        );
        return;
    }
    panic!("no seed in 60 produced two clean rolls to compare");
}

#[tokio::test]
async fn the_burn_warns_and_the_ice_treats_it() {
    let app = seeded_with(Floor::Bedroom, |run| {
        run.warmed_up = true;
        run.eq = 60;
        run.items.baby_oil = 9;
        run.friction = 7;
        run.conditions.friction_burn = true;
    });
    let lube = [("content-type", "application/baby-oil")];
    let jelq = send(
        &app,
        "JELQ",
        "/runs/cafebabe?technique=wet&intensity=5",
        &lube,
        "",
    )
    .await;
    let warnings: Vec<_> = jelq
        .headers()
        .get_all("warning")
        .iter()
        .filter_map(|w| w.to_str().ok())
        .collect();
    assert!(warnings.contains(&"199 - \"friction burn\""));
    send(&app, "JELQ", "/runs/cafebabe?technique=ice", &[], "").await;
    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
    let warnings: Vec<_> = view
        .headers()
        .get_all("warning")
        .iter()
        .filter_map(|w| w.to_str().ok())
        .collect();
    assert!(!warnings.contains(&"199 - \"friction burn\""));
}

#[tokio::test]
async fn the_burn_shifts_the_rupture_tiers() {
    async fn ruptures(burned: bool) -> u32 {
        let mut gone = 0;
        for seed in 0..400u64 {
            let app = app_with(Floor::Bedroom, seed, |run| {
                run.warmed_up = true;
                run.eq = 60;
                run.items.baby_oil = 9;
                run.conditions.friction_burn = burned;
            });
            let lube = [("content-type", "application/baby-oil")];
            let jelq = send(
                &app,
                "JELQ",
                "/runs/cafebabe?technique=wet&intensity=5",
                &lube,
                "",
            )
            .await;
            if jelq.status() == StatusCode::INTERNAL_SERVER_ERROR {
                gone += 1;
            }
        }
        gone
    }
    let burned = ruptures(true).await;
    let calm = ruptures(false).await;
    assert!(
        burned >= 8 && calm <= 4,
        "burned {burned} ruptures against {calm}"
    );
}

#[tokio::test]
async fn meditation_respects_the_priapism_floor() {
    let app = seeded_with(Floor::Bedroom, |run| {
        run.eq = 80;
        run.conditions.priapism_turns = 3;
    });
    let calmed = send(&app, "JELQ", "/runs/cafebabe?technique=meditate", &[], "").await;
    assert_eq!(calmed.status(), StatusCode::OK);
    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
    assert_eq!(header(&view, "x-eq"), "75");
}

#[tokio::test]
async fn the_kitchen_pays_out_at_the_documented_odds() {
    let mut oil = 0;
    let mut drinks = 0;
    let mut packs = 0;
    for seed in 0..600u64 {
        let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
        run.kitchen_tellings = 0;
        let held = (
            run.items.coconut_oil,
            run.items.energy_drinks,
            run.items.ice_packs,
        );
        let _ = run.raid_kitchen();
        oil += u32::from(run.items.coconut_oil > held.0);
        drinks += u32::from(run.items.energy_drinks > held.1);
        packs += u32::from(run.items.ice_packs > held.2);
    }
    assert!((170..=230).contains(&oil), "coconut {oil} in 600");
    assert!((90..=150).contains(&drinks), "energy {drinks} in 600");
    assert!((45..=105).contains(&packs), "ice {packs} in 600");
}

#[tokio::test]
async fn a_refused_jelq_leaves_the_lube_alone() {
    let app = seeded_with(Floor::Bedroom, |run| {
        run.warmed_up = true;
        run.items.extender = true;
        run.girth = STORAGE_GIRTH + 1.0;
    });
    let lube = [("content-type", "application/baby-oil")];
    let full = send(
        &app,
        "JELQ",
        "/runs/cafebabe?technique=wet&intensity=5",
        &lube,
        "",
    )
    .await;
    assert_eq!(full.status(), StatusCode::INSUFFICIENT_STORAGE);
    let inv = send(&app, "GET", "/runs/cafebabe/inventory", &[], "").await;
    let body = json(inv).await;
    let held = body["items"].as_array().unwrap();
    assert!(held.iter().any(|i| i["name"] == "baby-oil"));
}

#[tokio::test]
async fn an_empty_bottle_is_declined_before_the_enemy_stirs() {
    let control = seeded_with(Floor::ChangingRoom, |run| {
        run.warmed_up = true;
        run.suspicion = SUSPICION_LIMIT;
    });
    let lube = [("content-type", "application/baby-oil")];
    let caught = send(
        &control,
        "JELQ",
        "/runs/cafebabe?technique=wet&intensity=5",
        &lube,
        "",
    )
    .await;
    assert_eq!(caught.status(), StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS);

    let app = seeded_with(Floor::ChangingRoom, |run| {
        run.warmed_up = true;
        run.suspicion = SUSPICION_LIMIT;
        run.items.baby_oil = 0;
    });
    let refused = send(
        &app,
        "JELQ",
        "/runs/cafebabe?technique=wet&intensity=5",
        &lube,
        "",
    )
    .await;
    assert_eq!(refused.status(), StatusCode::UNSUPPORTED_MEDIA_TYPE);
    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
    assert_eq!(header(&view, "x-suspicion"), "5/5");
    assert_eq!(header(&view, "x-shame"), "0");
}

#[tokio::test]
async fn the_top_tier_rolls_a_single_third() {
    let mut ruptures = 0;
    let mut early = 0;
    for seed in 0..400u64 {
        let app = app_with(Floor::Bedroom, seed, |run| {
            run.warmed_up = true;
            run.eq = 96;
            run.items.baby_oil = 9;
            run.items.blinds = true;
        });
        let lube = [("content-type", "application/baby-oil")];
        let jelq = send(
            &app,
            "JELQ",
            "/runs/cafebabe?technique=wet&intensity=5",
            &lube,
            "",
        )
        .await;
        match jelq.status() {
            StatusCode::INTERNAL_SERVER_ERROR => ruptures += 1,
            StatusCode::TOO_EARLY => early += 1,
            other => panic!("seed {seed} ended in {other}"),
        }
    }
    assert!(
        (90..=175).contains(&ruptures),
        "ruptures {ruptures} of 400 against {early} early"
    );
    assert!(
        (225..=310).contains(&early),
        "early {early} of 400 against {ruptures} ruptures"
    );
}

#[tokio::test]
async fn priapism_holds_the_floor_through_every_reset() {
    let exit = seeded_with(Floor::Bedroom, |run| {
        run.warmed_up = true;
        run.eq = 90;
        run.here.turns = 99;
        run.conditions.priapism_turns = 3;
    });
    let out = send(&exit, "POST", "/runs/cafebabe/floor", &[], "").await;
    assert_eq!(out.status(), StatusCode::SEE_OTHER);
    let view = send(&exit, "GET", "/runs/cafebabe", &[], "").await;
    assert_eq!(header(&view, "x-eq"), "75");

    let melon = seeded_with(Floor::Bedroom, |run| {
        run.eq = 95;
        run.here.melon_offered = true;
        run.conditions.priapism_turns = 2;
    });
    let bite = send(&melon, "POST", "/runs/cafebabe/kitchen/watermelon", &[], "").await;
    assert_eq!(bite.status(), StatusCode::OK);
    let view = send(&melon, "GET", "/runs/cafebabe", &[], "").await;
    assert_eq!(header(&view, "x-eq"), "75");
}

#[tokio::test]
async fn holding_rolls_a_flat_rupture_chance() {
    async fn ruptures(eq: i32, stamina: i32) -> u32 {
        let mut gone = 0;
        for seed in 0..600u64 {
            let app = app_with(Floor::Bedroom, seed, |run| {
                run.warmed_up = true;
                run.eq = eq;
                run.stamina = stamina;
            });
            let held = send(&app, "HOLD", "/runs/cafebabe", &[], "").await;
            if held.status() == StatusCode::INTERNAL_SERVER_ERROR {
                gone += 1;
            }
        }
        gone
    }
    let high = ruptures(90, 10).await;
    let low = ruptures(30, 2).await;
    assert!((0..=9).contains(&high), "high holds ruptured {high}/600");
    assert!((0..=9).contains(&low), "low holds ruptured {low}/600");
}

#[tokio::test]
async fn the_kitchen_rolls_the_normal_tiers() {
    async fn ruptures(eq: i32) -> u32 {
        let mut gone = 0;
        for seed in 0..600u64 {
            let app = app_with(Floor::Bedroom, seed, |run| run.eq = eq);
            let raid = send(&app, "POST", "/runs/cafebabe/kitchen", &[], "").await;
            if raid.status() == StatusCode::INTERNAL_SERVER_ERROR {
                gone += 1;
            }
        }
        gone
    }
    let hot = ruptures(96).await;
    let cool = ruptures(40).await;
    assert!((40..=80).contains(&hot), "hot kitchen ruptured {hot}/600");
    assert!((0..=9).contains(&cool), "cool kitchen ruptured {cool}/600");
}

#[tokio::test]
async fn the_thread_cannot_be_reread_before_anyone_mentions_it() {
    let app = seeded_with(Floor::Bedroom, |run| run.warmed_up = true);
    let read = send(&app, "POST", "/runs/cafebabe/re-read", &[], "").await;
    assert_eq!(read.status(), StatusCode::NOT_FOUND);
    let after = send(&app, "GET", "/runs/cafebabe", &[], "").await;
    assert_eq!(header(&after, "x-floor"), "1");
    assert!(!header(&after, "link").contains("/re-read"));
}

#[tokio::test]
async fn any_other_action_takes_the_melon_off_the_table() {
    for (method, uri) in [
        ("JELQ", "/runs/cafebabe?technique=warmup"),
        ("POST", "/runs/cafebabe/drawer"),
    ] {
        let app = seeded_with(Floor::Bedroom, |run| {
            run.eq = 95;
            run.here.melon_offered = true;
        });
        send(&app, method, uri, &[], "").await;
        let melon = send(&app, "POST", "/runs/cafebabe/kitchen/watermelon", &[], "").await;
        assert_eq!(melon.status(), StatusCode::CONFLICT, "{method} {uri}");
    }
}

#[tokio::test]
async fn a_refused_jelq_does_not_break_the_edging_streak() {
    let app = seeded_with(Floor::ChangingRoom, |run| {
        run.warmed_up = true;
        run.eq = 45;
        run.here.edges = 2;
    });
    let refused = send(
        &app,
        "JELQ",
        "/runs/cafebabe?technique=dry",
        &[("content-type", "application/baby-oil")],
        "",
    )
    .await;
    assert_eq!(refused.status(), StatusCode::UNSUPPORTED_MEDIA_TYPE);
    let third = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
    assert_eq!(third.status(), StatusCode::LOOP_DETECTED);
}

#[tokio::test]
async fn an_interrupted_edge_keeps_no_gains() {
    let app = seeded_with(Floor::ChangingRoom, |run| {
        run.warmed_up = true;
        run.eq = 10;
    });
    let before = send(&app, "GET", "/runs/cafebabe", &[], "").await;
    let girth = header(&before, "x-girth").to_owned();
    let edge = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
    assert_eq!(edge.status(), StatusCode::NOT_FOUND);
    assert_eq!(header(&edge, "x-girth"), girth);
}

#[tokio::test]
async fn rummaging_for_the_key_leaves_the_drawer_unsearched() {
    let mut found = 0;
    for seed in 0..20u64 {
        let app = app_with(Floor::Hotel, seed, |run| {
            run.here.wifi_accepted = true;
            run.items.cage = true;
        });
        for _ in 0..30 {
            let rummage = send(&app, "POST", "/runs/cafebabe/drawer", &[], "").await;
            if rummage.status() == StatusCode::OK {
                break;
            }
        }
        let search = send(&app, "POST", "/runs/cafebabe/drawer", &[], "").await;
        if search.status() == StatusCode::FOUND {
            assert!(header(&search, "location").ends_with("/inventory/do-not-disturb-sign"));
            found += 1;
        }
    }
    assert!(
        found >= 18,
        "only {found} of 20 hotel drawers survived the rummage"
    );
}

#[tokio::test]
async fn a_full_server_buries_the_dead_to_make_room() {
    let app = crate::app(Config {
        max_runs: 1,
        ..Config::default()
    });
    let first = send(&app, "POST", "/runs", &[], "").await;
    let location = header(&first, "location").to_owned();
    let full = send(&app, "POST", "/runs", &[], "").await;
    assert_eq!(full.status(), StatusCode::SERVICE_UNAVAILABLE);
    send(&app, "DELETE", &location, &[], "").await;
    let second = send(&app, "POST", "/runs", &[], "").await;
    assert_eq!(second.status(), StatusCode::CREATED);
}