jelq

use super::*;

#[tokio::test]

async fn deleting_the_foreskin_requires_certainty() {

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

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

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

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

    let app = seeded_with(Floor::Forum, |run| run.body.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 dry_jelqs_build_friction_and_real_lube_does_not() {

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

        run.body.warmed_up = true;

        run.items.lubes.baby_oil = 1;

        run.body.foreskin = Some(0.9);

    });

    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.body.warmed_up = true;

        run.body.foreskin = Some(0.9);

    });

    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.body.eq = 80;

        run.body.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.body.friction = 5;

        run.online.meditation_taught = true;

    });

    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.body.warmed_up = true;

            run.body.eq = 60;

            run.items.lubes.baby_oil = 9;

        });

        let hurt_app = app_with(Floor::Bedroom, seed, |run| {

            run.body.warmed_up = true;

            run.body.eq = 60;

            run.items.lubes.baby_oil = 9;

            run.body.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.body.warmed_up = true;

        run.body.eq = 60;

        run.items.lubes.baby_oil = 9;

        run.body.friction = 7;

        run.body.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 friction_rises_with_vigour_and_edging_chafes() {

    let spit = [("content-type", "text/plain; charset=spit")];

    for (intensity, friction) in [(5, "1/10"), (7, "2/10"), (10, "3/10")] {

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

            run.here.wifi_accepted = true;

            run.body.warmed_up = true;

            run.body.eq = 55;

            run.body.foreskin = Some(0.5);

        });

        let uri = format!("/runs/cafebabe?technique=wet&intensity={intensity}");

        let jelq = send(&app, "JELQ", &uri, &spit, "").await;

        assert_eq!(

            header(&jelq, "x-friction"),

            friction,

            "intensity {intensity}"

        );

    }

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

        run.here.wifi_accepted = true;

        run.body.warmed_up = true;

        run.body.eq = 55;

        run.body.foreskin = Some(0.5);

    });

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

    assert_eq!(header(&edge, "x-friction"), "2/10");

}

#[tokio::test]

async fn the_body_changes_how_the_skin_takes_it() {

    let spit = [("content-type", "text/plain; charset=spit")];

    for (foreskin, girth, friction) in [(0.5, 4.5, "1/10"), (1.2, 4.5, "0/10"), (0.5, 5.8, "2/10")]

    {

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

            run.here.wifi_accepted = true;

            run.body.warmed_up = true;

            run.body.eq = 55;

            run.body.foreskin = Some(foreskin);

            run.body.girth = girth;

        });

        let jelq = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &spit, "").await;

        assert_eq!(header(&jelq, "x-friction"), friction, "{foreskin} {girth}");

    }

}

#[tokio::test]

async fn a_thick_girth_outgrows_the_underhand_grip() {

    let app = seeded_with(Floor::Bedroom, |run| run.body.girth = 5.8);

    let grip = send(

        &app,

        "GET",

        "/runs/cafebabe/grip",

        &[("upgrade", "underhand"), ("connection", "upgrade")],

        "",

    )

    .await;

    assert_eq!(grip.status(), StatusCode::PAYLOAD_TOO_LARGE);

}

#[tokio::test]

async fn a_long_run_fills_the_jeans_before_a_thick_one() {

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

        run.body.warmed_up = true;

        run.items.kit.extender = true;

        run.body.girth = 4.8;

        run.body.length = 7.5;

    });

    let lube = [("content-type", "application/baby-oil")];

    let full = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;

    assert_eq!(full.status(), StatusCode::INSUFFICIENT_STORAGE);

}

#[tokio::test]

async fn a_refused_jelq_leaves_the_lube_alone() {

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

        run.body.warmed_up = true;

        run.items.kit.extender = true;

        run.body.girth = 6.0;

        run.body.length = 6.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 lubes_run_out_but_spit_never_does() {

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

        run.body.warmed_up = true;

        run.items.lubes.baby_oil = 1;

    });

    let lube = [("content-type", "application/baby-oil")];

    send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;

    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::UNSUPPORTED_MEDIA_TYPE,

            "spit never runs out"

        );

    }

}

#[tokio::test]

async fn patching_costs_a_little_eq() {

    let app = seeded_with(Floor::Bedroom, |run| run.body.eq = 50);

    let patch = send(

        &app,

        "PATCH",

        "/runs/cafebabe",

        &[("content-type", "application/json-patch+json")],

        r#"[{"op": "test", "path": "/girth", "value": 1.0}]"#,

    )

    .await;

    assert_eq!(patch.status(), StatusCode::CONFLICT);

    assert_eq!(header(&patch, "x-eq"), "47");

}

#[tokio::test]

async fn a_combo_chafes_twice_and_costs_two_stamina() {

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

        run.here.wifi_accepted = true;

        run.body.warmed_up = true;

        run.body.eq = 55;

        run.body.foreskin = Some(0.5);

    });

    let spit = [("content-type", "text/plain; charset=spit")];

    let combo = send(

        &app,

        "JELQ",

        "/runs/cafebabe?technique=wet,stretch",

        &spit,

        "",

    )

    .await;

    assert_eq!(header(&combo, "x-friction"), "2/10");

    assert_eq!(header(&combo, "x-stamina"), "8/10");

}

#[test]

fn the_drawer_starts_with_at_most_one_bottle() {

    let mut stocked = 0;

    for seed in 0..400u64 {

        let lubes = &Run::new("cafebabe".into(), "cafe".into(), seed).items.lubes;

        let bottles = lubes.baby_oil + lubes.lotion;

        assert!(bottles <= 1 && lubes.coconut_oil + lubes.vaseline == 0);

        stocked += bottles;

    }

    assert!(

        (160..=240).contains(&stocked),

        "{stocked}/400 started with lube"

    );

}

#[tokio::test]

async fn stretching_reports_the_foreskin_it_grew() {

    let mut landed = 0;

    for seed in 0..40u64 {

        let app = app_with(Floor::Bedroom, seed, |run| {

            run.body.warmed_up = true;

            run.body.eq = 60;

            run.body.foreskin = Some(1.0);

        });

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

        if stretch.status() == StatusCode::OK {

            assert_eq!(header(&stretch, "x-foreskin"), "1.03");

            assert_eq!(json(stretch).await["foreskin"], 0.03);

            landed += 1;

        }

    }

    assert!(landed > 0, "forty stretches and none landed clean");

}