SeaBattle/sea_battle_backend/src/test/client.rs

use tokio::task;

use crate::args::Args;
use crate::bot_client;
use crate::bot_client::ClientEndResult;
use crate::data::{BoatsLayout, GameRules};
use crate::server::start_server;
use crate::test::network_utils::wait_for_port;
use crate::test::TestPort;

#[tokio::test]
async fn invalid_port() {
    let _ = env_logger::builder().is_test(true).try_init();

    let rules = GameRules::random_players_rules();
    bot_client::run_client(
        &TestPort::ClientInvalidPort.as_url(),
        &rules,
        BoatsLayout::gen_random_for_rules(&rules).unwrap(),
    )
    .await
    .unwrap_err();
}

#[tokio::test]
async fn invalid_rules() {
    let _ = env_logger::builder().is_test(true).try_init();

    let local_set = task::LocalSet::new();
    local_set
        .run_until(async move {
            let mut rules = GameRules::random_players_rules();
            rules.map_width = 0;

            task::spawn_local(start_server(Args::for_test(TestPort::ClientInvalidRules)));
            wait_for_port(TestPort::ClientInvalidRules.port()).await;

            bot_client::run_client(
                &TestPort::ClientInvalidRules.as_url(),
                &rules,
                BoatsLayout::gen_random_for_rules(&GameRules::random_players_rules()).unwrap(),
            )
            .await
            .unwrap_err();
        })
        .await;
}

#[tokio::test]
async fn full_game() {
    let _ = env_logger::builder().is_test(true).try_init();

    let local_set = task::LocalSet::new();
    local_set
        .run_until(async move {
            let rules = GameRules::random_players_rules();
            task::spawn_local(start_server(Args::for_test(TestPort::FullGame)));
            wait_for_port(TestPort::FullGame.port()).await;

            let res = bot_client::run_client(
                &TestPort::FullGame.as_url(),
                &rules,
                BoatsLayout::gen_random_for_rules(&rules).unwrap(),
            )
            .await
            .unwrap();
            assert_eq!(res, ClientEndResult::Finished);
        })
        .await;
}

#[tokio::test]
async fn full_game_no_touching_boats() {
    let _ = env_logger::builder().is_test(true).try_init();

    let local_set = task::LocalSet::new();
    local_set
        .run_until(async move {
            let mut rules = GameRules::random_players_rules();
            rules.boats_can_touch = false;
            task::spawn_local(start_server(Args::for_test(
                TestPort::FullGameTouchingBoats,
            )));
            wait_for_port(TestPort::FullGameTouchingBoats.port()).await;

            let res = bot_client::run_client(
                &TestPort::FullGameTouchingBoats.as_url(),
                &rules,
                BoatsLayout::gen_random_for_rules(&rules).unwrap(),
            )
            .await
            .unwrap();

            assert_eq!(res, ClientEndResult::Finished);
        })
        .await;
}