From d9f1fe513e6f7696809d3a9b4d44ca485fe99c97 Mon Sep 17 00:00:00 2001
From: salmonik <salmonik@tuta.io>
Date: Thu, 29 Oct 2026 17:18:34 +0100
Subject: v2.1.0: add European roulette with split bets and wheel animation

---
 tests/roulette.rs | 184 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 184 insertions(+)
 create mode 100644 tests/roulette.rs

(limited to 'tests/roulette.rs')

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::<Vec<_>>());
+    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());
+}
-- 
cgit v1.2.3