jelq

use super::*;

#[tokio::test]

async fn forged_ruler_cookies_are_lies() {

    let forged = send(

        &app(),

        "GET",

        "/leaderboard?sort=content-length",

        &[("cookie", "ruler=1")],

        "",

    )

    .await;

    assert_eq!(forged.status(), StatusCode::BAD_REQUEST);

}

#[tokio::test]

async fn listings_never_reveal_the_private_id() {

    let app = app();

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

    let location = header(&created, "location").to_owned();

    let board = text(send(&app, "GET", "/leaderboard", &[], "").await).await;

    let private = location.trim_start_matches("/runs/");

    assert!(!board.contains(private));

    let entry: Value = serde_json::from_str(&board).unwrap();

    let public = entry["entries"][0]["public_id"].as_str().unwrap();

    let guess = send(&app, "DELETE", &format!("/runs/{public}"), &[], "").await;

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

}

#[tokio::test]

async fn seeded_runs_are_unranked() {

    let app = app();

    send(&app, "POST", "/runs?seed=7", &[], "").await;

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

    assert_eq!(board["entries"].as_array().unwrap().len(), 0);

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

    assert_eq!(all["entries"][0]["ranked"], false);

}

#[tokio::test]

async fn idle_runs_are_evicted_and_the_server_has_a_limit() {

    let state = Arc::new(

        AppState::new(Config {

            idle_ttl: Duration::ZERO,

            ..Config::default()

        })

        .unwrap(),

    );

    let forgetful = router(Arc::clone(&state));

    let first = send(&forgetful, "POST", "/runs", &[], "").await;

    let location = header(&first, "location").to_owned();

    state.sweep(std::time::Instant::now()).unwrap();

    let gone = send(&forgetful, "GET", &location, &[], "").await;

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

    let board = json(send(&forgetful, "GET", "/leaderboard", &[], "").await).await;

    assert_eq!(

        board["entries"][0]["status"], "alive",

        "a swept run keeps its place on the leaderboard"

    );

    let tiny = crate::app(Config {

        max_runs: 1,

        ..Config::default()

    })

    .unwrap();

    send(&tiny, "POST", "/runs", &[], "").await;

    let full = send(&tiny, "POST", "/runs", &[], "").await;

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

}

#[tokio::test]

async fn shame_from_two_runs_adds_up() {

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

    state.insert(Run::new("cafebabe".into(), "cafe".into(), SEED));

    state.insert(Run::new("deadbeef".into(), "dead".into(), 7));

    let app = router(state);

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

    assert_eq!(header(&first, "x-shame"), "1");

    let cookie = header(&first, "set-cookie")

        .split(';')

        .next()

        .unwrap()

        .to_owned();

    let second = send(&app, "TRACE", "/runs/deadbeef", &[("cookie", &cookie)], "").await;

    assert_eq!(header(&second, "x-shame"), "2");

}

#[tokio::test]

async fn the_root_negotiates() {

    let app = app();

    let browser = send(&app, "GET", "/", &[("accept", "text/html,*/*")], "").await;

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

    assert_eq!(header(&browser, "location"), "/ui/");

    let curl = send(&app, "GET", "/", &[("accept", "*/*")], "").await;

    assert_eq!(json(curl).await["ui"], "/ui/");

    let page = send(&app, "GET", "/ui/", &[], "").await;

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

}

#[tokio::test]

async fn the_ui_replays_what_browsers_cannot_send() {

    let app = app();

    let envelope =

        r#"{"method": "TRACE", "path": "/graveyard", "headers": [["X-Confession", "I did it"]]}"#;

    let traced = json(send(&app, "POST", "/ui/send", &[], envelope).await).await;

    assert_eq!(traced["status"], 405);

    let envelope = r#"{"method": "GET", "path": "/", "headers": [["Accept", "text/html"]]}"#;

    let redirected = json(send(&app, "POST", "/ui/send", &[], envelope).await).await;

    assert_eq!(redirected["status"], 303);

    assert_eq!(redirected["reason"], "See Other");

}

#[tokio::test]

