def test__is_royal_flush(self):
expected = Combination(
10, [Rank.Ace, Rank.King, Rank.Queen, Rank.Jack, Rank.r10])
sc = Suit.clubs
sd = Suit.diamonds
# when clubs
test_input = [
Card(Rank.Ace, sc),
Card(Rank.r10, sc),
Card(Rank.Queen, sc),
Card(Rank.Jack, sc),
Card(Rank.King, sc)
]
result = combination_finder.find(test_input)
self.assertEqual(expected.strength, result.strength)
self.assertEqual(expected.kickers, result.kickers)
# when diamonds
test_input = [
Card(Rank.Ace, sd),
Card(Rank.r10, sd),
Card(Rank.King, sd),
Card(Rank.Queen, sd),
Card(Rank.Jack, sd)
]
result = combination_finder.find(test_input)
self.assertEqual(expected.strength, result.strength)
self.assertEqual(expected.kickers, result.kickers)
def setUp(self):
self.zone = Zone()
self.card1 = Card()
self.card2 = Card()
self.card3 = Card()
def test_general(self):
self.engine.deck.pull_out = Mock(return_value=Card(SUIT.CLUBS, VALUE.SIX))
self.engine.init_game()
with self.subTest():
self.assertEqual(len(self.engine.bj_gametable.get_cards(self.user_1)), 2)
with self.subTest():
self.assertEqual(len(self.engine.bj_gametable.get_cards(self.user_2)), 2)
with self.subTest():
self.assertTrue(self.engine.is_inited)
with self.subTest():
self.assertEqual(self.engine.deck.pull_out.call_count, 4)
self.controller_1.make_turn = Mock(return_value=TURN.HIT_ME)
self.controller_2.make_turn = Mock(return_value=TURN.HIT_ME)
self.controller_1.update_table = Mock()
self.controller_2.update_table = Mock()
self.engine.one_tick()
with self.subTest():
self.controller_1.make_turn.assert_called_once()
with self.subTest():
self.assertEqual(self.controller_1.update_table.call_count, 2)
with self.subTest():
self.controller_2.make_turn.assert_called_once()
with self.subTest():
self.assertEqual(self.controller_2.update_table.call_count, 2)
with self.subTest():
self.assertEqual(self.engine.deck.pull_out.call_count, 6)
with self.subTest():
self.assertFalse(self.engine.is_ended())
self.engine.deck.pull_out.side_effect = [Card(SUIT.CLUBS, VALUE.THREE),
Card(SUIT.CLUBS, VALUE.TWO),
Card(SUIT.CLUBS, VALUE.ACE)]
self.controller_1.make_turn.return_value = TURN.HIT_ME
self.controller_2.make_turn.side_effect = [TURN.HIT_ME, TURN.HIT_ME]
self.engine.one_tick()
with self.subTest():
self.assertEqual(self.engine.bj_gametable.get_status(self.user_1), UserStatus.BLACKJACK)
with self.subTest():
self.assertEqual(self.engine.bj_gametable.get_status(self.user_2), UserStatus.IN_GAME)
with self.subTest():
self.assertFalse(self.engine.is_ended())
self.controller_1.outcome_notify = Mock()
self.controller_2.outcome_notify = Mock()
self.engine.one_tick()
with self.subTest():
self.assertEqual(self.controller_1.make_turn.call_count + 1,
self.controller_2.make_turn.call_count)
with self.subTest():
self.assertTrue(self.engine.is_ended())
self.engine.outcomes_notify(self.engine.generate_outcomes())
with self.subTest():
self.controller_1.outcome_notify.assert_called_once_with(21, GameOutcome.DRAW)
with self.subTest():
self.controller_2.outcome_notify.assert_called_once_with(21, GameOutcome.DRAW)
def test_registration(self):
"""
Make sure that assigning IDs works.
"""
card1 = Card()
card2 = Card()
zone1 = Zone()
zone2 = Zone()
self.assertIsNone(card1.game_id)
self.assertIsNone(card2.game_id)
self.assertIsNone(zone1.game_id)
self.assertIsNone(zone2.game_id)
# Make sure we can assign ids to a set of cards
self.game.register((card1, card2))
self.assertEqual(card1.game_id, 1)
self.assertEqual(card2.game_id, 2)
# Make sure we can access the objects from the game
self.assertEqual(self.game.get_object_with_id("Card", 1), card1)
self.assertEqual(self.game.get_object_with_id("Card", 2), card2)
# Make sure that we don't change ids if the id
# is already there.
self.game.register((card2, card1))
self.assertEqual(card1.game_id, 1)
self.assertEqual(card2.game_id, 2)
# Make sure that we assign different ids to different
# classes.
self.game.register((zone1, zone2))
self.assertEqual(zone1.game_id, 1)
self.assertEqual(zone2.game_id, 2)
# Make sure we can access the objects from the game
self.assertEqual(self.game.get_object_with_id("Zone", 1), zone1)
self.assertEqual(self.game.get_object_with_id("Zone", 2), zone2)
# Make sure we know what to do on edge cases
self.assertIsNone(self.game.get_object_with_id("Zone", 3))
self.game.register([])
def test_init(self):
card_1 = Card(2, 'b')
assert card_1.color == 'b'
assert card_1.number == 2
assert card_1.public_number == None
assert card_1.public_color == None
assert card_1.in_your_hand == False
def test_init(self):
card_1 = Card(2, 'b')
assert card_1.color == 'b'
assert card_1.number == 2
self.assertIsNone(card_1.public_number)
self.assertIsNone(card_1.public_color)
self.assertIs(card_1.in_your_hand, False)
def test_init(self):
card_1 = Card(2, 'b')
your_card_1 = YourCard(card_1)
self.assertIs(your_card_1.number, False)
self.assertIs(your_card_1.color, False)
self.assertIsNone(your_card_1.public_number)
self.assertIsNone(your_card_1.public_color)
self.assertIs(your_card_1.in_your_hand, True)
def test_init(self):
card_1 = Card(2, 'b')
your_card_1 = YourCard(card_1)
assert your_card_1.number == False
assert your_card_1.color == False
assert your_card_1.public_number == None
assert your_card_1.public_color == None
assert your_card_1.in_your_hand == True
def test_cannot_make_public(self):
card_1 = Card(2, 'b')
your_card_1 = YourCard(card_1)
with pytest.raises(Exception) as excinfo:
your_card_1.make_public("color")
assert str(
excinfo.value
) == "Cannot make YourCards public because actual attributes are hidden."
def test_both_enough(self):
self.game_table.add_card(self.user_1, Card(SUIT.HEARTS, VALUE.KING))
self.game_table.add_card(self.user_2, Card(SUIT.HEARTS, VALUE.ACE))
self.game_table.set_status(self.user_1, UserStatus.ENOUGH)
self.game_table.set_status(self.user_2, UserStatus.ENOUGH)
with self.subTest():
self.assertListEqual(self.game_table.get_active_users(), [])
with self.subTest():
self.assertEqual(self.game_table.get_user_score(self.user_1), 10)
with self.subTest():
self.assertEqual(self.game_table.get_user_score(self.user_2), 11)
with self.subTest():
self.assertListEqual(self.game_table.get_users(),
[self.user_1, self.user_2])
def create_card_from_dict(card_def):
"""
This is a simple function that will make a card from a dictionary of
attributes.
"""
card = Card()
for attribute in card_def:
setattr(card, attribute, card_def[attribute])
return card
def test_deck_correctness(self):
deck = Deck(shuffle=True, is_small=False)
cards = [deck.pull_out() for _ in range(52)]
with self.subTest():
with self.assertRaises(EmptyDeckException):
deck.pull_out()
with self.subTest():
sorted_cards = []
for suit in SUIT:
for value in VALUE:
sorted_cards.append(Card(suit, value))
self.assertNotEqual(cards, sorted_cards)
def test_made_public_both(self):
card_1 = Card(2, 'b')
card_1.make_public('color')
card_1.make_public('number')
your_card_1 = YourCard(card_1)
assert your_card_1.public_color == 'b'
assert your_card_1.public_number == 2
def create_playing_card(suit, number):
card = Card()
card.suit = suit
card.number = number
card.front_face = img_location + get_file_name(suit, number)
card.back_face = img_location + "b1fv.png"
return card
def test_get_state_with_player_data(self):
"""
If we set attributes that are specifc to player make sure we can
get the state for that player.
"""
expected_state = {
'cards': [{
'face_up': False,
'game_id': 1,
'zone': None
}],
'players': [{
'game_id': 1,
'zones': {}
}],
'zones': []
}
player_expected_state = {
'cards': [{
'face_up': True,
'game_id': 1,
'zone': None
}],
'players': [{
'game_id': 1,
'zones': {}
}],
'zones': []
}
card = Card()
self.game.register([card])
card.set_value("face_up", True, self.player)
self.assertDictEqual(expected_state, self.game.get_state())
self.assertDictEqual(player_expected_state,
self.game.get_state(self.player.game_id))
def test_make_action_substitution(self):
"""
Makes sure that make action actually makes proper substitutions
depending on variable name.
"""
card = Card()
zone = Zone()
self.game.register([card, zone])
self.game.make_action('test_argument_types',
card=card.game_id,
zone=zone.game_id,
player=self.player.game_id)
def test_user_status(self):
with self.subTest():
self.assertEqual(self.game_table.get_status(self.user_1),
UserStatus.IN_GAME)
with self.subTest():
self.assertEqual(self.game_table.get_status(self.user_2),
UserStatus.IN_GAME)
with self.subTest():
self.game_table.add_card(self.user_1, Card(SUIT.DIAMONDS,
VALUE.ACE))
self.game_table.add_card(self.user_1,
Card(SUIT.DIAMONDS, VALUE.JACK))
self.assertEqual(self.game_table.get_status(self.user_1),
UserStatus.BLACKJACK)
with self.subTest():
self.game_table.add_card(self.user_2, Card(SUIT.HEARTS, VALUE.TEN))
self.game_table.add_card(self.user_2, Card(SUIT.HEARTS,
VALUE.JACK))
self.game_table.add_card(self.user_2, Card(SUIT.HEARTS, VALUE.TWO))
self.assertEqual(self.game_table.get_status(self.user_2),
UserStatus.LOSE)
def test_shuffle(self):
"""
Test shuffling the cards.
"""
for _ in range(0, 100):
self.zone.add_card(Card())
temp = self.zone.get_cards()[:]
self.zone.shuffle()
# Make sure cards were shuffled and that we didn't lose any
self.assertFalse(temp == self.zone.get_cards())
self.assertEqual(len(temp), len(self.zone.get_cards()))
def __init__(self,
colors=('r', 'y', 'g', 'w', 'b'),
numbers=(1, 1, 1, 2, 2, 3, 3, 4, 4, 5),
seed=None):
if len(colors) < 1:
raise ValueError("Decks must have at least one card color.")
if len(numbers) < 1:
raise ValueError("Decks must have at least one card number.")
self.card_colors = colors
self.card_numbers = numbers
self.card_list = []
for color in self.card_colors:
for number in self.card_numbers:
self.card_list.append(Card(number, color))
def __init__(self,
colors=('r', 'y', 'g', 'w', 'b'),
numbers=(1, 1, 1, 2, 2, 3, 3, 4, 4, 5),
seed=None):
self.card_colors = colors
self.card_numbers = numbers
self.card_list = []
for color in self.card_colors:
for number in self.card_numbers:
self.card_list.append(Card(number, color))
if seed:
Random(seed).shuffle(self.card_list)
else:
shuffle(self.card_list)
def test_deregister(self):
"""
Make sure that we can properly deregister objects.
"""
player = Player()
card = Card()
zone = Zone()
other = GameObject()
unregistered = GameObject()
self.game.register([player, card, zone, other])
self.game.deregister([player, card, zone, other, unregistered])
print self.game.registered_objects
self.assertEqual(self.game.registered_objects["Player"][0], 2)
self.assertEqual(self.game.registered_objects["Card"][0], 1)
self.assertEqual(self.game.registered_objects["Zone"][0], 1)
self.assertEqual(self.game.registered_objects["GameObject"][0], 1)
def test_forbid_add_card_when_unactive(self):
with self.subTest():
self.game_table.add_card(self.user_1, Card(SUIT.HEARTS,
VALUE.KING))
self.game_table.add_card(self.user_1, Card(SUIT.HEARTS, VALUE.TEN))
self.game_table.set_status(self.user_1, UserStatus.ENOUGH)
with self.assertRaises(WrongRightsException):
self.game_table.add_card(self.user_1,
Card(SUIT.HEARTS, VALUE.TWO))
with self.subTest():
self.game_table.add_card(self.user_2, Card(SUIT.HEARTS,
VALUE.KING))
self.game_table.add_card(self.user_2, Card(SUIT.HEARTS, VALUE.TEN))
self.game_table.add_card(self.user_2, Card(SUIT.HEARTS, VALUE.TWO))
with self.assertRaises(WrongRightsException):
self.game_table.add_card(self.user_2,
Card(SUIT.HEARTS, VALUE.TWO))
def get_card_by_id(card_id):
card = Card(card_id, cards['name'][card_id], cards['element'][card_id],
cards['force'][card_id], cards['image_path'][card_id])
return card
def test_eq_false_color(self):
card_1 = Card(1, 'y')
card_2 = Card(1, 'b')
assert card_1 != card_2
def test_eq_false_number(self):
card_1 = Card(1, 'y')
card_2 = Card(2, 'y')
assert card_1 != card_2
def test_eq_true_despite_public(self):
card_1 = Card(1, 'g')
card_2 = Card(1, 'g')
card_2.make_public('color')
assert card_1 == card_2
def test_cannot_make_public(self):
card_1 = Card(2, 'b')
your_card_1 = YourCard(card_1)
with pytest.raises(Exception):
your_card_1.make_public("color")
def test_make_public_color(self):
card_1 = Card(5, 'b')
card_1.make_public('color')
assert card_1.public_color == 'b'
def test_make_public_number(self):
card_1 = Card(3, 'y')
card_1.make_public('number')
assert card_1.public_number == 3
def test_make_public_invalid_input(self):
card_1 = Card(1, 'g')
with pytest.raises(ValueError):
card_1.make_public('flavor')
