class TestPot(unittest.TestCase): """Do we have a fully functional pot object?""" def setUp(self): self.p0 = Player('p0', 100) self.p1 = Player('p1', 100) self.p2 = Player('p2', 100) self.p3 = Player('p3', 100) self.p4 = Player('p4', 100) self.p5 = Player('p5', 100) self.s0 = Seat('s0') self.s1 = Seat('s1') self.s2 = Seat('s2') self.s3 = Seat('s3') self.s4 = Seat('s4') self.s5 = Seat('s5') players = [self.p0, self.p1, self.p2, self.p3, self.p4, self.p5] seats = [self.s0, self.s1, self.s2, self.s3, self.s4, self.s5] self.table = Table(seats, 5, 10, 0) self.dealer = Dealer(self.table) self.table.dealer = self.dealer player = 0 for seat in seats: seat.player = players[player] seat.player.seat = seat seat.active = True seat.player.table = self.table player += 1 self.table.init_hand() def test_who_is_first_pre_flop(self): """Do we make the proper player act first pre-flop??""" self.dealer.deal_hole() self.assertTrue(self.table.seats[self.table.under_the_gun].player.action) def test_who_is_first_post_flop(self): """Do we make the proper player act first post-flop""" self.dealer.deal_hole() self.table.seats[self.table.under_the_gun].player.action = False self.dealer.deal() self.assertTrue(self.table.seats[self.table.first].player.action) def test_bet(self): """Can each player bet 50?""" self.dealer.deal_hole() i = 0 while i < 6: i += 1 for seat in self.table.pots[-1].seats: print(seat.player.name, seat.player.equity, seat.player.action) if seat.player.action: seat.player.bet(50) self.table.pots[-1].betting_round() break print(seat.player.name, seat.player.equity, seat.player.action) print(self.table.pots[-1].pot)
class TestDealer(unittest.TestCase): """Do we have a functioning Dealer?""" def setUp(self): self.p1 = Player('p1', 100) self.p2 = Player('p2', 100) self.p3 = Player('p3', 0) self.p4 = Player('p4', 100) self.s1 = Seat('s1') self.s2 = Seat('s2') self.s3 = Seat('s3') self.s4 = Seat('s4') players = [self.p1, self.p2, self.p3, self.p4] seats = [self.s1, self.s2, self.s3, self.s4] self.table = Table(seats, 5, 10, 0) self.dealer = Dealer(self.table) self.table.dealer = self.dealer player = 0 for seat in seats: seat.player = players[player] seat.player.seat = seat seat.active = True seat.player.table = self.table player += 1 def test_deal_hole(self): """can the dealer deal two cards to each player??""" self.table.seats[2].active = False self.table.init_hand() # only want the active players players = [] for seat in self.table.seats: if seat.active: players.append(seat.player) # active players should have cards for player in players: self.assertEqual(len(player.hole), 2) # inactive players shouldn't have cards self.assertEqual(len(self.table.seats[2].player.hole), 0)
class TestTable(unittest.TestCase): """Do we have a working table object?""" def setUp(self): self.p0 = Player('p0', 100) self.p1 = Player('p1', 100) self.p2 = Player('p2', 100) self.p3 = Player('p3', 100) self.p4 = Player('p4', 100) self.p5 = Player('p5', 100) self.s0 = Seat('s0') self.s1 = Seat('s1') self.s2 = Seat('s2') self.s3 = Seat('s3') self.s4 = Seat('s4') self.s5 = Seat('s5') players = [self.p0, self.p1, self.p2, self.p3, self.p4, self.p5] seats = [self.s0, self.s1, self.s2, self.s3, self.s4, self.s5] self.table = Table(seats, 5, 10, 0) self.dealer = Dealer(self.table) self.table.dealer = self.dealer player = 0 for seat in seats: seat.player = players[player] seat.player.seat = seat seat.active = True seat.player.table = self.table player += 1 def test_set_button(self): """can we randomly set the button for initial play on active seats only??""" self.table.seats[2].active = False self.table.set_button() a = self.table.button self.assertTrue(self.table.seats[self.table.button].active) self.table.set_button() b = self.table.button self.assertTrue(self.table.seats[self.table.small_blind].active) self.table.set_button() c = self.table.button self.assertTrue(self.table.seats[self.table.big_blind].active) self.table.set_button() d = self.table.button self.assertTrue(self.table.seats[self.table.under_the_gun].active) self.table.set_button() e = self.table.button self.assertTrue(self.table.seats[self.table.button].active) self.table.set_button() f = self.table.button self.assertTrue(self.table.seats[self.table.button].active) self.assertFalse(a == b and b == c and c == d and d == e and e == f) """can we set the button/blinds correctly head to head?""" self.table.seats[3].active = False self.table.seats[2].active = False self.table.seats[4].active = False self.table.seats[5].active = False self.table.set_button() self.assertEqual(self.table.button, self.table.small_blind) self.assertEqual(self.table.button, self.table.under_the_gun) self.assertFalse(self.table.button == self.table.big_blind) def test_button_move(self): """Can we move the button and the blinds appropriately?""" self.table.button = 5 self.table.small_blind = 0 self.table.big_blind = 1 self.table._button_move() self.assertEqual(self.table.button, 0) self.assertEqual(self.table.small_blind, 1) self.assertEqual(self.table.big_blind, 2) self.assertEqual(self.table.under_the_gun, 3) def test_skip_inactive(self): self.table.button = 5 self.table.small_blind = 0 self.table.big_blind = 1 self.s2.active = False self.table._button_move() self.assertFalse(self.table.big_blind == 2) def test_dead_sb(self): """if the big blind goes inactive do we get a dead small blind?""" self.s1.active = False self.p1.missed_big_blind = False self.table.button = 5 self.table.small_blind = 0 self.table.big_blind = 1 self.table._button_move() self.assertTrue(self.table.small_blind == 1) def test_button_move_head_to_head(self): """Can we move the blinds and button appropriately head to head?""" self.s2.active = False self.p2.missed_big_blind = True self.s3.active = False self.p3.missed_big_blind = True self.s4.active = False self.p4.missed_big_blind = True self.s5.active = False self.p5.missed_big_blind = True self.table.button = 2 self.table.small_blind = 3 self.table.big_blind = 0 self.table._button_move() self.assertEqual(self.table.button, 0) self.assertEqual(self.table.small_blind, 0) self.assertEqual(self.table.big_blind, 1) self.assertEqual(self.table.under_the_gun, 0) def test_set_missed_bb(self): """Do we set the players missed bb appropriately?""" self.table.button = 5 self.table.small_blind = 0 self.table.big_blind = 1 self.s2.active = False self.table._button_move() self.assertTrue(self.p2.missed_big_blind) self.assertFalse(self.p2.missed_small_blind) def test_set_missed_sb(self): """Do we set the players missed sb appropriatly?""" self.table.button = 0 self.table.small_blind = 1 self.table.big_blind = 3 self.s2.active = False self.p2.missed_big_blind = True self.table._button_move() self.assertTrue(self.p2.missed_small_blind) def test_buying_the_button(self): """first active seat between buttons and sb should buy the button, all others should be frozen""" self.table.button = 0 self.p1.missed_big_blind = True self.p2.missed_big_blind = True self.table.small_blind = 3 self.table.big_blind = 4 self.table._reset_blinds() self.assertTrue(self.table.bought_button == 1) self.assertTrue(self.p2.frozen) def test_button_buy_pays(self): """The bb and sb don't pay after a button buy""" self.table.button = 0 self.table.bought_button = 1 self.table.small_blind = 2 self.table.big_blind = 3 self.table._create_pot() self.assertTrue(self.p2.stack == 100) self.assertTrue(self.p3.stack == 100) self.assertTrue(self.p1.stack == 85) def test_create_pot(self): """ can we spawn a pot object properly? """ self.table.small_blind = 0 self.table.big_blind = 1 self.table.utg = 2 self.p0.missed_big_blind = True self.p4.missed_big_blind = True self.p4.missed_small_blind = True pot = self.table._create_pot() self.assertEqual(pot.pot, 40) self.assertEqual(len(self.table.pots), 1) self.assertEqual(pot.increment, self.table.big_blind_amount) def test_reset_players(self): """ Can we reset for a new hand??""" self.table.seats[0].player.equity = 50 self.table.seats[0].player.hole = [1, 2, 3] self.table._reset_players() self.assertTrue(self.table.seats[0].player.equity == 0) self.assertEqual(len(self.table.seats[0].player.hole), 0) def test_reset_frozen_seat(self): """ Can we reset dead button player to active""" self.table.seats[4].active = False self.table.seats[4].player.frozen = True self.table._reset_players() self.assertTrue(self.table.seats[4].active) self.assertFalse(self.table.seats[4].player.frozen) def test_remove_0_stack(self): """Does the table remove broke players at the start of a hand??""" self.setUp() self.table.seats[2].player.stack = 0 self.table._remove_0_stack() self.assertFalse(self.table.seats[2].active) def test_init_hand(self): """Does it all come together?""" self.p0.stack = 0 self.table.init_hand() self.assertTrue(self.table.pots[0].pot == 15) self.assertEqual(len(self.p1.hole), 2)
class TestAnalyzer(unittest.TestCase): def setUp(self): self.p0 = Player('p0', 100) self.p1 = Player('p1', 100) self.p2 = Player('p2', 100) self.p3 = Player('p3', 100) self.p4 = Player('p4', 100) self.p5 = Player('p5', 100) self.s0 = Seat('s0') self.s1 = Seat('s1') self.s2 = Seat('s2') self.s3 = Seat('s3') self.s4 = Seat('s4') self.s5 = Seat('s5') players = [self.p0, self.p1, self.p2, self.p3, self.p4, self.p5] seats = [self.s0, self.s1, self.s2, self.s3, self.s4, self.s5] self.table = Table(seats, 5, 10, 0) self.dealer = Dealer(self.table) self.table.dealer = self.dealer player = 0 for seat in seats: seat.player = players[player] seat.player.seat = seat seat.active = True seat.player.table = self.table player += 1 self.table.init_hand() self.dealer.deal() self.dealer.deal() self.dealer.deal() self.analyzer = Analyzer(self.table) def test_award(self): """can we award a single winner the entire pot?""" players = [self.p2] self.table.pots[0].pot = 100 self.p2.stack = 90 self.analyzer._award(players) self.assertEqual(self.p2.stack, 190) def test_award_multiple(self): """Can we pay out evenly to multiple winners?""" players = [self.p2, self.p3] self.table.pots[0].pot = 100 self.p2.stack = 50 self.p3.stack = 50 self.analyzer._award(players) self.assertEqual(self.p2.stack, 100) self.assertEqual(self.p3.stack, 100) def test_award_indivisible(self): """Can we properly pay pots that don't divide evenly?""" players = [self.p2, self.p3] self.table.first = 1 self.table.pots[0].pot = 105 self.p2.stack = 50 self.p3.stack = 50 self.analyzer._award(players) self.assertEqual(self.p2.stack, 105) self.assertEqual(self.p3.stack, 100) def test_compare(self): """can we determine the winning hand""" players = self.analyzer._setup() self.p0.hand = [0, 14, 12, 11, 10, 8] self.p1.hand = [1, 14, 12, 11, 8] self.p2.hand = [7, 8, 14] self.p3.hand = [7, 10, 2] self.p4.hand = [0] self.p5.hand = [0] result = self.analyzer._compare(players) expected = [self.p3] self.assertEqual(expected, result) def test_compare_multiple(self): """if there are multiple winners do we return all of them?""" players = self.analyzer._setup() self.p0.hand = [0, 14, 12, 11, 10, 8] self.p1.hand = [1, 14, 12, 11, 8] self.p2.hand = [7, 10, 2] self.p3.hand = [7, 10, 2] self.p4.hand = [0] self.p5.hand = [0] result = self.analyzer._compare(players) expected = [self.p2, self.p3] self.assertEqual(expected, result) def test_hi_card(self): """can we identify a hi card hand?""" players = self.analyzer._setup() self.p4.hole[0].value = 12 self.p4.hole[1].value = 11 self.p4.hole[2].value = 9 self.p4.hole[3].value = 14 self.p4.hole[4].value = 13 self.p4.hole[5].value = 3 self.p4.hole[6].value = 2 players = self.analyzer._order(players) self.analyzer._matching(players) expected = [0, 14, 13, 12, 11, 9] self.assertEqual(self.p4.hand, expected) def test_matching_hands(self): """can we find matching number hands eg. pairs through quads??""" players = self.analyzer._setup() # quads self.p0.hole[0].value = 14 self.p0.hole[1].value = 14 # boat self.p1.hole[0].value = 14 self.p1.hole[1].value = 13 # trips self.p2.hole[0].value = 14 self.p2.hole[1].value = 12 # two pair self.p3.hole[0].value = 12 self.p3.hole[1].value = 12 # pair self.p4.hole[0].value = 12 self.p4.hole[1].value = 11 self.p4.hole[2].value = 14 self.p4.hole[3].value = 14 self.p4.hole[4].value = 13 self.p4.hole[5].value = 3 self.p4.hole[6].value = 2 players = self.analyzer._order(players) self.analyzer._matching(players) # Do we have 4 A's with a K kicker? self.assertEqual(self.p0.hand, [7, 14, 13]) # Do we have a boat A's full of K's? self.assertEqual(self.p1.hand, [6, 14, 13]) # Do we have trip A's with K & Q kickers? self.assertEqual(self.p2.hand, [3, 14, 13, 12]) # Do we have 2 pair A's & Q's with a K kicker? self.assertEqual(self.p3.hand, [2, 14, 12, 13]) # Do we have a pair of A's with K, Q, J kickers? self.assertEqual(self.p4.hand, [1, 14, 13, 12, 11]) def test_straight(self ): """can we find the highest straight in a hand""" players = self.analyzer._setup() #p0 has a 6 high straight self.p0.hole[0].value = 8 self.p0.hole[1].value = 6 self.p0.hole[2].value = 5 self.p0.hole[3].value = 4 self.p0.hole[4].value = 3 self.p0.hole[5].value = 13 self.p0.hole[6].value = 2 #poor p1 hit the wheel self.p1.hole[0].value = 14 self.p1.hole[1].value = 11 self.analyzer._order(players) self.analyzer._straight(self.p0) self.analyzer._straight(self.p1) expected_0 = [4, 6] expected_1 = [4, 5] self.assertEqual(self.p0.hand, expected_0) self.assertEqual(self.p1.hand, expected_1) def test_flush(self): """Can we find a flush in the players' hands""" players = self.analyzer._setup() # a flush self.p0.hole[0].suit = "d" self.p0.hole[0].value = 2 self.p0.hole[1].suit = "d" self.p0.hole[1].value = 2 self.p0.hole[2].suit = "d" self.p0.hole[3].suit = "d" self.p0.hole[4].suit = "d" self.p0.hole[5].suit = "d" self.p0.hole[5].value = 5 self.p0.hole[6].suit = "d" self.p0.hole[6].value = 4 self.p1.hole[0].suit = "d" self.p1.hole[1].suit = "d" self.p1.hole[0].value = 14 self.p1.hole[1].value = 13 self.p1.hole[2].value = 12 self.p1.hole[3].value = 11 self.p1.hole[4].value = 10 players = self.analyzer._order(players) self.analyzer._flush(players) self.assertTrue(self.p0.hand) self.assertEqual(self.p0.hand[0], 5) self.assertEqual(len(self.p0.hand), 6) # p1 should be a straight flush expected = [8, 14] self.assertEqual(self.p1.hand, expected) def test_order(self): """Can we order the hands in a proper order, left to right""" players = self.analyzer._setup() players = self.analyzer._order(players) for player in players: for i in range(6): v1 = player.hole[i].value v2 = player.hole[i + 1].value self.assertTrue(v2 <= v1) def test_seven_cards(self): """Can we get a list of players in the hand with 7 cards in the hand""" players = self.analyzer._setup() for player in players: self.assertTrue(len(player.hole) == 7)