jelq

use std::{sync::Arc, time::Duration};

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::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::NO_CONTENT);

    let etag = header(&look, "etag").to_owned();

    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"]);

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