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)
