jelq

use super::*;

#[tokio::test]

async fn mum_accepts_a_known_excuse() {

    let app = seeded_with(Floor::Bedroom, mum_at_the_door);

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

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

    assert_eq!(header(&response, "via"), "1.1 mum");

    let response = send(

        &app,

        "GET",

        "/runs/cafebabe",

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

        "",

    )

    .await;

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

}

#[tokio::test]

async fn mum_runs_out_of_patience() {

    let app = seeded_with(Floor::Bedroom, mum_at_the_door);

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

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

        mum_at_the_door(run);

        run.household.heard.push(Excuse::Homework);

    });

    let basic = send(

        &app,

        "GET",

        "/runs/cafebabe",

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

        "",

    )

    .await;

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

    assert!(header(&basic, "www-authenticate").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=\"wrapping presents\", nonce=\"abc\"",

        )],

        "",

    )

    .await;

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

}

#[tokio::test]

async fn a_pulled_muscle_is_a_true_excuse() {

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

        mum_at_the_door(run);

        run.body.conditions.pulled_muscle = true;

        run.household.heard.push(Excuse::PulledAMuscle);

    });

    let response = send(

        &app,

        "GET",

        "/runs/cafebabe",

        &[(

            "authorization",

            "Digest username=\"pulled a muscle\", nonce=\"abc\"",

        )],

        "",

    )

    .await;

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

}

#[tokio::test]

async fn ignoring_mum_has_consequences() {

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

        mum_at_the_door(run);

        run.here.turns = 6;

    });

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

    assert_eq!(

        json(knock).await["type"],

        "https://jelq.dev/problems/someone-at-the-door"

    );

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

    assert_eq!(

        leave.status(),

        StatusCode::UNAUTHORIZED,

        "no leaving with Mum at the door"

    );

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

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

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

    assert_eq!(

        json(opened).await["type"],

        "https://jelq.dev/problems/opened"

    );

}

#[tokio::test]

async fn mom_speaks_american() {

    let app = seeded_with(Floor::Nans, mum_at_the_door);

    let us = [("accept-language", "en-US")];

    let knock = send(&app, "GET", "/runs/cafebabe", &us, "").await;

    assert_eq!(header(&knock, "content-language"), "en-US");

    assert_eq!(header(&knock, "via"), "1.1 mom");

    assert!(

        json(knock).await["detail"]

            .as_str()

            .unwrap()

            .contains("Someone is at the door.")

    );

    let excuse = [

        ("accept-language", "en-US"),

        (

            "authorization",

            "Digest username=\"carving the turkey\", nonce=\"abc\"",

        ),

    ];

    let answered = send(&app, "GET", "/runs/cafebabe", &excuse, "").await;

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

    let floor = json(send(&app, "GET", "/runs/cafebabe/floor", &us, "").await).await;

    assert_eq!(floor["name"], "Grandma's house for Thanksgiving");

}

#[tokio::test]

async fn an_empty_bottle_is_declined_before_the_enemy_stirs() {

    let control = seeded_with(Floor::ChangingRoom, |run| {

        run.standing.suspicion = SUSPICION_LIMIT;

    });

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

    let caught = send(

        &control,

        "JELQ",

        "/runs/cafebabe?technique=wet&intensity=5",

        &lube,

        "",

    )

    .await;

    assert_eq!(caught.status(), StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS);

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

        run.standing.suspicion = SUSPICION_LIMIT;

        run.items.lubes.baby_oil = 0;

    });

    let refused = send(

        &app,

        "JELQ",

        "/runs/cafebabe?technique=wet&intensity=5",

        &lube,

        "",

    )

    .await;

    assert_eq!(refused.status(), StatusCode::UNSUPPORTED_MEDIA_TYPE);

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

    assert_eq!(header(&view, "x-suspicion"), "5/5");

    assert_eq!(header(&view, "x-shame"), "0");

}

#[tokio::test]

async fn respectable_girth_waves_off_the_gym_staff() {

    let staff = |girth: f64| {

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

            run.body.eq = 45;

            run.body.girth = girth;

            run.standing.suspicion = SUSPICION_LIMIT;

        })

    };

    let thin = send(

        &staff(4.5),

        "JELQ",

        "/runs/cafebabe?technique=edge",

        &[],

        "",

    )

    .await;

    assert_eq!(thin.status(), StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS);

    assert_eq!(header(&thin, "x-shame"), "5");

    let thick = send(

        &staff(5.2),

        "JELQ",

        "/runs/cafebabe?technique=edge",

        &[],

        "",

    )

    .await;

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

    assert!(

        warnings(&thick)

            .iter()

            .any(|w| w.contains("the gym staff have seen worse"))

    );

}

#[tokio::test]

async fn the_kitchen_is_only_on_the_home_floors() {

    let absent = seeded_with(Floor::Bathroom, |_| {});

    let no_kitchen = send(&absent, "POST", "/runs/cafebabe/kitchen", &[], "").await;

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

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

    assert!(!header(&view, "link").contains("/kitchen"));

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

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

    assert!(header(&view, "link").contains("/kitchen"));

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

    assert_ne!(raid.status(), StatusCode::NOT_FOUND);

}

#[tokio::test]

