From d9f1fe513e6f7696809d3a9b4d44ca485fe99c97 Mon Sep 17 00:00:00 2001 From: salmonik Date: Thu, 29 Oct 2026 17:18:34 +0100 Subject: v2.1.0: add European roulette with split bets and wheel animation --- tests/client_core.rs | 88 ++++++++++++++++++++++++ tests/roulette.rs | 184 +++++++++++++++++++++++++++++++++++++++++++++++++++ tests/server_core.rs | 59 +++++++++++++++++ 3 files changed, 331 insertions(+) create mode 100644 tests/roulette.rs (limited to 'tests') diff --git a/tests/client_core.rs b/tests/client_core.rs index 4749d99..7fb7e29 100644 --- a/tests/client_core.rs +++ b/tests/client_core.rs @@ -47,6 +47,15 @@ impl Screen { self.region_start = None; self.region_len = 0; } + Effect::AnimateRoulette { final_lines, .. } => { + if let Some(start) = self.region_start { + self.lines.truncate(start); + } else { + self.region_start = Some(self.lines.len()); + } + self.lines.extend(final_lines.iter().cloned()); + self.region_len = final_lines.len(); + } Effect::SetPrompt { text, cursor_col } => { self.prompt = text.clone(); self.prompt_cursor = *cursor_col; @@ -125,6 +134,11 @@ impl Harness { self.line(&format!("play slots {bet}")); self.reply("INFO alice 1 1000"); } + + fn enter_roulette(&mut self) { + self.line("play roulette"); + self.reply("INFO alice 1 1000"); + } } #[test] @@ -559,3 +573,77 @@ fn rejects_a_grid_with_the_wrong_size() { assert!(parse_spin_response(response).is_err()); } + +#[test] +fn roulette_split_bets_spin_and_show_the_result() { + let mut h = Harness::new(); + h.enter_roulette(); + + assert_eq!(h.board().len(), 8); + assert_eq!(h.board()[0], "=== ROULETTE ==="); + assert!(h.board()[1].contains("Balance: 1000 PLN")); + assert!(h.board()[1].contains("Chip: 10 PLN")); + assert!(h.board()[2].contains("Bets: (none)")); + + h.key(Key::Char('r')); + h.key(Key::Char('e')); + h.key(Key::Char('1')); + h.key(Key::Char('7')); + h.key(Key::Enter); + + assert!(h.board()[2].contains("RED 10")); + assert!(h.board()[2].contains("EVEN 10")); + assert!(h.board()[2].contains("#17 10")); + assert!(h.board()[2].contains("Total: 30 PLN")); + + h.key(Key::Char(' ')); + let request = h + .sent + .iter() + .find(|line| line.starts_with("PLAY_START roulette")) + .expect("roulette request"); + assert_eq!( + request, + "PLAY_START roulette 30 {\"red\":10,\"black\":0,\"even\":10,\"odd\":0,\"numbers\":[{\"number\":17,\"amount\":10}]}" + ); + + let bets = + r#"{"red":10,"black":0,"even":10,"odd":0,"numbers":[{"number":17,"amount":10}]}"#; + h.reply(&format!( + "ROULETTE_RESULT session-1 360 30 1330 17 black {bets}" + )); + + assert_eq!(h.board().len(), 8); + assert!(h.board()[1].contains("Balance: 1330 PLN")); + assert!(h.board()[4].contains("Winning: 17 BLACK ODD")); + assert!(h.board()[5].contains("Won 360 PLN")); +} + +#[test] +fn roulette_rejects_an_empty_spin_and_accepts_the_equals_chip_key() { + let mut h = Harness::new(); + h.enter_roulette(); + + h.key(Key::Char(' ')); + assert!(h.board()[4].contains("ERROR: Place at least one bet")); + assert!(!h.sent.iter().any(|line| line.starts_with("PLAY_START roulette"))); + + h.key(Key::Char('=')); + assert!(h.board()[1].contains("Chip: 20 PLN")); + h.key(Key::Char('r')); + assert!(h.board()[2].contains("RED 20")); + assert!(h.board()[2].contains("Total: 20 PLN")); +} + +#[test] +fn roulette_rejects_an_out_of_range_number() { + let mut h = Harness::new(); + h.enter_roulette(); + + h.key(Key::Char('9')); + h.key(Key::Char('9')); + h.key(Key::Enter); + + assert!(h.board()[4].contains("ERROR: Number must be 0-36")); + assert!(h.board()[2].contains("Bets: (none)")); +} diff --git a/tests/roulette.rs b/tests/roulette.rs new file mode 100644 index 0000000..6b99d17 --- /dev/null +++ b/tests/roulette.rs @@ -0,0 +1,184 @@ +use zagan_bet::roulette::{ + color, is_black, is_even, is_odd, is_red, rtp, Bets, NumberBet, WHEEL, +}; +use zagan_bet::server::games::roulette::RouletteGame; +use zagan_bet::server::games::traits::Game; + +#[test] +fn the_european_wheel_has_all_37_unique_pockets() { + let mut numbers = WHEEL.to_vec(); + numbers.sort_unstable(); + assert_eq!(numbers, (0..=36).collect::>()); + assert_eq!(color(0), "green"); + assert_eq!(WHEEL.len(), 37); +} + +#[test] +fn colors_and_even_odd_are_correct() { + assert!(is_red(1)); + assert!(is_black(2)); + assert!(!is_red(0)); + assert!(!is_black(0)); + assert!(is_even(2)); + assert!(is_odd(3)); + assert!(!is_even(0)); + assert!(!is_odd(0)); + assert_eq!(color(17), "black"); + assert_eq!(color(18), "red"); +} + +#[test] +fn european_rtp_is_36_over_37() { + assert!((rtp() - 36.0 / 37.0).abs() < 1e-12); +} + +#[test] +fn bets_total_and_winning_number_payouts() { + let bets = Bets { + red: 10, + black: 10, + even: 10, + odd: 10, + numbers: vec![NumberBet { + number: 17, + amount: 5, + }], + }; + + assert_eq!(bets.total(), 45); + // 17 is black and odd: 10*2 + 10*2 + 5*36. + assert_eq!(bets.winnings(17), 220); + // 18 is red and even. + assert_eq!(bets.winnings(18), 40); +} + +#[test] +fn zero_loses_all_outside_bets_but_pays_a_straight_zero() { + let outside = Bets { + red: 10, + black: 10, + even: 10, + odd: 10, + numbers: vec![], + }; + assert_eq!(outside.winnings(0), 0); + + let straight = Bets { + red: 10, + black: 10, + even: 10, + odd: 10, + numbers: vec![NumberBet { + number: 0, + amount: 5, + }], + }; + assert_eq!(straight.total(), 45); + assert_eq!(straight.winnings(0), 180); +} + +#[test] +fn bets_validate_empty_balance_and_invalid_numbers() { + assert!(Bets::default().validate(1000).is_err()); + + let too_big = Bets { + red: 2000, + ..Bets::default() + }; + assert!(too_big.validate(1000).is_err()); + + let bad_number = Bets { + numbers: vec![NumberBet { + number: 37, + amount: 10, + }], + ..Bets::default() + }; + assert!(bad_number.validate(1000).is_err()); +} + +#[test] +fn the_server_settles_a_split_bet() { + let bets = Bets { + red: 10, + black: 10, + even: 10, + odd: 10, + numbers: vec![NumberBet { + number: 17, + amount: 5, + }], + }; + let payload = serde_json::to_string(&bets).unwrap(); + let game = RouletteGame::with_result(17); + let state = game.prepare_state("alice", bets.total()); + + let state = game.process_action(&state, "spin", &[&payload]).unwrap(); + let result = game.calculate_result(&state).unwrap(); + + assert_eq!(result.winnings, 220); + assert_eq!(result.result_data.get("number").unwrap(), "17"); + assert_eq!(result.result_data.get("color").unwrap(), "black"); + assert_eq!(result.result_data.get("bets").unwrap(), &payload); +} + +#[test] +fn the_server_rejects_a_total_that_does_not_match_the_bets() { + let payload = serde_json::to_string(&Bets { + red: 10, + ..Bets::default() + }) + .unwrap(); + let game = RouletteGame::with_result(17); + let state = game.prepare_state("alice", 99); + + assert!(game.process_action(&state, "spin", &[&payload]).is_err()); +} + +#[test] +fn the_server_rejects_an_invalid_number() { + let payload = serde_json::to_string(&Bets { + numbers: vec![NumberBet { + number: 37, + amount: 10, + }], + ..Bets::default() + }) + .unwrap(); + let game = RouletteGame::with_result(17); + let state = game.prepare_state("alice", 10); + + assert!(game.process_action(&state, "spin", &[&payload]).is_err()); +} + +#[test] +fn parses_a_roulette_result() { + let bets = r#"{"red":10,"black":0,"even":10,"odd":0,"numbers":[{"number":17,"amount":10}]}"#; + let response = format!("ROULETTE_RESULT session-1 360 30 1330 17 black {bets}"); + let result = zagan_bet::client::games::response::parse_roulette_response(&response).unwrap(); + + assert_eq!(result.session_id, "session-1"); + assert_eq!(result.winnings, 360); + assert_eq!(result.bet_amount, 30); + assert_eq!(result.balance, 1330); + assert_eq!(result.number, 17); + assert_eq!(result.color, "black"); + assert_eq!(result.bets, bets); +} + +#[test] +fn rejects_bad_roulette_results() { + use zagan_bet::client::games::response::parse_roulette_response; + + let valid_bets = r#"{"red":10}"#; + assert!(parse_roulette_response(&format!( + "ROULETTE_RESULT s 1 1 1 37 green {valid_bets}" + )) + .is_err()); + assert!(parse_roulette_response(&format!( + "ROULETTE_RESULT s 1 1 1 17 purple {valid_bets}" + )) + .is_err()); + assert!(parse_roulette_response("ROULETTE_RESULT s 1 1 1 17 black nope").is_err()); + assert!(parse_roulette_response("").is_err()); +} diff --git a/tests/server_core.rs b/tests/server_core.rs index cab74a7..cf05102 100644 --- a/tests/server_core.rs +++ b/tests/server_core.rs @@ -4,7 +4,9 @@ use rusqlite::Connection; use zagan_bet::server::core::{ConnectionState, ServerCore}; use zagan_bet::server::database; use zagan_bet::server::games::registry::GameRegistry; +use zagan_bet::server::games::roulette::RouletteGame; use zagan_bet::server::games::slots::SlotsGame; +use zagan_bet::roulette::Bets; fn setup(name: &str, grid: &str) -> (ServerCore, String) { let path = PathBuf::from(env!("CARGO_TARGET_TMPDIR")) @@ -29,6 +31,22 @@ const LOSS: &str = "CLOOGDSLCDCOGLS"; /// Top line is C C C D D; it pays 2x total bet. const WIN3: &str = "CCCCLLCLODGSDGS"; +fn setup_roulette(name: &str, number: u8) -> (ServerCore, String) { + let path = PathBuf::from(env!("CARGO_TARGET_TMPDIR")) + .join(format!("server-core-{name}.db")) + .to_string_lossy() + .into_owned(); + let _ = std::fs::remove_file(&path); + + let conn = Connection::open(&path).unwrap(); + database::init_db(&conn); + + let registry = GameRegistry::new(); + registry.register_game(RouletteGame::with_result(number)); + + (ServerCore::with_registry(conn, registry, 4), path) +} + fn register(core: &mut ServerCore, state: &mut ConnectionState, user: &str) { assert_eq!( core.handle_message(state, &format!("REGISTER {user} credential")), @@ -163,6 +181,47 @@ fn plays_record_the_game_type_and_game_specific_details() { assert_eq!(details["win_cells"], "0,3,6"); } +#[test] +fn roulette_settles_split_bets_and_records_details() { + let (mut core, path) = setup_roulette("roulette", 17); + let mut state = ConnectionState::default(); + register(&mut core, &mut state, "alice"); + login(&mut core, &mut state, "alice"); + + let bets = + r#"{"red":10,"black":10,"even":10,"odd":10,"numbers":[{"number":17,"amount":5}]}"#; + let response = core.handle_message(&mut state, &format!("PLAY_START roulette 45 {bets}")); + + assert!( + response.starts_with("ROULETTE_RESULT"), + "response: {response}" + ); + assert!( + response.contains(" 220 45 1175 17 black "), + "response: {response}" + ); + assert!(response.ends_with(&format!(" {bets}")), "response: {response}"); + assert_eq!(core.balance("alice"), Some(1175)); + assert_eq!(core.play_count("alice"), 1); + assert_eq!(core.session_count(), 0); + + let conn = Connection::open(&path).unwrap(); + let (game_type, details): (String, String) = conn + .query_row( + "SELECT game_type, details FROM plays WHERE username = 'alice'", + [], + |row| Ok((row.get(0)?, row.get(1)?)), + ) + .unwrap(); + + assert_eq!(game_type, "roulette"); + let details: serde_json::Value = serde_json::from_str(&details).unwrap(); + assert_eq!(details["number"], "17"); + assert_eq!(details["color"], "black"); + let stored: Bets = serde_json::from_str(details["bets"].as_str().unwrap()).unwrap(); + assert_eq!(stored.total(), 45); +} + #[test] fn a_failed_audit_insert_rolls_back_the_balance_change() { let (mut core, path) = setup("rollback", LOSS); -- cgit v1.2.3