jelq

use super::*;

#[tokio::test]

async fn only_the_key_opens_the_cage() {

    let app = seeded_with(Floor::ChangingRoom, |run| run.items.kit.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 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 the_elder_is_stale() {

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

    let app = seeded_with(Floor::ChangingRoom, |run| run.items.kit.cage = true);

    let mut statuses = Vec::new();

    for _ in 0..30 {

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

        statuses.push(response.status());

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

            break;

        }

    }

    assert_eq!(statuses.last(), Some(&StatusCode::OK), "{statuses:?}");

    assert!(

        statuses[..statuses.len() - 1]

            .iter()

            .all(|s| *s == StatusCode::NO_CONTENT)

    );

}

#[tokio::test]

async fn an_open_tab_is_linked_and_jelq_still_answers_with_choices() {

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

        run.online.story = Story::Pending;

    });

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

    let links = header(&response, "link");

    assert!(links.contains("/branches/forum>; rel=\"https://jelq.dev/rels/branch\""));

    assert!(links.contains("/branches/close-tab>; rel=\"https://jelq.dev/rels/branch\""));

    assert!(links.contains("?technique=wet>"));

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

    assert_eq!(jelq.status(), StatusCode::MULTIPLE_CHOICES);

}

#[tokio::test]

async fn either_story_choice_is_reachable_during_cooldown() {

    for choice in ["forum", "close-tab"] {

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

            run.turn = 9;

            run.body.eq = 45;

            run.body.stamina = 1;

            run.items.stores.door_locks = 1;

        });

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

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

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

        assert!(!header(&response, "link").contains("?technique="));

        let path = format!("/runs/cafebabe/branches/{choice}");

        assert!(

            header(&response, "link")

                .contains(&format!("<{path}>; rel=\"https://jelq.dev/rels/branch\""))

        );

        let chosen = send(&app, "POST", &path, &[], "").await;

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

        assert!(!header(&chosen, "link").contains("/branches/"));

        let repeated = send(&app, "POST", &path, &[], "").await;

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

    }

}

#[tokio::test]

async fn the_thread_announces_itself_at_the_branch() {

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

        run.turn = 8;

        run.items.lubes.baby_oil = 9;

    });

    send(

        &app,

        "JELQ",

        "/runs/cafebabe?technique=wet",

        &[("content-type", "application/baby-oil")],

        "",

    )

    .await;

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

    assert!(!header(&ninth, "link").contains("/cafebabe/thread>"));

    let tenth = send(

        &app,

        "JELQ",

        "/runs/cafebabe?technique=wet",

        &[("content-type", "application/baby-oil")],

        "",

    )

    .await;

    assert!(

        tenth

            .headers()

            .get_all("warning")

            .iter()

            .any(|w| w.to_str().unwrap().contains("a forum thread from 2009"))

    );

    assert!(header(&tenth, "link").contains("/cafebabe/thread>"));

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

    assert!(header(&announced, "link").contains("/cafebabe/thread>"));

}

#[tokio::test]

async fn reading_the_thread_teaches_uli() {

    let mut taught_runs = 0;

    for seed in 0..100u64 {

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

            run.turn = BRANCH_TURN;

            run.online.story = Story::ClosedTab;

            run.online.meditation_taught = true;

        });

        let mut taught = false;

        for _ in 0..2 {

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

            assert_eq!(read.status(), StatusCode::OK, "seed {seed}");

            let warned = warnings(&read).iter().any(|w| w.contains("2009"));

            let body = json(read).await;

            assert!(body["posts"].is_array(), "a read always shows the thread");

            if body["detail"].is_string() {

                assert!(!warned);

                taught = true;

                break;

            }

            assert!(warned);

        }

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

        assert_eq!(header(&state, "x-stamina"), "10/10", "reading is free");

        if taught {

            taught_runs += 1;

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

            assert_ne!(jelq.status(), StatusCode::FORBIDDEN);

        } else {

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

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

            assert!(header(&cached, "warning").starts_with("112"));

            assert!(header(&cached, "age").parse::<u64>().unwrap() > 0);

        }

    }

    assert!(

        (30..=58).contains(&taught_runs),

        "{taught_runs}/100 learned uli in two reads"

    );

}

#[tokio::test]

async fn the_thread_cannot_be_read_before_anyone_mentions_it() {

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

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

    assert_eq!(read.status(), StatusCode::NOT_FOUND);

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

    assert!(!header(&after, "link").contains("/thread"));

}

#[tokio::test]

async fn rummaging_for_the_key_leaves_the_drawer_unsearched() {

    let mut found = 0;

    for seed in 0..20u64 {

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

            run.here.wifi_accepted = true;

            run.items.kit.cage = true;

        });

        for _ in 0..30 {

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

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

                break;

            }

        }

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

        if search.status() == StatusCode::FOUND {

            assert!(header(&search, "location").ends_with("/inventory/do-not-disturb-sign"));

            found += 1;

        }

    }

    assert!(

        found >= 18,

        "only {found} of 20 hotel drawers survived the rummage"

    );

}

#[tokio::test]

async fn kev_is_the_bar_in_the_changing_room() {

    for (length, shamed) in [(5.0, true), (7.0, false)] {

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

            run.body.length = length;

            run.here.turns = 6;

        });

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

        assert_eq!(header(&left, "x-floor"), "3");

        let warning = left

            .headers()

            .get("warning")

            .map(|w| w.to_str().unwrap().to_owned());

        assert_eq!(

            warning.is_some_and(|w| w.contains("Kev")),

            shamed,

            "length {length}"

        );

    }

}

