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())