async fn any_other_action_takes_the_melon_off_the_table() {

    for (method, uri) in [

        ("JELQ", "/runs/cafebabe?technique=warmup"),

        ("POST", "/runs/cafebabe/drawer"),

    ] {

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

            run.body.eq = 95;

            run.here.kitchen.melon_offered = true;

        });

        send(&app, method, uri, &[], "").await;

        let melon = send(&app, "POST", "/runs/cafebabe/kitchen/watermelon", &[], "").await;

        assert_eq!(melon.status(), StatusCode::CONFLICT, "{method} {uri}");

    }

}

#[tokio::test]

async fn the_truth_works_under_any_scheme_and_costs_ten() {

    let app = seeded_with(Floor::Bedroom, mum_at_the_door);

    let truth = [("authorization", "Whatever honesty")];

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

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

    assert_eq!(header(&confessed, "x-shame"), "10");

}

#[tokio::test]

async fn mum_refuses_basic_and_stale_nonces() {

    let bedroom = seeded_with(Floor::Bedroom, mum_at_the_door);

    let basic = send(

        &bedroom,

        "GET",

        "/runs/cafebabe",

        &[("authorization", "Basic aG9tZXdvcms=")],

        "",

    )

    .await;

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

    assert!(

        json(basic).await["type"]

            .as_str()

            .unwrap()

            .ends_with("/basic")

    );

    let nans = seeded_with(Floor::Nans, mum_at_the_door);

    let stale = [(

        "authorization",

        "Digest username=\"on a call\", nonce=\"yesterday\"",

    )];

    let refused = send(&nans, "GET", "/runs/cafebabe", &stale, "").await;

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

    assert!(

        json(refused).await["type"]

            .as_str()

            .unwrap()

            .ends_with("stale-nonce")

    );

}

#[tokio::test]

async fn american_players_can_say_studying() {

    let app = seeded_with(Floor::Bedroom, mum_at_the_door);

    let excuse = [

        ("accept-language", "en-US"),

        ("authorization", "Excuse \"Studying\""),

    ];

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

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

}

#[tokio::test]

async fn raids_get_noisier_and_the_household_notices() {

    let told = |suspicion: u8| {

        (0..400u64)

            .filter(|&seed| {

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

                run.body.eq = 40;

                run.standing.suspicion = suspicion;

                run.raid_kitchen().is_err() && run.here.kitchen.closed

            })

            .count()

    };

    let quiet = told(0);

    let noisy = told(4);

    assert!(

        (60..=150).contains(&quiet),

        "a quiet house told {quiet} of 400 raids, about 100 expected"

    );

    assert!(

        (240..=340).contains(&noisy),

        "a noisy house told {noisy} of 400 raids, about 300 expected"

    );

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

    run.body.eq = 40;

    let _ = run.raid_kitchen();

    assert_eq!(run.standing.suspicion, 1, "every raid makes a little noise");

}

#[tokio::test]

async fn one_telling_closes_the_kitchen_and_its_link() {

    let app = seeded_with(Floor::Bedroom, |run| run.standing.suspicion = 4);

    let mut told = None;

    for _ in 0..20 {

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

        if raid.status() == StatusCode::GONE {

            told = Some(raid);

            break;

        }

        assert!(

            warnings(&raid).iter().all(|w| !w.contains("Stop raiding")),

            "there is no warning before the telling"

        );

    }

    let told = told.expect("a noisy house tells within twenty raids");

    assert!(

        warnings(&told)

            .iter()

            .any(|w| w.contains("Stop raiding the kitchen."))

    );

    assert_eq!(json(told).await["detail"], "The kitchen is off limits.");

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

    assert!(!header(&view, "link").contains("/kitchen"));

}

#[tokio::test]

async fn an_excuse_without_a_scheme_is_explained_for_free() {

    let app = seeded_with(Floor::Bedroom, mum_at_the_door);

    for said in ["homework", "on a call", "homework", "homework"] {

        let response = send(

            &app,

            "GET",

            "/runs/cafebabe",

            &[("authorization", said)],

            "",

        )

        .await;

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

        assert!(

            json(response).await["detail"]

                .as_str()

                .unwrap()

                .contains("Excuse \"homework\"")

        );

    }

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

    assert_eq!(header(&view, "x-shame"), "0");

    let excused = send(

        &app,

        "GET",

        "/runs/cafebabe",

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

        "",

    )

    .await;

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

}

#[tokio::test]

async fn mum_leaves_the_way_her_errand_suggests() {

    let app = seeded_with(Floor::Bedroom, mum_at_the_door);

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

    assert_eq!(

        header(&pockets, "www-authenticate"),

        "Excuse realm=\"household\""

    );

    let excused = send(

        &app,

        "GET",

        "/runs/cafebabe",

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

        "",

    )

    .await;

    assert!(warnings(&excused).iter().any(|w| w.contains("the pipes")));

    assert!(excused.headers().get("www-authenticate").is_none());

}

#[tokio::test]

async fn a_stale_nonce_is_explained_for_free() {

    let app = seeded_with(Floor::Nans, mum_at_the_door);

    for _ in 0..4 {

        let stale = send(

            &app,

            "GET",

            "/runs/cafebabe",

            &[(

                "authorization",

                "Digest username=\"helping Nan\", nonce=\"old\"",

            )],

            "",

        )

        .await;

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

        assert!(header(&stale, "www-authenticate").contains("nonce=\"abc\""));

    }

    let current = send(

        &app,

        "GET",

        "/runs/cafebabe",

        &[(

            "authorization",

            "Digest username=\"helping Nan\", nonce=\"abc\"",

        )],

        "",

    )

    .await;

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

}