jelq

use std::sync::Arc;

use axum::{

    Router,

    body::{Body, to_bytes},

    http::{Method, Request, StatusCode, header},

    response::Response,

};

use jelqd::{

    AppState,

    game::{Floor, Run},

    router,

};

use serde_json::Value;

use tower::ServiceExt;

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

}

fn seeded(floor: Floor) -> (Router, String) {

    let state = Arc::new(AppState::default());

    let mut run = Run::new("cafebabe".into(), 69, 0);

    run.floor = floor;

    let etag = run.origin_etag.clone();

    state.insert(run);

    (router(state), etag)

}

#[tokio::test]

async fn creating_a_run_returns_location_and_etag() {

    let app = jelqd::app();

    let response = send(&app, "POST", "/runs?seed=1", &[], "").await;

    assert_eq!(response.status(), StatusCode::CREATED);

    assert!(response.headers().contains_key(header::LOCATION));

    assert!(response.headers().contains_key(header::ETAG));

    assert_eq!(response.headers()[header::SERVER], "jelqd/0.6.9");

}

#[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!(

        response.headers()[header::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);

}

#[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 etag = send(&app, "GET", "/runs/cafebabe/foreskin", &[], "")

        .await

        .headers()[header::ETAG]

        .to_str()

        .unwrap()

        .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 found = send(&app, "POST", "/runs/cafebabe/drawer", &[], "").await;

    assert_eq!(found.status(), StatusCode::FOUND);

    let truth = send(&app, "GET", "/runs/cafebabe/length", &[], "").await;

    let declared: usize = truth.headers()[header::CONTENT_LENGTH]

        .to_str()

        .unwrap()

        .parse()

        .unwrap();

    let body = to_bytes(truth.into_body(), usize::MAX).await.unwrap();

    assert_eq!(body.len(), declared);

    assert!(body.starts_with(b"8=") && body.ends_with(b"D"));

}

#[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(

            response.headers()[header::WWW_AUTHENTICATE]

                .to_str()

                .unwrap()

                .to_owned(),

        );

    }

    assert!(hints[2].contains("Be honest."));

}

#[tokio::test]

async fn the_true_ending_is_not_modified() {

    let (app, etag) = seeded(Floor::Clinic);

    let early = seeded(Floor::Bedroom).0;

    let response = send(&early, "GET", "/runs/cafebabe/diagnosis", &[], "").await;

    assert_eq!(response.status(), StatusCode::TOO_EARLY);

    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!(response.headers()["x-diagnosis"], "normal");

}

#[tokio::test]

async fn mom_accepts_a_known_excuse() {

    let state = Arc::new(AppState::default());

    let mut run = Run::new("cafebabe".into(), 69, 0);

    run.mom_present = true;

    state.insert(run);

    let app = router(state);

    let response = send(&app, "GET", "/runs/cafebabe", &[], "").await;

    assert_eq!(response.status(), StatusCode::UNAUTHORIZED);

    assert_eq!(response.headers()["via"], "1.1 mom");

    let response = send(

        &app,

        "GET",

        "/runs/cafebabe",

        &[("authorization", "Excuse \"homework\"")],

        "",

    )

    .await;

    assert_eq!(response.status(), StatusCode::OK);

}

fn seeded_with(floor: Floor, setup: impl FnOnce(&mut Run)) -> Router {

    let state = Arc::new(AppState::default());

    let mut run = Run::new("cafebabe".into(), 69, 0);

    run.floor = floor;

    setup(&mut run);

    state.insert(run);

    router(state)

}

#[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.floor_turns = 6);

    let next = send(&app, "POST", "/runs/cafebabe/floor", &[], "").await;

    assert_eq!(next.status(), StatusCode::SEE_OTHER);

    assert_eq!(next.headers()["x-floor"], "2");

}

#[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::LockerRoom, |_| {});

    let pump = send(&app, "POST", "/runs/cafebabe/shop/pump", &[], "").await;

    assert_eq!(pump.status(), StatusCode::UPGRADE_REQUIRED);

    assert_eq!(pump.headers()[header::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 combos_are_multi_status_xml() {

    let app = seeded_with(Floor::Bedroom, |run| run.foreskin = Some(1.0));

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

    let body = to_bytes(response.into_body(), usize::MAX).await.unwrap();

    assert!(String::from_utf8_lossy(&body).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);

    let exit = send(&app, "POST", "/runs/cafebabe/floor", &[], "").await;

    assert_eq!(exit.status(), StatusCode::SEE_OTHER);

}

#[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 mom_remembers_excuses_by_thanksgiving() {

    let app = seeded_with(Floor::Grandmas, |run| {

        run.mom_present = true;

        run.nonce = "abc".into();

        run.heard.push("homework".into());

    });

    let basic = send(

        &app,

        "GET",

        "/runs/cafebabe",

        &[("authorization", "Excuse \"changing\"")],

        "",

    )

    .await;

    assert_eq!(basic.status(), StatusCode::UNAUTHORIZED);

    assert!(

        basic.headers()[header::WWW_AUTHENTICATE]

            .to_str()

            .unwrap()

            .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=\"praying\", nonce=\"abc\"",

        )],

        "",

    )

    .await;

    assert_eq!(fresh.status(), StatusCode::OK);

}

#[tokio::test]

async fn length_supports_inch_ranges() {

    let app = seeded_with(Floor::Bedroom, |_| {});

    let response = send(

        &app,

        "GET",

        "/runs/cafebabe/length",

        &[("range", "inches=0-1")],

        "",

    )

    .await;

    assert_eq!(response.status(), StatusCode::PARTIAL_CONTENT);

    assert!(

        response.headers()[header::CONTENT_RANGE]

            .to_str()

            .unwrap()

            .starts_with("inches 0.00-1.00/")

    );

    let body = to_bytes(response.into_body(), usize::MAX).await.unwrap();

    assert_eq!(body.len(), 25);

    let absurd = send(

        &app,

        "GET",

        "/runs/cafebabe/length",

        &[("range", "inches=40-50")],

        "",

    )

    .await;

    assert_eq!(absurd.status(), StatusCode::RANGE_NOT_SATISFIABLE);

}

#[tokio::test]

async fn http_1_0_gets_the_pdf_treatment() {

    let request = Request::builder()

        .uri("/graveyard")

        .version(axum::http::Version::HTTP_10)

        .body(Body::empty())

        .unwrap();

    let response = jelqd::app().oneshot(request).await.unwrap();

    assert_eq!(response.status(), StatusCode::HTTP_VERSION_NOT_SUPPORTED);

}

#[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 mom_runs_out_of_patience() {

    let app = seeded_with(Floor::Bedroom, |run| run.mom_present = true);

    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 forged_ruler_cookies_are_lies() {

    let app = jelqd::app();

    let forged = send(

        &app,

        "GET",

        "/leaderboard?sort=content-length",

        &[("cookie", "ruler=1")],

        "",

    )

    .await;

    assert_eq!(forged.status(), StatusCode::BAD_REQUEST);

}

#[tokio::test]

async fn seeded_runs_are_unranked() {

    let app = jelqd::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 the_root_negotiates() {

    let app = jelqd::app();

    let browser = send(&app, "GET", "/", &[("accept", "text/html,*/*")], "").await;

    assert_eq!(browser.status(), StatusCode::SEE_OTHER);

    assert_eq!(browser.headers()[header::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 = jelqd::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");

}