async fn the_ui_decodes_gzip_for_display() {

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

    let envelope =

        r#"{"method": "GET", "path": "/runs/cafebabe", "headers": [["Accept-Encoding", "gzip"]]}"#;

    let shown = json(send(&app, "POST", "/ui/send", &[], envelope).await).await;

    assert!(

        shown["body"]

            .as_str()

            .unwrap()

            .contains("\"public_id\":\"cafe\"")

    );

    let encoding = shown["headers"]

        .as_array()

        .unwrap()

        .iter()

        .any(|h| h[0] == "content-encoding" && h[1] == "gzip");

    assert!(encoding);

}

#[tokio::test]

async fn the_default_locale_is_british() {

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

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

    assert_eq!(header(&floor, "content-language"), "en-GB");

    assert!(header(&floor, "vary").contains("Accept-Language"));

    assert_eq!(json(floor).await["name"], "Nan's house at Christmas");

}

#[tokio::test]

async fn a_full_server_buries_the_dead_to_make_room() {

    let app = crate::app(Config {

        max_runs: 1,

        ..Config::default()

    })

    .unwrap();

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

    let location = header(&first, "location").to_owned();

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

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

    send(&app, "DELETE", &location, &[], "").await;

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

    assert_eq!(second.status(), StatusCode::CREATED);

}

#[tokio::test]

async fn the_forum_respects_volume() {

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

    for (id, length, girth) in [("slim", 7.0, 4.0), ("stout", 5.0, 5.5)] {

        let mut run = Run::new(id.into(), id.into(), 1);

        run.body.length = length;

        run.body.girth = girth;

        state.insert(run);

    }

    let app = router(state);

    let board = json(

        send(

            &app,

            "GET",

            "/leaderboard?sort=volume&seeded=include",

            &[],

            "",

        )

        .await,

    )

    .await;

    assert_eq!(board["entries"][0]["public_id"], "stout");

    assert!(board["entries"][0]["volume"].as_f64().unwrap() > 0.0);

}

#[tokio::test]

async fn the_dead_outlive_the_server() {

    let path = std::env::temp_dir().join(format!("jelqd-{}.sqlite", std::process::id()));

    let config = || Config {

        db: Some(path.clone()),

        ..Config::default()

    };

    let first = crate::app(config()).unwrap();

    let created = send(&first, "POST", "/runs", &[], "").await;

    let location = header(&created, "location").to_owned();

    send(&first, "DELETE", &location, &[], "").await;

    drop(first);

    let second = crate::app(config()).unwrap();

    let gone = send(&second, "GET", &location, &[], "").await;

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

    let graveyard = json(send(&second, "GET", "/graveyard", &[], "").await).await;

    assert_eq!(graveyard["runs"].as_array().unwrap().len(), 1);

    let board = json(send(&second, "GET", "/leaderboard", &[], "").await).await;

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

    for suffix in ["", "-wal", "-shm"] {

        let _ = std::fs::remove_file(format!("{}{suffix}", path.display()));

    }

}

#[tokio::test]

async fn the_graveyard_pages_by_fifty() {

    let app = app();

    for _ in 0..51 {

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

        let location = header(&created, "location").to_owned();

        send(&app, "DELETE", &location, &[], "").await;

    }

    let first = send(&app, "GET", "/graveyard", &[], "").await;

    assert!(header(&first, "link").contains("page=2>; rel=\"next\""));

    assert_eq!(json(first).await["runs"].as_array().unwrap().len(), 50);

    let second = send(&app, "GET", "/graveyard?page=2", &[], "").await;

    assert!(header(&second, "link").contains("page=1>; rel=\"prev\""));

    assert_eq!(json(second).await["runs"].as_array().unwrap().len(), 1);

}

#[tokio::test]

async fn a_prescribed_run_outlives_the_server() {

    let path = std::env::temp_dir().join(format!("jelqd-prescribed-{}.sqlite", std::process::id()));

    let config = || Config {

        db: Some(path.clone()),

        ..Config::default()

    };

    let state = Arc::new(AppState::new(config()).unwrap());

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

    run.floor = Floor::Clinic;

    state.insert(run);

    let first = router(state);

    send(

        &first,

        "GET",

        "/runs/cafebabe/diagnosis",

        &[("authorization", "Bearer honesty")],

        "",

    )

    .await;

    drop(first);

    let second = crate::app(config()).unwrap();

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

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

    for suffix in ["", "-wal", "-shm"] {

        let _ = std::fs::remove_file(format!("{}{suffix}", path.display()));

    }

}