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