def setUp(self):
self.three_of_clubs = Card(rank = "3", suit = "Clubs")
self.three_of_diamonds = Card(rank = "3", suit = "Diamonds")
self.three_of_hearts = Card(rank = "3", suit = "Hearts")
self.three_of_spades = Card(rank = "3", suit = "Spades")
self.cards = [
Card(rank = "2", suit = "Clubs"),
self.three_of_clubs,
self.three_of_diamonds,
self.three_of_hearts,
self.three_of_spades,
Card(rank = "7", suit = "Hearts"),
Card(rank = "9", suit = "Spades")
]
def __init__(self, pocket_cards, table_cards):
"""
:type pocket_cards: list
:type table_cards: list
"""
self.pocket_cards = pocket_cards
self.table_cards = table_cards
self.kicker_cards = []
self.combination = None
self.combination_cards = []
self.kicker_cards = []
self.power_cards = []
self.power = 0
self.seven_cards = Card.sort_desc(self.table_cards + self.pocket_cards)
self.process()
def setUp(self):
self.four_of_diamonds = Card(rank="4", suit="Diamonds")
self.four_of_spades = Card(rank="4", suit="Spades")
self.four_of_hearts = Card(rank="4", suit="Hearts")
self.eight_of_hearts = Card(rank="8", suit="Hearts")
self.eight_of_clubs = Card(rank="8", suit="Clubs")
self.eight_of_spades = Card(rank="8", suit="Spades")
self.ten_of_hearts = Card(rank="10", suit="Hearts")
self.cards = [
self.four_of_diamonds, self.four_of_hearts, self.four_of_spades,
self.eight_of_clubs, self.eight_of_hearts, self.eight_of_spades,
self.ten_of_hearts
]
def test_determines_there_are_not_five_consectuive_cards_with_same_suit(
self):
cards = [
Card(rank="3", suit="Clubs"),
Card(rank="4", suit="Clubs"),
Card(rank="5", suit="Clubs"),
Card(rank="6", suit="Clubs"),
Card(rank="7", suit="Diamonds"),
Card(rank="King", suit="Clubs"),
Card(rank="Ace", suit="Diamonds")
]
validator = StraightFlushValidator(cards=cards)
self.assertEqual(validator.is_valid(), False)
def test_validates_that_cards_do_not_have_straight_flush_ending_in_ace(
self):
cards = [
Card(rank="2", suit="Spades"),
Card(rank="10", suit="Clubs"),
Card(rank="Jack", suit="Clubs"),
Card(rank="Queen", suit="Clubs"),
Card(rank="King", suit="Clubs"),
Card(rank="Ace", suit="Clubs"),
Card(rank="Ace", suit="Diamonds")
]
validator = RoyalFlushValidator(cards=cards)
self.assertEqual(validator.is_valid(), True)
def test_returns_five_straight_cards_with_same_rank_ending_in_ace(self):
ten = Card(rank="10", suit="Clubs")
jack = Card(rank="Jack", suit="Clubs")
queen = Card(rank="Queen", suit="Clubs")
king = Card(rank="King", suit="Clubs")
ace = Card(rank="Ace", suit="Clubs")
cards = [
Card(rank="2", suit="Spades"), ten, jack, queen, king, ace,
Card(rank="Ace", suit="Diamonds")
]
validator = RoyalFlushValidator(cards=cards)
self.assertEqual(validator.valid_cards(),
[ten, jack, queen, king, ace])
def setUp(self):
self.eight_of_clubs = Card(rank='8', suit='Clubs')
self.eight_of_diamonds = Card(rank='8', suit='Diamonds')
self.eight_of_hearts = Card(rank='8', suit='Hearts')
self.eight_of_spades = Card(rank='8', suit='Spades')
self.cards = [
self.eight_of_clubs,
self.eight_of_diamonds,
self.eight_of_hearts,
self.eight_of_spades,
Card(rank='10', suit='Hearts'),
Card(rank='King', suit='Clubs'),
Card(rank='Ace', suit='Spades')
]
def test_returns_five_consectuive_cards_with_same_suit(self):
three = Card(rank="3", suit="Clubs")
four = Card(rank="4", suit="Clubs")
five = Card(rank="5", suit="Clubs")
six = Card(rank="6", suit="Clubs")
seven = Card(rank="7", suit="Clubs")
cards = [
three, four, five, six, seven,
Card(rank="King", suit="Clubs"),
Card(rank="Ace", suit="Diamonds")
]
validator = StraightFlushValidator(cards=cards)
self.assertEqual(validator.valid_cards(),
[three, four, five, six, seven])
def test_validates_that_cards_do_not_have_straight_flush_ending_in_ace(
self):
cards = [
Card(rank="2", suit="Spades"),
Card(rank="10", suit="Clubs"),
Card(rank="Jack", suit="Clubs"),
Card(rank="Queen", suit="Clubs"),
Card(rank="King", suit="Clubs"),
Card(rank="Ace", suit="Clubs"),
Card(rank="Ace", suit="Diamonds")
]
# TODO: there is a bugh for straight if we have two cards with the same rank
valdiator = RoyalFlushValidator(cards=cards)
self.assertEqual(valdiator.is_valid(), True)
def setUp(self):
self.two_of_hearts = Card(rank="2", suit="Hearts")
self.five_of_hearts = Card(rank="5", suit="Hearts")
self.seven_of_hearts = Card(rank="7", suit="Hearts")
self.eight_of_hearts = Card(rank="8", suit="Hearts")
self.ten_of_hearts = Card(rank="10", suit="Hearts")
self.ace_of_hearts = Card(rank="Ace", suit="Hearts")
self.cards = [
self.two_of_hearts,
self.five_of_hearts,
self.seven_of_hearts,
self.eight_of_hearts,
self.ten_of_hearts,
Card(rank="Jack", suit="Clubs"),
self.ace_of_hearts
]
def test_straigh_flush_is_not_valid(self):
'''
straight flush occurs when
all rank are sequential and
suite is same
'''
cards = [
Card(rank="3", suite="clubs"),
Card(rank="4", suite="hearts"),
Card(rank="5", suite="hearts"),
Card(rank="6", suite="hearts"),
Card(rank="7", suite="hearts"),
Card(rank="8", suite="clubs"),
Card(rank="King", suite="hearts")
]
validator = StraightFlushValidator(cards=cards)
self.assertEqual(validator.is_valid(), False)
def setUp(self):
self.two_of_diamonds = Card(rank='2', suit='Diamonds')
self.three_of_diamonds = Card(rank='3', suit='Diamonds')
self.five_of_diamonds = Card(rank='5', suit='Diamonds')
self.seven_of_diamonds = Card(rank='7', suit='Diamonds')
self.eight_of_diamonds = Card(rank='8', suit='Diamonds')
self.queen_of_diamonds = Card(rank='Queen', suit='Diamonds')
self.cards = [
self.two_of_diamonds,
self.three_of_diamonds,
self.five_of_diamonds,
self.seven_of_diamonds,
self.eight_of_diamonds,
Card(rank='Jack', suit='Hearts'),
self.queen_of_diamonds
]
def setUp(self):
self.three_of_hearts = Card(rank="3", suite="hearts")
self.four_of_hearts = Card(rank="4", suite="hearts")
self.five_of_hearts = Card(rank="5", suite="hearts")
self.ten_of_hearts = Card(rank="10", suite="hearts")
self.ace_of_hearts = Card(rank="Ace", suite="hearts")
self.cards = [
self.three_of_hearts, self.four_of_hearts, self.five_of_hearts,
Card(rank="7", suite="clubs"), self.ten_of_hearts,
self.ace_of_hearts
]
def test_validates_that_cards_do_not_have_straight_flush_ending_in_ace(
self):
cards = [
Card(rank='9', suit='Diamonds'),
Card(rank='10', suit='Diamonds'),
Card(rank='Jack', suit='Diamonds'),
Card(rank='Queen', suit='Diamonds'),
Card(rank='King', suit='Diamonds'),
Card(rank='Ace', suit='Clubs')
]
validator = RoyalFlushValidator(cards=cards)
self.assertEqual(validator.is_valid(), False)
def test_validates_that_card_do_not_have_a_straight_flush_ending_with_an_ace(
self):
cards = [
Card(rank="9", suit="Clubs"),
Card(rank="10", suit="Clubs"),
Card(rank="Jack", suit="Clubs"),
Card(rank="Queen", suit="Clubs"),
Card(rank="King", suit="Clubs"),
Card(rank="Ace", suit="Diamonds"),
]
validator = RoyalFlushValidator(cards=cards)
self.assertEqual(validator.is_valid(), False)
def setUp(self):
self.seven_of_spades = Card(rank = "7", suit = "Spades")
self.eight_of_spades = Card(rank = "8", suit = "Spades")
self.nine_of_spades = Card(rank = "9", suit = "Spades")
self.ten_of_spades = Card(rank = "10", suit = "Spades")
self.jack_of_spades = Card(rank = "Jack", suit = "Spades")
self.queen_of_spades = Card(rank = "Queen", suit = "Spades")
self.king_of_clubs = Card(rank = "King", suit = "Clubs")
self.cards = [
self.seven_of_spades,
self.eight_of_spades,
self.nine_of_spades,
self.ten_of_spades,
self.jack_of_spades,
self.queen_of_spades,
self.king_of_clubs
]
def setUp(self):
self.three_of_clubs = Card(rank = "3", suit = "Clubs")
self.five_of_clubs = Card(rank = "5", suit = "Clubs")
self.six_of_clubs = Card(rank = "6", suit = "Clubs")
self.ten_of_clubs = Card(rank = "10", suit = "Clubs")
self.ace_of_clubs = Card(rank = "Ace", suit = "Clubs")
self.jack_of_hearts = Card(rank = "Jack", suit = "Hearts")
self.eight_of_clubs = Card(rank = "8", suit = "Clubs")
self.cards = [
self.three_of_clubs,
self.five_of_clubs,
self.six_of_clubs,
self.eight_of_clubs,
self.ten_of_clubs,
self.jack_of_hearts,
self.ace_of_clubs
]
def setUp(self):
two = Card(rank="2", suit="Spades")
six = Card(rank="6", suit="Hearts")
self.seven = Card(rank="7", suit="Diamonds")
self.eight = Card(rank="8", suit="Spades")
self.nine = Card(rank="9", suit="Clubs")
self.ten = Card(rank="10", suit="Clubs")
self.jack = Card(rank="Jack", suit="Hearts")
self.cards = [
two,
six,
self.seven,
self.eight,
self.nine,
self.ten,
self.jack
]
def setUp(self):
two_of_diamonds = Card(rank='2', suit='Diamonds')
six_of_diamonds = Card(rank='6', suit='Diamonds')
self.seven_of_clubs = Card(rank='7', suit='Clubs')
self.eight_of_spades = Card(rank='8', suit='Spades')
self.nine_of_spades = Card(rank='9', suit='Spades')
self.ten_of_clubs = Card(rank='10', suit='Clubs')
self.jack_of_spades = Card(rank='Jack', suit='Spades')
self.cards = [
two_of_diamonds,
six_of_diamonds,
self.seven_of_clubs,
self.eight_of_spades,
self.nine_of_spades,
self.ten_of_clubs,
self.jack_of_spades
]
def test_hands_value_vs_other_hand_value(self):
hand_a = [
Card("Ace", "Clubs"),
Card("Ace", "Diamonds"),
Card("2", "Clubs"),
Card("3", "Diamonds")
]
# hand_a_value = (20 * sum([13, 13])) + sum([13, 13, 1, 2])
# print(hand_a_value)
hand_b = [
Card("Ace", "Clubs"),
Card("Queen", "Diamonds"),
Card("10", "Clubs"),
Card("10", "Diamonds")
]
# hand_b_value = (20 * sum([10, 10])) + sum([13, 11, 10, 10])
# print(hand_b_value)
cards_a = Hand()
cards_a.add_cards(hand_a)
cards_b = Hand()
cards_b.add_cards(hand_b)
self.assertEqual(cards_a > cards_b, True)
def create_players(number):
deck = CardDeck()
cards = Card.create_cards()
deck.add_cards(cards)
hand = Hand()
player = Player(f"Player", hand)
players.append(player)
human = Human(player=player)
for i in range(number):
hand = Hand()
player = Player(f"Opponent {i}", hand)
players.append(player)
ai = AI(player=player)
hide_buttons()
for player in players:
player.add_chips(60)
game = GameRound(players=players, deck=deck)
# game.set_game_qty(game_qty=10)
game.set_game_qty(infinite=True)
game.play()
def setUp(self):
self.four_of_hearts = Card(rank = "4", suite = "hearts")
self.four_of_diamonds= Card(rank = "4", suite = "diamonds")
self.four_of_clubs = Card(rank = "4", suite = "clubs")
five_of_clubs = Card(rank = "5", suite = "clubs")
self.two_of_diamonds = Card(rank = "2", suite = "diamonds")
self.two_of_spades = Card(rank = "2", suite = "spades")
self.cards = [
self.two_of_diamonds,
self.two_of_spades,
self.four_of_clubs,
self.four_of_diamonds,
self.four_of_hearts,
five_of_clubs
]
class CardTest(unittest.TestCase):
def setUp(self):
self.low = Card(2, 0)
self.low2 = Card(2, 1)
self.high = Card(14, 2)
self.high2 = Card(14, 2)
def test_comparisons(self):
self.assertTrue(self.low < self.high)
self.assertTrue(self.high > self.low)
self.assertTrue(self.high == self.high2)
self.assertTrue(self.low <= self.high)
self.assertTrue(self.high >= self.low)
self.assertTrue(self.low != self.low2)
def test_rank_from_zero(self):
self.assertEqual(self.low.rank_from_zero(), 0)
self.assertEqual(self.high.rank_from_zero(), 12)
def test_rank_name(self):
self.assertEqual(self.low.rank_name(), 'Two')
self.assertEqual(self.high.rank_name(), 'Ace')
def test_suit_name(self):
self.assertEqual(self.low.suit_name(), 'Club')
self.assertEqual(self.high.suit_name(), 'Heart')
#maybe belongs in a different test class
def test_straights_by_high_rank(self):
self.assertEqual(straights_by_high_rank(2), [5, 6])
self.assertEqual(straights_by_high_rank(3), [5, 6, 7])
self.assertEqual(straights_by_high_rank(4), [5, 6, 7, 8])
self.assertEqual(straights_by_high_rank(5), [5, 6, 7, 8, 9])
self.assertEqual(straights_by_high_rank(6), [6, 7, 8, 9, 10])
self.assertEqual(straights_by_high_rank(7), [7, 8, 9, 10, 11])
self.assertEqual(straights_by_high_rank(8), [8, 9, 10, 11, 12])
self.assertEqual(straights_by_high_rank(9), [9, 10, 11, 12, 13])
self.assertEqual(straights_by_high_rank(10), [10, 11, 12, 13, 14])
self.assertEqual(straights_by_high_rank(11), [11, 12, 13, 14])
self.assertEqual(straights_by_high_rank(12), [12, 13, 14])
self.assertEqual(straights_by_high_rank(13), [13, 14])
self.assertEqual(straights_by_high_rank(14), [5, 14])
def test_bad_inputs(self):
self.assertRaises(CardError, Card, 100, 100)
def test_to_royal_flush_is_best_rank(self):
'''
royal flush occurs when
all rank are sequential and
suite is same and the last card is Ace
'''
cards = [
Card(rank = "9", suite = "hearts"),
Card(rank = "10", suite = "hearts"),
Card(rank = "Jack", suite = "hearts"),
Card(rank = "Queen", suite = "hearts"),
Card(rank = "King", suite = "hearts"),
Card(rank = "Ace", suite = "diamonds"),
]
validator = RoyalFlushValidator(cards= cards)
self.assertEqual(
validator.is_valid(),
False
)
def test_determines_that_there_are_five_consecutive_cards_with_the_same_suit(
self):
seven_of_diamonds = Card(rank='7', suit='Diamonds')
eight_of_diamonds = Card(rank='8', suit='Diamonds')
nine_of_diamonds = Card(rank='9', suit='Diamonds')
ten_of_diamonds = Card(rank='10', suit='Diamonds')
jack_of_diamonds = Card(rank='Jack', suit='Diamonds')
cards = [
seven_of_diamonds,
eight_of_diamonds,
nine_of_diamonds,
ten_of_diamonds,
jack_of_diamonds,
Card(rank='King', suit='Diamonds'),
Card(rank='Ace', suit='Clubs'),
]
validator = StraightFlushValidator(cards=cards)
self.assertEqual(validator.valid_cards(), [
seven_of_diamonds, eight_of_diamonds, nine_of_diamonds,
ten_of_diamonds, jack_of_diamonds
])
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_card(self):
card = Card(3, 2)
self.assertEquals(3, card.rank)
self.assertEquals(2, card.suit)
def test_pair_with_longer_sequence(self):
expected_category = HoldemPokerScore.PAIR
cards = [
Card(9, 0),
Card(8, 0),
Card(2, 2),
Card(3, 0),
Card(4, 3),
Card(13, 3),
Card(8, 3)
]
expected_cards = [
Card(8, 3),
Card(8, 0),
Card(13, 3),
Card(9, 0),
Card(4, 3)
]
self._test_detect(cards, expected_category, expected_cards)
def test_detect_full_houses_over_flush(self):
expected_category = HoldemPokerScore.FULL_HOUSE
cards = [
Card(8, 0),
Card(8, 1),
Card(8, 2),
Card(9, 0),
Card(9, 1),
Card(2, 3),
Card(3, 3),
Card(4, 3),
Card(5, 3),
Card(7, 3),
]
expected_cards = [
Card(8, 2),
Card(8, 1),
Card(8, 0),
Card(9, 1),
Card(9, 0)
]
self._test_detect(cards, expected_category, expected_cards)
def test_detect_shorter_sequence(self):
expected_category = HoldemPokerScore.TRIPS
cards = [Card(8, 0), Card(7, 3), Card(8, 1), Card(8, 2)]
expected_cards = [Card(8, 2), Card(8, 1), Card(8, 0), Card(7, 3)]
self._test_detect(cards, expected_category, expected_cards)
def test_detect_longer_sequence(self):
expected_category = TraditionalPokerScore.TRIPS
cards = [
Card(7, 0),
Card(7, 2),
Card(8, 0),
Card(7, 3),
Card(8, 1),
Card(8, 2),
Card(14, 0)
]
expected_cards = [
Card(8, 2),
Card(8, 1),
Card(8, 0),
Card(14, 0),
Card(7, 3)
]
self._test_detect(cards, expected_category, expected_cards)
def test_make_random_is_instance_of_Card_Rank_and_Suit():
card = Card.make_random()
assert isinstance(card, Card)
assert isinstance(card.rank, Rank)
assert isinstance(card.suit, Suit)
def setUp(self):
self.low = Card(2, 0)
self.low2 = Card(2, 1)
self.high = Card(14, 2)
self.high2 = Card(14, 2)
