def test_fromdict(self):
"""Given a dictionary as created by asdict(), fromdict()
should deserialize the Player object.
"""
hands = (cards.Hand((
cards.Card(11, 3),
cards.Card(2, 1),
)), )
exp = players.Player(hands, 'spam', 200)
exp.will_buyin = MethodType(players.will_buyin_always, exp)
exp.will_double_down = MethodType(players.will_double_down_always, exp)
exp.will_hit = MethodType(players.will_hit_dealer, exp)
exp.will_insure = MethodType(players.will_insure_always, exp)
exp.will_split = MethodType(players.will_split_always, exp)
value = {
'class': 'Player',
'chips': 200,
'hands': hands,
'insured': 0,
'name': 'spam',
'will_buyin': 'will_buyin_always',
'will_double_down': 'will_double_down_always',
'will_hit': 'will_hit_dealer',
'will_insure': 'will_insure_always',
'will_split': 'will_split_always',
}
act = players.Player.fromdict(value)
self.assertEqual(exp, act)
def test_has_decision_methods(self):
"""The players created by make_player() should have the
decision methods for Players, such as will_hit and
will_insure.
"""
# As long as no exception is raised, this test passes.
phand = cards.Hand([
cards.Card(11, 3),
cards.Card(1, 2),
])
dhand = cards.Hand([
cards.Card(11, 3),
cards.Card(1, 2),
])
dealer = players.Dealer((dhand, ), 'Dealer')
g = game.Engine(None, dealer, None, None, 2)
player = players.make_player()
methods = [
player.will_hit,
player.will_split,
player.will_double_down,
]
for method in methods:
_ = method(phand, g)
methods = [
player.will_buyin,
player.will_insure,
]
for method in methods:
_ = method(g)
def test_fromdict_methods(self):
"""Given a dictionary as created by asdict(), fromdict()
should deserialize the Player object.
"""
exp = MethodType
hands = (cards.Hand((
cards.Card(11, 3),
cards.Card(2, 1),
)), )
value = {
'class': 'Player',
'chips': 200,
'hands': hands,
'insured': 0,
'name': 'spam',
'will_buyin': 'will_buyin_always',
'will_double_down': 'will_double_down_always',
'will_hit': 'will_hit_dealer',
'will_insure': 'will_insure_always',
'will_split': 'will_split_always',
}
methods = [key for key in value if key.startswith('will_')]
player = players.Player.fromdict(value)
for method in methods:
act = getattr(player, method)
self.assertIsInstance(act, exp)
def test_serialize(self):
"""When called, serialize() should return the object
serialized as a JSON string.
"""
hands = (cards.Hand((
cards.Card(11, 3),
cards.Card(2, 1),
)), )
exp = json.dumps({
'class': 'Player',
'chips': 200,
'hands': (hands[0].serialize(), ),
'insured': 0,
'name': 'spam',
'will_buyin': 'will_buyin_always',
'will_double_down': 'will_double_down_always',
'will_hit': 'will_hit_dealer',
'will_insure': 'will_insure_always',
'will_split': 'will_split_always',
})
player = players.Player(hands, 'spam', 200)
player.will_buyin = MethodType(players.will_buyin_always, player)
player.will_double_down = MethodType(players.will_double_down_always,
player)
player.will_hit = MethodType(players.will_hit_dealer, player)
player.will_insure = MethodType(players.will_insure_always, player)
player.will_split = MethodType(players.will_split_always, player)
act = player.serialize()
self.assertEqual(exp, act)
def test_serialize(self):
"""When called, serialize() should return the Pile object
serialized to a JSON string.
"""
exp = json.dumps({
'class':
'Pile',
'_iter_index':
0,
'cards': [
'["Card", 11, "clubs", true]',
'["Card", 12, "clubs", true]',
'["Card", 13, "clubs", true]',
]
})
cardlist = [
cards.Card(11, 0, True),
cards.Card(12, 0, True),
cards.Card(13, 0, True),
]
pile = cards.Pile(cardlist)
act = pile.serialize()
self.assertEqual(exp, act)
def test_hand_updates(self, mock_update):
"""The methods tested should send _update_hand a player,
hand, and event text for display to the user.
"""
player = players.Player(name='spam')
hand = cards.Hand([
cards.Card(11, 3),
cards.Card(1, 0),
])
events = [
'Dealt hand.',
'Flip.',
'Hit.',
'Stand.',
]
exp = [call(player, hand, event) for event in events]
ui = cli.LogUI()
ui.deal(player, hand)
ui.flip(player, hand)
ui.hit(player, hand)
ui.stand(player, hand)
act = mock_update.mock_calls
self.assertListEqual(exp, act)
def test__asdict(self):
"""When called, asdict() should serialize the object to a
dictionary.
"""
hands = (cards.Hand((
cards.Card(11, 3),
cards.Card(2, 1),
)), )
exp = {
'class': 'Player',
'chips': 200,
'hands': hands,
'insured': 0,
'name': 'spam',
'will_buyin': 'will_buyin_always',
'will_double_down': 'will_double_down_always',
'will_hit': 'will_hit_dealer',
'will_insure': 'will_insure_always',
'will_split': 'will_split_always',
}
player = players.Player(hands, 'spam', 200)
player.will_buyin = MethodType(players.will_buyin_always, player)
player.will_double_down = MethodType(players.will_double_down_always,
player)
player.will_hit = MethodType(players.will_hit_dealer, player)
player.will_insure = MethodType(players.will_insure_always, player)
player.will_split = MethodType(players.will_split_always, player)
act = player._asdict()
self.assertEqual(exp, act)
def test_serialize(self):
"""When called, serialize() should return the Deck object
serialized as a JSON string.
"""
exp = json.dumps({
'class':
'Deck',
'_iter_index':
0,
'cards': [
'["Card", 11, "clubs", true]',
'["Card", 12, "clubs", true]',
'["Card", 13, "clubs", true]',
],
'size':
1
})
cardlist = [
cards.Card(11, 0, True),
cards.Card(12, 0, True),
cards.Card(13, 0, True),
]
deck = cards.Deck(cardlist)
act = deck.serialize()
self.assertEqual(exp, act)
def test_serialize(self):
"""When called, serialize() should return the object
serialized as a JSON string.
"""
exp = json.dumps({
'class':
'Hand',
'_iter_index':
0,
'cards': [
'["Card", 11, "clubs", true]',
'["Card", 12, "clubs", true]',
'["Card", 13, "clubs", true]',
],
'doubled_down':
False,
})
cardlist = [
cards.Card(11, 0, True),
cards.Card(12, 0, True),
cards.Card(13, 0, True),
]
hand = cards.Hand(cardlist)
act = hand.serialize()
self.assertEqual(exp, act)
def test__update_bet_split(self, mock_main):
"""When is_split is True, _update_bet should update the split
row of the data table for the player.
"""
hands = [
cards.Hand([
cards.Card(11, 0),
]),
cards.Hand([
cards.Card(11, 3),
]),
]
player = players.Player(hands, name='spam', chips=100)
player2 = players.Player(name='eggs', chips=100)
new_data = [
[player, 100, 20, 'J♣', 'Splits hand.'],
[' \u2514\u2500', '', 20, 'J♠', 'Loses.'],
[player2, 100, 20, '3♣ 4♣', 'Takes hand.'],
]
exp = call().send(('update', new_data))
data = [
[player, 100, 20, 'J♣', 'Splits hand.'],
[' \u2514\u2500', '', '', 'J♠', ''],
[player2, 100, 20, '3♣ 4♣', 'Takes hand.'],
]
ui = cli.TableUI()
ui.ctlr.data = data
ui.start()
ui._update_bet(player, 20, 'Loses.', split=True)
act = mock_main.mock_calls[-1]
ui.end()
self.assertEqual(exp, act)
def test_hand_updates(self, mock_update_hand, _):
"""The tested methods should call the _update_hand() method
with the player, hand, and event text.
"""
player = players.Player(name='spam', chips=100)
hand = cards.Hand([
cards.Card(11, 0),
cards.Card(10, 3),
])
handstr = str(hand)
exp = [
call(player, hand, 'Takes hand.'),
call(player, hand, 'Flips card.'),
call(player, hand, 'Hits.'),
call(player, hand, 'Stands.'),
]
data = [
[player, 80, 20, '', ''],
]
ui = cli.TableUI()
ui.ctlr.data = data
ui.start()
ui.deal(player, hand)
ui.flip(player, hand)
ui.hit(player, hand)
ui.stand(player, hand)
act = mock_update_hand.mock_calls[-4:]
ui.end()
self.assertEqual(exp, act)
def test__update_hand_split(self, mock_main):
"""If sent a split hand, _update_hand() should update the
split row of the table.
"""
hands = [
cards.Hand([
cards.Card(11, 0),
]),
cards.Hand([
cards.Card(11, 3),
]),
]
player = players.Player(hands, name='spam', chips=100)
player2 = players.Player(name='eggs', chips=100)
new_data = [
[player, 100, 20, 'J♣', 'Splits hand.'],
[' \u2514\u2500', '', 20, 'J♠ 5♣', 'Hits.'],
[player2, 100, 20, '3♣ 4♣', 'Takes hand.'],
]
exp = call().send(('update', new_data))
data = [
[player, 100, 20, 'J♣', 'Splits hand.'],
[' \u2514\u2500', '', 20, 'J♠', 'Splits hand.'],
[player2, 100, 20, '3♣ 4♣', 'Takes hand.'],
]
ui = cli.TableUI()
ui.ctlr.data = data
ui.start()
hands[1].append(cards.Card(5, 0))
ui._update_hand(player, hands[1], 'Hits.')
act = mock_main.mock_calls[-1]
ui.end()
self.assertEqual(exp, act)
def test_cleanup(self, mock_main):
"""When called, cleanup() should clear the bet, hand, and
event field of every row in the data table, then send it to
the UI.
"""
hands = [
cards.Hand([
cards.Card(11, 0),
]),
cards.Hand([
cards.Card(11, 3),
]),
]
player = players.Player(hands, name='spam', chips=100)
player2 = players.Player(hands, name='eggs', chips=100)
new_data = [
[player, 100, '', '', ''],
[player2, 100, '', '', ''],
]
exp = call().send(('update', new_data))
data = [
[player, 100, 20, 'J♣', 'Splits hand.'],
[' \u2514\u2500', '', 20, 'J♠', 'Splits hand.'],
[player2, 100, 20, '3♣ 4♣', 'Takes hand.'],
]
ui = cli.TableUI()
ui.ctlr.data = data
ui.start()
ui.cleanup()
act = mock_main.mock_calls[-1]
self.assertEqual(exp, act)
def test_fromdict_invalid_method(self):
"""Given a dictionary as created by asdict(), fromdict()
should deserialize the Player object.
"""
exp = ValueError
hands = (cards.Hand((
cards.Card(11, 3),
cards.Card(2, 1),
)), )
dict_ = {
'class': 'Player',
'chips': 200,
'hands': hands,
'insured': 0,
'name': 'spam',
'will_buyin': 'will_buyin_always',
'will_double_down': 'will_double_down_always',
'will_hit': 'will_hit_dealer',
'will_insure': 'will_insure_always',
'will_split': 'will_split_always',
}
methkeys = [key for key in dict_ if key.startswith('will_')]
test = 'spam'
for key in methkeys:
test_dict = copy(dict_)
test_dict[key] = test
with self.assertRaises(exp):
act = players.Player.fromdict(test_dict)
def test___contains__(self):
"""Pile should implement the in operator."""
c1 = cards.Card(1, 0)
c2 = cards.Card(2, 0)
c3 = cards.Card(3, 0)
d = cards.Pile([c1, c2])
self.assertTrue(c1 in d)
self.assertFalse(c3 in d)
def test__astuple_deserialize(self):
"""The result of astuple() should be able to be used to create
a new instance of cards.Card with the same attributes.
"""
exp = cards.Card(11, 3, True)
serialized = exp._astuple()
act = cards.Card(*serialized[1:])
self.assertEqual(exp, act)
def test_can_split_true(self):
"""can_split() should return true if the hand can be split."""
cardlist = [
cards.Card(10, 0),
cards.Card(10, 2),
]
h = cards.Hand(cardlist)
actual = h.can_split()
self.assertTrue(actual)
def test_is_will_hit(self):
"""A will_hit function should accept a Player, a Hand, and a
Game objects.
"""
player = players.Player()
hand = cards.Hand([
cards.Card(11, 0),
cards.Card(11, 3),
])
g = game.Engine()
_ = willhit.will_hit_dealer(player, hand, g)
def test_can_split_false(self):
"""can_split() should return false if the hand cannot be
split.
"""
cardlist = [
cards.Card(10, 0),
cards.Card(11, 2),
]
h = cards.Hand(cardlist)
actual = h.can_split()
self.assertFalse(actual)
def test_is_blackjack_false_two_cards(self):
"""is_blackjack() should return false if the hand doesn't
equal 21.
"""
cardlist = [
cards.Card(11, 3),
cards.Card(4, 2),
]
h = cards.Hand(cardlist)
actual = h.is_blackjack()
self.assertFalse(actual)
def test_is_blackjack_true(self):
"""is_blackjack() should return true if the hand is a natural
blackjack.
"""
cardlist = [
cards.Card(11, 3),
cards.Card(1, 2),
]
h = cards.Hand(cardlist)
actual = h.is_blackjack()
self.assertTrue(actual)
def test_split_invalid(self):
"""If the hand cannot be split, split() should raise a
ValueError exception.
"""
expected = ValueError
h = cards.Hand([
cards.Card(11, 0),
cards.Card(2, 3),
])
with self.assertRaises(ValueError):
_ = h.split()
def test_valid(self):
"""Given a valid value, validate_cardtuple should normalize
and validate it then return the normalized value.
"""
exp = (
cards.Card(11, 3),
cards.Card(1, 1),
)
value = list(exp)
act = cards.validate_cardtuple(None, value)
self.assertEqual(exp, act)
def test_is_blackjack_false_three_cards(self):
"""is_blackjack() should return false if the hand has more
than two cards.
"""
cardlist = [
cards.Card(11, 3),
cards.Card(4, 2),
cards.Card(7, 3),
]
h = cards.Hand(cardlist)
actual = h.is_blackjack()
self.assertFalse(actual)
def test___ne__nonequality_test(self):
"""Card objects should compare for non equality based on their
rank and suit.
"""
c1 = cards.Card(2, 'hearts')
c2 = cards.Card(2, 'hearts')
c3 = cards.Card(11, 'clubs')
c4 = cards.Card(2, 'spades')
c5 = cards.Card(11, 'hearts')
self.assertFalse(c1 != c2)
self.assertTrue(c1 != c3)
self.assertTrue(c1 != c4)
self.assertTrue(c1 != c5)
def test_cards(self):
"""An instance of Pile should be able to hold cards in its
cards attribute.
"""
expected = (
cards.Card(1, 3),
cards.Card(2, 3),
cards.Card(3, 3),
)
d = cards.Pile(expected)
actual = d.cards
self.assertEqual(expected, actual)
def test___iter__(self):
"""__iter__() should return a copy of of the Pile object for
iteration.
"""
card_list = [
cards.Card(1, 0),
cards.Card(2, 0),
]
expected = cards.Pile(card_list)
actual = expected.__iter__()
self.assertEqual(expected, actual)
self.assertFalse(expected is actual)
def test_is_bust_false(self):
"""When called, is_bust() should return true if their are
possible scores under 21.
"""
exp = False
hand = cards.Hand((
cards.Card(1, 0),
cards.Card(1, 0),
cards.Card(1, 0),
))
act = hand.is_bust()
self.assertEqual(exp, act)
def test_is_bust(self):
"""When called, is_bust() should return true if the score of
the hand is over 21.
"""
exp = True
hand = cards.Hand((
cards.Card(11, 0),
cards.Card(11, 0),
cards.Card(11, 0),
))
act = hand.is_bust()
self.assertEqual(exp, act)
def test_stand_on_bust(self):
"""If the hand is bust, will_hit_dealer() should return
False.
"""
expected = willhit.STAND
h = cards.Hand([
cards.Card(11, 0),
cards.Card(4, 2),
cards.Card(11, 3),
])
actual = willhit.will_hit_dealer(None, h)
self.assertEqual(expected, actual)
