def test_player_wants_to_fold_or_not(self):
player = Player(name = "shoreya", hand = Hand())
self.assertEqual(
player.wants_to_fold(),
False
)
def test_points_a_draw_between_two_out_of_three_players(self):
two_of_clubs = Card(rank="2", suit="Clubs")
two_of_hearts = Card(rank="2", suit="Hearts")
two_of_diamonds = Card(rank="2", suit="Diamonds")
two_of_spades = Card(rank="2", suit="Spades")
seven_of_hearts = Card(rank="7", suit="Hearts")
eight_of_clubs = Card(rank="8", suit="Clubs")
mock_hand1 = MagicMock()
mock_hand1.best_rank.return_value = (9, "Pair",
[two_of_clubs, two_of_diamonds])
mock_hand2 = MagicMock()
mock_hand2.best_rank.return_value = (9, "Pair",
[two_of_hearts, two_of_spades])
mock_hand3 = MagicMock()
mock_hand3.best_rank.return_value = (10, "High Card",
[seven_of_hearts, eight_of_clubs])
player1 = Player(name="Kimberly", hand=mock_hand1)
player2 = Player(name="Debbie", hand=mock_hand2)
player3 = Player(name="Amanda", hand=mock_hand3)
players = [player1, player2, player3]
self.assertEqual(player1, player2)
self.assertGreater(player1, player3)
self.assertGreater(player2, player3)
def test_player_decide_dop_out(self):
hand = Hand()
player = Player(name="Sarah", hand=hand, controller=MagicMock())
player.fold()
self.assertEqual(player.active, False)
player.active = True
self.assertEqual(player.active, True)
def test_bet_round_everyone_fold_with_blinds(self):
bets = {
"player-1": 400,
"player-2": 1000
}
player1 = Player("player-1", "Player One", 1000.0)
player2 = Player("player-2", "Player Two", 1000.0)
player3 = Player("player-3", "Player Three", 1000.0)
player4 = Player("player-4", "Player Four", 1000.0)
game_players = GamePlayers([player1, player2, player3, player4])
def bet_function_mock(player, min_bet, max_bet, bets):
return -1
bet_rounder = GameBetRounder(game_players)
best_player = bet_rounder.bet_round("player-3", bets, bet_function_mock)
self.assertEquals("player-2", best_player.id)
self.assertTrue(game_players.is_active("player-2"))
self.assertFalse(game_players.is_active("player-1"))
self.assertFalse(game_players.is_active("player-3"))
self.assertFalse(game_players.is_active("player-4"))
def test_add_bets_with_folders_two_rounds_all_in_players(self):
player1 = Player("player-1", "Player One", 1000)
player2 = Player("player-2", "Player Two", 1000)
player3 = Player("player-3", "Player Three", 1000)
player4 = Player("player-4", "Player Four", 1000)
game_players = GamePlayers([player1, player2, player3, player4])
game_pots = GamePots(game_players)
game_pots.add_bets({"player-1": 100.0, "player-2": 200.0, "player-3": 200.0, "player-4": 200.0})
self.assertEqual(2, len(game_pots))
self.assertEquals(400, game_pots[0].money)
self.assertListEqual([player1, player2, player3, player4], game_pots[0].players)
self.assertEquals(300, game_pots[1].money)
self.assertListEqual([player2, player3, player4], game_pots[1].players)
game_players.fold("player-2")
game_pots.add_bets({"player-1": 0, "player-2": 50.0, "player-3": 100, "player-4": 100})
self.assertEqual(2, len(game_pots))
self.assertEquals(400, game_pots[0].money)
self.assertListEqual([player1, player3, player4], game_pots[0].players)
self.assertEquals(550, game_pots[1].money)
self.assertListEqual([player3, player4], game_pots[1].players)
def test_bet_round_one_player_only(self):
game_players = GamePlayers([
Player("player-1", "Player One", 500.0),
Player("player-2", "Player Two", 1000.0),
Player("player-3", "Player Three", 1000.0),
Player("player-4", "Player Four", 2000.0),
])
game_players.fold("player-1")
game_players.fold("player-3")
game_players.fold("player-4")
bet_rounder = GameBetRounder(game_players)
bet_calls = { # Workaround as Python 2.7 doesn't have nonlocal
"counter": 0
}
def bet_function_mock(player, min_bet, max_bet, bets):
bet_calls["counter"] += 1
return -1
bets = {}
best_player = bet_rounder.bet_round("player-2", bets, bet_function_mock)
self.assertEquals(0, bet_calls["counter"])
self.assertEquals("player-2", best_player.id)
self.assertEquals({"player-2": 0.0}, bets)
def _create_game_players(self):
return GamePlayers([
Player("player-1", "Player One", 1000.0),
Player("player-2", "Player Two", 1000.0),
Player("player-3", "Player Three", 0.0),
Player("player-4", "Player Four", 1000.0),
])
def test_player_bet(self):
hand = Hand()
player = Player("Sarah", hand, controller=MagicMock())
player.add_chips(50)
bet = player.bet(20)
self.assertEqual(bet, 20)
self.assertEqual(player.chips, 30)
def test_figures_out_own_best_hand(self):
mock_hand = MagicMock()
mock_hand.best_rank.return_value = "Straight Flush"
player = Player(name="Boris", hand=mock_hand)
self.assertEqual(player.best_hand(), "Straight Flush")
mock_hand.best_rank.assert_called()
def test_passes_new_cars_to_hand(self):
mock_hand = MagicMock()
player = Player(name="Kimberly", hand=mock_hand)
cards = [
Card(rank="Ace", suit="Spades"),
Card(rank="Queen", suit="Diamonds")
]
player.add_cards(cards)
mock_hand.add_cards.assert_called_once_with(cards)
def test_get_winners(self):
player1 = Player("player-1", "Player One", 1000.0)
player2 = Player("player-2", "Player Two", 1000.0)
player3 = Player("player-3", "Player Three", 1000.0)
player4 = Player("player-4", "Player Four", 1000.0)
players = GamePlayers([player1, player2, player3, player4])
class ScoreMock:
def __init__(self, value):
self.value = value
def cmp(self, other):
if self.value < other.value:
return -1
elif self.value > other.value:
return 1
else:
return 0
class GameScoresMock:
def player_score(self, player_id):
if player_id == "player-1":
return ScoreMock(3)
elif player_id == "player-2":
return ScoreMock(2)
elif player_id == "player-3":
return ScoreMock(2)
elif player_id == "player-4":
return ScoreMock(1)
else:
raise ValueError("Unknown player id")
winner_detector = GameWinnersDetector(players)
winners = winner_detector.get_winners([player2, player3, player4], GameScoresMock())
self.assertListEqual([player2, player3], winners)
winners = winner_detector.get_winners([player1, player2, player3, player4], GameScoresMock())
self.assertListEqual([player1], winners)
players.fold("player-1")
winners = winner_detector.get_winners([player1, player2, player3, player4], GameScoresMock())
self.assertListEqual([player2, player3], winners)
players.fold("player-2")
winners = winner_detector.get_winners([player1, player2, player3, player4], GameScoresMock())
self.assertListEqual([player3], winners)
players.fold("player-3")
winners = winner_detector.get_winners([player1, player2, player3, player4], GameScoresMock())
self.assertListEqual([player4], winners)
players.fold("player-4")
winners = winner_detector.get_winners([player1, player2, player3, player4], GameScoresMock())
self.assertListEqual([], winners)
def test_player_can_add_cards_to_hand(self):
hand_mock = MagicMock()
player = Player(name = "shoreya", hand = hand_mock)
cards = [
Card(rank = "Ace", suite = "diamonds"),
Card(rank = "8", suite = "spades")
]
player.add_cards(cards)
hand_mock.add_cards.assert_called_with(cards)
def test_figures_out_own_best_hand(self):
mock_hand = MagicMock()
mock_hand.best_rank.return_value = "Straight Flush"
player = Player(name="Boris", hand=mock_hand)
self.assertEqual(player.best_hand(), "Straight Flush")
# No need to have it becuase line 16 has this check
# within it. Just keep this line explicitly
mock_hand.best_rank.assert_called()
def test_add_bets_when_strongest_player_fold(self):
player1 = Player("player-1", "Player One", 1000)
player2 = Player("player-2", "Player Two", 1000)
player3 = Player("player-3", "Player Three", 1000)
player4 = Player("player-4", "Player Four", 1000)
game_players = GamePlayers([player1, player2, player3, player4])
game_pots = GamePots(game_players)
game_players.fold("player-4")
self.assertRaises(ValueError, game_pots.add_bets, {"player-3": 200.0, "player-4": 400.0})
def test_passes_new_cards_to_hand(self):
mock_hand = MagicMock()
player = Player(name='Bob', hand=mock_hand)
cards = [
Card(rank='Ace', suit='Diamonds'),
Card(rank='8', suit='Spades')
]
player.add_cards(cards)
mock_hand.add_cards.assert_called_once_with(cards)
def test_is_sorted_by_best_hand(self):
mock_hand1 = MagicMock()
mock_hand1.best_rank.return_value = [0, "Royal Flush", []]
mock_hand2 = MagicMock()
mock_hand2.best_rank.return_value = [2, "Four of a Kind", []]
player1 = Player(name="Kimberly", hand=mock_hand1)
player2 = Player(name="Debbie", hand=mock_hand2)
players = [player1, player2]
self.assertEqual(max(players), player1)
def test_is_sorted_by_best_hand(self):
mock_hand1 = MagicMock()
mock_hand1.best_rank.return_value = (0, "Royal Flush", [])
mock_hand2 = MagicMock()
mock_hand2.best_rank.return_value = (2, "Four of a Kind", [])
player1 = Player(name="Jeff", hand=mock_hand1)
player2 = Player(name="Bill", hand=mock_hand2)
players = [player1, player2]
self.assertEqual(max(players), player1)
def test_main_pot():
bot = SopelMock()
player1 = Player(bot, "player1")
player1.quit = False
player1.busted = False
player1.folded = False
players = [player1]
sidepots = SidePots()
sidepots.deposit(1000)
pots = sidepots.calculate(players)
assert pots
assert len(pots) == 1
assert pots[0].value == 1000
assert player1 in pots[0].players
def add_player(self, seat_pos, username, chips, id):
if seat_pos < 8:
if not self.players[seat_pos]:
self.players[seat_pos] = Player()
self.players[seat_pos].user = username
self.players[seat_pos].seat_num = seat_pos
self.players[seat_pos].coins = chips
self.players[seat_pos].id = id
def test_bet_round_valid_bet_dictionary_3(self):
bets = {
"player-1": 1000,
"player-2": 500
}
game_players = GamePlayers([
Player("player-1", "Player One", 1000.0),
Player("player-2", "Player Two", 1000.0)
])
def bet_function_mock(player, min_bet, max_bet, bets):
return -1
bet_rounder = GameBetRounder(game_players)
bet_rounder.bet_round("player-2", bets, bet_function_mock)
def test_add_bets_with_one_round(self):
player1 = Player("player-1", "Player One", 1000)
player2 = Player("player-2", "Player Two", 1000)
player3 = Player("player-3", "Player Three", 1000)
player4 = Player("player-4", "Player Four", 1000)
game_players = GamePlayers([player1, player2, player3, player4])
game_pots = GamePots(game_players)
game_pots.add_bets({"player-1": 500, "player-2": 0.0, "player-3": 800, "player-4": 800})
self.assertEqual(2, len(game_pots))
self.assertEquals(1500, game_pots[0].money)
self.assertEquals([player1, player3, player4], game_pots[0].players)
self.assertEquals(600, game_pots[1].money)
self.assertEquals([player3, player4], game_pots[1].players)
def test_sort_players_with_High_Card_in_correct_order(self):
two_of_clubs = Card(rank="2", suit="Clubs")
queen_of_diamonds = Card(rank="Queen", suit="Diamonds")
cards1 = [two_of_clubs]
cards2 = [queen_of_diamonds]
mock_hand1 = MagicMock()
mock_hand2 = MagicMock()
mock_hand1.best_rank.return_value = (9, "High Card", cards1)
mock_hand2.best_rank.return_value = (9, "High Card", cards2)
player1 = Player(name="Kimberly", hand=mock_hand1)
player2 = Player(name="Debbie", hand=mock_hand2)
players = [player1, player2]
self.assertEqual(max(players), player2)
def test_bet_round_invalid_bet_dictionary_with_dealer(self):
bets = {
"player-1": 400,
"player-2": 1000
}
game_players = GamePlayers([
Player("player-1", "Player One", 1000.0),
Player("player-2", "Player Two", 1000.0),
Player("player-3", "Player Three", 1000.0),
Player("player-4", "Player Four", 1000.0),
])
def bet_function_mock(player, min_bet, max_bet, bets):
return -1
bet_rounder = GameBetRounder(game_players)
self.assertRaises(ValueError, bet_rounder.bet_round, "player-4", bets, bet_function_mock)
def test_bet_round_everyone_call(self):
player1 = Player("player-1", "Player One", 1000.0)
player2 = Player("player-2", "Player Two", 1000.0)
player3 = Player("player-3", "Player Three", 1000.0)
player4 = Player("player-4", "Player Four", 1000.0)
game_players = GamePlayers([player1, player2, player3, player4])
def bet_function_mock(player, min_bet, max_bet, bets):
return min_bet
bet_rounder = GameBetRounder(game_players)
best_player = bet_rounder.bet_round("player-3", {"player-1": 300, "player-2": 600}, bet_function_mock)
self.assertEquals("player-3", best_player.id)
self.assertTrue(game_players.is_active("player-1"))
self.assertTrue(game_players.is_active("player-2"))
self.assertTrue(game_players.is_active("player-3"))
self.assertTrue(game_players.is_active("player-4"))
def init_hand():
n_players = 5
table = Table(n_players)
player1, player2, player3, player4, player5 = (Player(500) for _ in range(n_players))
player1.sit(table, 100)
player2.sit(table, 100)
player3.sit(table, 100)
player4.sit(table, 100)
player5.sit(table, 100)
hand = Hand(table)
return hand
def test_bet_round_no_players(self):
game_players = GamePlayers([
Player("player-1", "Player One", 500.0),
Player("player-2", "Player Two", 1000.0),
Player("player-3", "Player Three", 1000.0),
Player("player-4", "Player Four", 2000.0),
])
game_players.fold("player-1")
game_players.fold("player-2")
game_players.fold("player-3")
game_players.fold("player-4")
bet_rounder = GameBetRounder(game_players)
def bet_function_mock(player, min_bet, max_bet, bets):
return -1
bets = {}
self.assertRaises(GameError, bet_rounder.bet_round, "player-2", bets, bet_function_mock)
def _create_players(self, number):
names = Names()
self.hide_player_buttons()
self._root.update()
deck = CardDeck()
cards = Card.create_cards()
deck.add_cards(cards)
hand = Hand()
player = Player(f"Player", hand)
self._players.append(player)
human = Human(player=player, gui=self)
for i in range(number):
hand = Hand()
# player = Player(f"Opponent {i + 1}", hand)
player = Player(names.get_random_name(), hand)
self._players.append(player)
ai = AI(player=player)
self.hide_player_buttons()
for player in self._players:
player.add_chips(60)
game = GameRound(players=self._players, deck=deck, gui=self)
# game.set_game_qty(game_qty=10)
game.set_game_qty(infinite=True)
game.play()
self.stop()
def test_sort_players_with_Pair_in_correct_order(self):
two_of_clubs = Card(rank="2", suit="Clubs")
two_of_hearts = Card(rank="2", suit="Hearts")
king_of_clubs = Card(rank="King", suit="Clubs")
ten_of_clubs = Card(rank="10", suit="Clubs")
queen_of_diamonds = Card(rank="Queen", suit="Diamonds")
queen_of_hearts = Card(rank="Queen", suit="Hearts")
cards1 = [king_of_clubs, two_of_clubs, two_of_hearts]
cards2 = [ten_of_clubs, queen_of_diamonds, queen_of_hearts]
mock_hand1 = MagicMock()
mock_hand2 = MagicMock()
mock_hand1.best_rank.return_value = (8, "Pair", cards1)
mock_hand2.best_rank.return_value = (8, "Pair", cards2)
player1 = Player(name="Kimberly", hand=mock_hand1)
player2 = Player(name="Debbie", hand=mock_hand2)
players = [player1, player2]
self.assertEqual(max(players), player2)
def test_jam(table):
player1 = Player(table.bot, "player1")
player1.bankroll = table.max_buyin
player2 = Player(table.bot, "player2")
player2.bankroll = table.max_buyin
table.add_player(player1)
table.buyin(player1)
table.add_player(player2)
table.buyin(player2)
table.deck.reseed(True)
table.dealer.start_session(True)
player1.intent = Jam()
player2.intent = Jam()
table.dealer.act()
assert player1.total_action == 1000
assert player2.total_action == 1000
assert player1.total_winnings == 2000
assert player2.total_winnings == 0
def test_game(table):
player1 = Player(table.bot, "player1")
player1.bankroll = table.max_buyin
player2 = Player(table.bot, "player2")
player2.bankroll = table.max_buyin
table.add_player(player1)
table.buyin(player1)
table.add_player(player2)
table.buyin(player2)
table.dealer.start_session(True)
player1.intent = Fold()
table.dealer.act()
assert player1.total_action == 15
assert player2.total_action == 30
assert player1.total_winnings == 0
assert player2.total_winnings == 45
