jelq

use super::*;

#[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 Harness { app, .. } = harness(Floor::Bedroom, SEED, |_| {});

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

    assert!(response.headers().contains_key("x-eq"));

    assert_eq!(header(&response, "x-turn"), "0");

    assert_eq!(header(&response, "x-floor-turn"), "0/10");

    assert!(response.headers().get("x-floor-over").is_none());

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

    let friction = async |warm: bool| {

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

            run.body.eq = if warm { 40 } else { 20 };

            run.body.foreskin = Some(1.0);

        });

        let response = send(&app, "JELQ", "/runs/cafebabe?technique=stretch", &[], "").await;

        let noted = warnings(&response).iter().any(|w| w.contains("Cold start"));

        assert_eq!(noted, !warm);

        header(&response, "x-friction").to_owned()

    };

    assert_eq!(friction(true).await, "1/10");

    assert_eq!(friction(false).await, "3/10");

}

#[tokio::test]

async fn wet_without_lube_is_unsupported_media() {

    let Harness { app, .. } = harness(Floor::Bedroom, SEED, |_| {});

    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 Harness { app, .. } = harness(Floor::Bedroom, SEED, |_| {});

    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 Harness { app, .. } = harness(Floor::Clinic, SEED, |_| {});

    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 Harness { app: bedroom, .. } = harness(Floor::Bedroom, SEED, |_| {});

    let options = send(&bedroom, "OPTIONS", "/runs/cafebabe", &[], "").await;

    assert!(header(&options, "allow").contains("JELQ"));

}

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

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

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

    assert!(

        advertised(&cold).contains(&"stretch".to_owned()),

        "a cold jelq is allowed"

    );

    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\"; intensity=\"1-10\"")

    );

    let edge = header(&warm, "link")

        .split(", ")

        .find(|link| link.contains("title=\"edge\""))

        .unwrap();

    assert!(

        edge.ends_with("allow=\"JELQ\"; lubricant=\"optional\""),

        "an edge takes lube but no intensity"

    );

    let Harness { app: forum, .. } = harness(Floor::Forum, SEED, |_| {});

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

    assert!(advertised(&response).is_empty());

}

#[tokio::test]

async fn links_hide_resources_that_would_do_nothing() {

    let Harness { app: bedroom, .. } = harness(Floor::Bedroom, SEED, |_| {});

    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 Harness { app: clinic, .. } = harness(Floor::Clinic, SEED, |_| {});

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

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

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

    assert_eq!(header(&abandoned, "x-run-over"), "abandoned");

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

    assert_eq!(after.status(), StatusCode::GONE);

    assert_eq!(header(&after, "x-run-over"), "abandoned");

}