def generate_deck(): deck = [] for suit in Suit: for rank in Rank: card = Card(rank, suit) deck.append(card) return deck
def __init__(self, deck_count): # Initializes the deck and adds a full set of cards self.deck_count = deck_count self.cards = [] for i in range(deck_count): for c in cards: for s in suits: self.cards.append(Card(c, s))
def test_available_actions_at_end_of_game(self): # Player has won. game = Game([]) game.player.add_card(Card(1, SUIT_SPADES)) game.player.add_card(Card(13, SUIT_SPADES)) self.assertEqual((), game.get_available_actions()) # Player has gone bust. game = Game([]) game.player.add_card(Card(10, SUIT_SPADES)) game.player.add_card(Card(10, SUIT_SPADES)) game.player.add_card(Card(10, SUIT_SPADES)) self.assertEqual((), game.get_available_actions())
def test_undetermined_cards(self): exposed = True values = [_] cards = [Card(_, values, _, exposed), Card(_, values, _, exposed)] undetermined_values = [1, 2] undetermined_cards = [ Card(_, undetermined_values, _, exposed), Card(_, undetermined_values, _, exposed) ] player = Player(_, _) player.cards.extend(cards + undetermined_cards) for card in undetermined_cards: self.assertTrue( all(card == undetermined_card for undetermined_card in player.undetermined_cards))
def test_expose_cards(self): exposed = False first_values = [1, 2] second_values = [3, 4] hidden_cards = [ Card(_, first_values, _, exposed), Card(_, second_values, _, exposed) ] exposed_cards = hidden_cards.copy() exposed_cards = [card.expose() for card in exposed_cards] player = Player(_, _) player.cards.extend(hidden_cards) player.expose_cards() self.assertEqual(player.cards, exposed_cards)
def create_deck(self): cards = [] values = [ '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A' ] for value in values: for x in range(4): cards.append(Card(value)) return cards
def generate_cards(self): ''' This method will create card elements ''' x = 0 for suit in ['diamond', 'heart', 'club', 'spade']: for rank in (list(range(2, 11)) + ['Jack', 'Queen', 'King', 'Ace']): self.cards[x] = Card(suit, rank) x += 1
def build_deck(self): """ Builds deck :return: list """ suits = ('Hearts', 'Diamonds', 'Spades', 'Clubs') for suit in suits: for i, val in enumerate( ('Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine', 'Ten', 'Jack', 'Queen', 'King', 'Ace')): if val in ['Jack', 'Queen', 'King']: self.deck.append(Card([suit, val, 10, True])) elif val in ['Ace ']: self.deck.append(Card([suit, val, 11, True])) else: self.deck.append(Card([suit, val, (i + 2), True])) return self.deck
def test_not_exposed(self): values = [_] exposed = False card = Card(_, values, _, exposed) hidden_str = '*' self.assertEqual(card.name, hidden_str) self.assertEqual(card.value, hidden_str) self.assertEqual(card.suit, hidden_str) self.assertIn(hidden_str, str(card))
def test_card_attributes(self): name = 'Ten' value = 1 values = [value] suit = 'Spades' exposed = True card = Card(name, values, suit, exposed) self.assertEqual(card.name, name) self.assertEqual(card.value, value) self.assertEqual(card.suit, suit)
def test_determine_points(self, _print_mock, get_answer_mock): exposed = True first_values = [1, 2] second_values = [3, 4] cards = [ Card(_, first_values, _, exposed), Card(_, second_values, _, exposed) ] def get_answer_select(value_list): return value_list[0] get_answer_mock.side_effect = get_answer_select player = Player(_, _) player.cards.extend(cards) player.determine_points() self.assertEqual( get_answer_mock.mock_calls, [call(first_values), call(second_values)])
def test_player_loses(self, _print_mock, ai_player_make_move_mock, player_make_move_mock, player_make_bet_mock, deal_start_cards_mock): player_cards = [ Card('One', [1], '♣', exposed=True), Card('One', [1], '♦', exposed=True), ] dealer_cards = [ Card('Ten', [10], '♣', exposed=True), Card('Ten', [10], '♦', exposed=False), ] def deal(self): for player in self.players: player.cards.extend(player_cards) self.dealer.cards.extend(dealer_cards) deal_start_cards_mock.side_effect = deal budget = 500 player = Player('Bob', budget) players = [player] dealer = AiPlayer('Dealer', 5000) bet = 100 def make_bet(self): self.current_bet = bet player_make_bet_mock.side_effect = make_bet stand = 'stand' player_make_move_mock.return_value = stand ai_player_make_move_mock.return_value = stand game = Game(players, dealer) game.single_game() self.assertEqual(player.budget, budget - bet)
def test_bust_hand_cannot_win(self): # Dealer is bust. game = Game([]) game.player.add_card(Card(5, SUIT_SPADES)) game.dealer.add_card(Card(10, SUIT_SPADES)) game.dealer.add_card(Card(10, SUIT_SPADES)) game.dealer.add_card(Card(10, SUIT_SPADES)) self.assertEqual(game.player, game.get_winner()) # Player is bust: dealer automatically wins. game = Game([]) game.player.add_card(Card(10, SUIT_SPADES)) game.player.add_card(Card(10, SUIT_SPADES)) game.player.add_card(Card(10, SUIT_SPADES)) game.dealer.add_card(Card(10, SUIT_SPADES)) game.dealer.add_card(Card(10, SUIT_SPADES)) game.dealer.add_card(Card(10, SUIT_SPADES)) self.assertEqual(game.dealer, game.get_winner())
def test_equality_fail_not_card(self): values = [_] first_exposed = True second_exposed = False class Temp: exposed = None name = None value = None suit = None def __init__(self, *_, **__): pass first_card = Card(_, values, _, first_exposed) second_card = Temp(_, values, _, second_exposed) self.assertNotEqual(first_card, second_card)
def test_blackjack_always_wins(self): # If a player has a blackjack (e.g. their two first cards total # 21 points) they automatically win. game = Game([]) game.player.add_card(Card(1, SUIT_SPADES)) game.player.add_card(Card(13, SUIT_SPADES)) game.dealer.add_card(Card(1, SUIT_SPADES)) game.dealer.add_card(Card(13, SUIT_SPADES)) self.assertEqual(game.player, game.get_winner()) # Player may have 21 points without having a blackjack. game = Game([]) game.player.add_card(Card(9, SUIT_SPADES)) game.player.add_card(Card(10, SUIT_SPADES)) game.player.add_card(Card(2, SUIT_SPADES)) game.dealer.add_card(Card(1, SUIT_SPADES)) game.dealer.add_card(Card(13, SUIT_SPADES)) self.assertIsNone(game.get_winner(), 'Game should be a draw')
def test_ace_calculation(): temp = Hand() temp.add(Card("A")) assert temp.has_ace() assert temp.value() == 11 temp.add(Card("A")) assert temp.value() == 12 temp = Hand() temp.add(Card("9")) temp.add(Card("A")) assert temp.value() == 20 temp.add(Card("A")) assert temp.value() == 21 temp.add(Card("A")) assert temp.value() == 12
def __init__(self): self.suits = ('Hearts', 'Diamonds', 'Spades', 'Clubs') self.ranks = { 'Two': 2, 'Three': 3, 'Four': 4, 'Five': 5, 'Six': 6, 'Seven': 7, 'Eight': 8, 'Nine': 9, 'Ten': 10, 'Jack': 10, 'Queen': 10, 'King': 10, 'Ace': 11 } self.cards = [] # Fill the deck with cards for suit in self.suits: for (k, v) in self.ranks.items(): self.cards.append(Card(k, v, suit))
def test_complete_dealers_hand(self): # Cards given to the player. players_cards = [ Card(1, SUIT_SPADES), Card(2, SUIT_SPADES), ] # Cards given to the dealer. dealers_cards = [ Card(3, SUIT_SPADES), Card(7, SUIT_SPADES), Card(8, SUIT_SPADES), ] deck = players_cards + dealers_cards + [ Card(9, SUIT_SPADES), ] with patch.object(Game, 'shuffle_deck', autospec=True): game = Game(deck) game.start() game.complete_dealers_hand() dealer = game.dealer self.assertEqual(dealers_cards, dealer.hand.cards)
def test_complete_dealers_hand_does_not_hit_on_hard_17(self): # Cards given to the player. players_cards = [ Card(4, SUIT_SPADES), Card(5, SUIT_SPADES), ] # Cards given to the dealer. dealers_cards = [ Card(10, SUIT_SPADES), Card(6, SUIT_SPADES), Card(1, SUIT_SPADES), ] deck = players_cards + dealers_cards + [ Card(9, SUIT_SPADES), ] with patch.object(Game, 'shuffle_deck', autospec=True): game = Game(deck) game.start() game.complete_dealers_hand() dealer = game.dealer self.assertEqual(dealers_cards, dealer.hand.cards, 'Dealer must not hit on a hard 17')
def __init__(self): self.cards = deque() for suit in Suit: for i in range(1, 14): self.cards.append(Card(rank=i, suit=suit)) shuffle(self.cards)
def test_winner_for_draws(self): game = Game([]) game.player.add_card(Card(10, SUIT_SPADES)) game.dealer.add_card(Card(10, SUIT_SPADES)) self.assertIsNone(game.get_winner())
def test_blackjack(): temp = Hand() temp.add(Card("A")) temp.add(Card("K")) assert temp.is_blackjack()
def test_deck_creation(self): expected_cards = [ Card(1, SUIT_CLUBS), Card(2, SUIT_CLUBS), Card(3, SUIT_CLUBS), Card(4, SUIT_CLUBS), Card(5, SUIT_CLUBS), Card(6, SUIT_CLUBS), Card(7, SUIT_CLUBS), Card(8, SUIT_CLUBS), Card(9, SUIT_CLUBS), Card(10, SUIT_CLUBS), Card(11, SUIT_CLUBS), Card(12, SUIT_CLUBS), Card(13, SUIT_CLUBS), Card(1, SUIT_DIAMONDS), Card(2, SUIT_DIAMONDS), Card(3, SUIT_DIAMONDS), Card(4, SUIT_DIAMONDS), Card(5, SUIT_DIAMONDS), Card(6, SUIT_DIAMONDS), Card(7, SUIT_DIAMONDS), Card(8, SUIT_DIAMONDS), Card(9, SUIT_DIAMONDS), Card(10, SUIT_DIAMONDS), Card(11, SUIT_DIAMONDS), Card(12, SUIT_DIAMONDS), Card(13, SUIT_DIAMONDS), Card(1, SUIT_HEARTS), Card(2, SUIT_HEARTS), Card(3, SUIT_HEARTS), Card(4, SUIT_HEARTS), Card(5, SUIT_HEARTS), Card(6, SUIT_HEARTS), Card(7, SUIT_HEARTS), Card(8, SUIT_HEARTS), Card(9, SUIT_HEARTS), Card(10, SUIT_HEARTS), Card(11, SUIT_HEARTS), Card(12, SUIT_HEARTS), Card(13, SUIT_HEARTS), Card(1, SUIT_SPADES), Card(2, SUIT_SPADES), Card(3, SUIT_SPADES), Card(4, SUIT_SPADES), Card(5, SUIT_SPADES), Card(6, SUIT_SPADES), Card(7, SUIT_SPADES), Card(8, SUIT_SPADES), Card(9, SUIT_SPADES), Card(10, SUIT_SPADES), Card(11, SUIT_SPADES), Card(12, SUIT_SPADES), Card(13, SUIT_SPADES), ] self.assertCountEqual(expected_cards, generate_deck())
def get_full_deck(): """ Returns whole deck """ cards = [ { 'name': 'Ace', 'value': [1, 11] }, { 'name': 'Two', 'value': [2] }, { 'name': 'Three', 'value': [3] }, { 'name': 'Four', 'value': [4] }, { 'name': 'Five', 'value': [5] }, { 'name': 'Six', 'value': [6] }, { 'name': 'Seven', 'value': [7] }, { 'name': 'Eight', 'value': [8] }, { 'name': 'Nine', 'value': [9] }, { 'name': 'Ten', 'value': [10] }, { 'name': 'Jack', 'value': [10] }, { 'name': 'Queen', 'value': [10] }, { 'name': 'King', 'value': [10] }, ] suits = ['♣', '♦', '♥', '♠'] return [ Card(card['name'], card['value'], suit) for card in cards for suit in suits ]
def reset_shoe(self): self.cards = [ Card(card) for card in VALID_CARDS * 4 * self.number_decks ] random.shuffle(self.cards)
def test_score_returns_ten_for_faces(self): hand = create_hand([ Card(11, SUIT_SPADES), Card(12, SUIT_SPADES), ]) self.assertEqual(20, hand.get_score())