#[tokio::test]

async fn pump_bro_charges_the_thin_more_for_girth() {

    for (girth, ring, oil) in [(4.5, 11, 4), (5.2, 8, 4)] {

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

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

        let price = |slug: &str| {

            shop["stock"]

                .as_array()

                .unwrap()

                .iter()

                .find(|item| item["item"] == slug)

                .unwrap()["price"]

                .as_u64()

                .unwrap()

        };

        assert_eq!(price("cock-ring"), ring, "girth {girth}");

        assert_eq!(price("baby-oil"), oil, "girth {girth}");

    }

}

#[tokio::test]

async fn the_clinic_escalates_toward_honesty() {

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

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

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

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

    let Harness {

        app, origin: etag, ..

    } = harness(Floor::Clinic, SEED, |_| {});

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

    let forum = |girth: f64| {

        seeded_with(Floor::Forum, move |run| {

            run.body.length = 6.0;

            run.body.girth = girth;

        })

    };

    let fib = [("proxy-authorization", "Ruler 6.5")];

    let thin = forum(4.5);

    for _ in 0..2 {

        let strike = send(&thin, "GET", "/runs/cafebabe/elder", &fib, "").await;

        assert_eq!(strike.status(), StatusCode::PROXY_AUTHENTICATION_REQUIRED);

    }

    let banned = send(&thin, "GET", "/runs/cafebabe/elder", &fib, "").await;

    assert_eq!(banned.status(), StatusCode::FORBIDDEN);

    assert!(

        json(banned).await["type"]

            .as_str()

            .unwrap()

            .ends_with("banned")

    );

    let thick = forum(5.2);

    for _ in 0..4 {

        let excused = send(&thick, "GET", "/runs/cafebabe/elder", &fib, "").await;

        assert_eq!(excused.status(), StatusCode::PROXY_AUTHENTICATION_REQUIRED);

        assert!(header(&excused, "x-forum-note").contains("Girth is also a dimension"));

    }

}

#[tokio::test]

async fn the_zip_ends_one_exit_in_two_hundred() {

    let mut zipped = 0;

    for seed in 0..4000u64 {

        let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);

        run.here.turns = 6;

        if run.advance().is_err() && run.ended.is_some() {

            zipped += 1;

        }

    }

    assert!(

        (8..=35).contains(&zipped),

        "{zipped} zips in 4000 exits, about 20 expected"

    );

}

#[tokio::test]

async fn a_prescription_ends_the_run_and_the_true_ending_still_waits() {

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

    let honest = [("authorization", "Bearer honesty")];

    let prescribed = send(&app, "GET", "/runs/cafebabe/diagnosis", &honest, "").await;

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

    assert!(header(&prescribed, "server-timing").contains("volume;"));

    assert!(

        json(prescribed).await["detail"]

            .as_str()

            .unwrap()

            .starts_with("Congratulations")

    );

    let board = json(send(&app, "GET", "/leaderboard?seeded=include", &[], "").await).await;

    assert_eq!(board["entries"][0]["status"], "prescribed");

    let conditional = [

        ("authorization", "Bearer honesty"),

        ("if-none-match", origin.as_str()),

    ];

    let cured = send(&app, "GET", "/runs/cafebabe/diagnosis", &conditional, "").await;

    assert_eq!(cured.status(), StatusCode::NOT_MODIFIED);

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

    assert_eq!(view["status"], "normal");

}

#[tokio::test]

async fn the_foreskin_window_has_hard_edges() {

    for (foreskin, refused) in [

        (0.79, Some(StatusCode::LENGTH_REQUIRED)),

        (0.8, None),

        (2.0, None),

        (2.01, Some(StatusCode::PAYLOAD_TOO_LARGE)),

    ] {

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

            run.here.wifi_accepted = true;

            run.body.eq = 55;

            run.body.foreskin = Some(foreskin);

        });

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

        match refused {

            Some(status) => assert_eq!(dry.status(), status, "foreskin {foreskin}"),

            None => assert!(

                ![StatusCode::LENGTH_REQUIRED, StatusCode::PAYLOAD_TOO_LARGE]

                    .contains(&dry.status()),

                "foreskin {foreskin} sits inside the window"

            ),

        }

    }

}

#[tokio::test]

async fn the_forum_teaches_breathing_before_uli() {

    let mut breathing = 0;

    for seed in 0..100u64 {

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

            run.turn = BRANCH_TURN;

            run.online.story = Story::Pending;

        });

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

        let meditate = listed["techniques"]

            .as_array()

            .unwrap()

            .iter()

            .find(|t| t["name"] == "meditate")

            .unwrap();

        assert_eq!(meditate["locked"], true);

        send(&app, "POST", "/runs/cafebabe/branches/forum", &[], "").await;

        for _ in 0..2 {

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

        }

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

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

            breathing += 1;

        } else {

            assert_eq!(meditated.status(), StatusCode::FORBIDDEN);

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

            assert_eq!(

                uli.status(),

                StatusCode::FORBIDDEN,

                "seed {seed} skipped ahead"

            );

        }

    }

    assert!(

        (75..=97).contains(&breathing),

        "{breathing}/100 learned to breathe on the branch floor"

    );

}