jelq

use std::sync::Arc;

use axum::{

    Router,

    body::{Body, to_bytes},

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

    response::Response,

};

use jelqd::{AppState, game::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(turn: u32) -> (Router, String) {

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

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

    run.turn = turn;

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

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

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

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

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

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

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

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

    let early = seeded(3).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);

}