def get_next(self):
assert self._current_game
assert self.has_next
result = {}
cur_move = self._current_game['moves'][self._current_move]
if self._current_table_index == self.INITIAL_CURRENT_TABLE_INDEX:
result = self._get_new_move(cur_move)
else:
mr_len = len(cur_move['moves_and_responds'])
if self._current_table_index < mr_len:
result['card'] = (DurakCard(
cur_move['moves_and_responds'][self._current_table_index]))
if self._current_table_index % 2:
to_move = self._get_opposite_player(cur_move['to_move'])
event_type = self.RESPOND
else:
to_move = cur_move['to_move']
event_type = self.MOVE
result['to_move'] = to_move
result['event_type'] = event_type
else:
result['event_type'] = self.GIVE_MORE
result['card'] = DurakCard(
cur_move['given_more'][self._current_table_index - mr_len])
result['to_move'] = cur_move['to_move']
self._increment()
return result
def test_cards_property(self):
cards = [DurakCard('6H'), DurakCard('7H'), DurakCard('8H')]
card_values = [Mock(), Mock(), Mock()]
self.panel._cards = OrderedDict(zip(cards, card_values))
self.assertEqual(self.panel.cards, cards)
def test_remove_card_does_layout_if_do_layout_is_true(self):
self.sizer._buttons_dict = {DurakCard('6H'): Mock()}
with patch.object(self.sizer, 'Detach'):
with patch.object(self.sizer, 'Layout') as Layout_mock:
self.sizer.remove_card(DurakCard('6H'), do_layout=True)
self.assertTrue(Layout_mock.called)
def test_card_groups_not_including_trumps(self):
card_set = CardSet(['7H', '8S', '8C', '9C', '6H', '6C', '6D'],
self.trump)
self.assertEqual(card_set.card_groups(including_trumps=False), [
{DurakCard('6C'), DurakCard('6D')},
{DurakCard('8S'), DurakCard('8C')},
])
def test_cards_that_can_beat_trump_including_trumps(self):
card_set = CardSet(['7H', 'KH', 'AH', '6S', 'TS', 'QS', '8D', 'AC'],
self.trump)
self.assertEqual(card_set.cards_that_can_beat('TH'), [
DurakCard('KH'),
DurakCard('AH'),
])
def test_pop_if_no_given_more(self):
card_mock = Mock()
self.panel._cards[DurakCard('6H')] = card_mock
self.assertEqual(self.panel.pop(), DurakCard('6H'))
self.assertDictEqual(self.panel._cards, {})
card_mock.Destroy.assert_called()
def test_on_table_property(self):
controller = GameController()
controller._on_table = [
DurakCard('6S'), DurakCard('6H'),
DurakCard('8S')
]
self.assertEqual(controller.on_table, controller._on_table)
def test_deal_with_no_response(self):
controller = GameController()
controller._trump = DurakCard('6H')
controller._state = controller.States.DEALING
controller._no_response = True
controller._discarded = []
controller._to_move = controller._player1
controller._player1.cards = {DurakCard('JH')}
controller._player2.cards = set()
controller._deck = []
controller._on_table = Table([DurakCard('6S'), DurakCard('6H')])
controller._on_table.given_more = {DurakCard('7S'), DurakCard('7H')}
controller._logger_enabled = False
controller.deal()
self.assertItemsEqual(controller._player2.cards, {
DurakCard('6S'),
DurakCard('6H'),
DurakCard('7S'),
DurakCard('7H')
})
self.assertFalse(controller._no_response)
self.assertEqual(controller._to_move, controller._player1)
self.assertEqual(controller._state, controller.States.MOVING)
def test_init_accepts_cards_and_trump(self):
cards = [DurakCard('7', 'S'), 'TD', DurakCard('KC')]
card_set = CardSet(cards, self.trump)
self.assertEqual(card_set._trump, self.trump)
self.assertItemsEqual(
card_set, {DurakCard('7S'),
DurakCard('TD'),
DurakCard('KC')})
def test_durak_card_instances_are_immutable(self):
card = DurakCard('7', 'S')
with self.assertRaises(AttributeError):
card.rank = '8'
with self.assertRaises(AttributeError):
card.suit = 'D'
def test_give_more_converts_output_to_cards(self):
self.process.stdout.readline.return_value = '8H 9H'
results = self.wrapper.give_more([DurakCard('7H')])
self.assertItemsEqual(results, [DurakCard('8H'), DurakCard('9H')])
self.process.stdin.write.assert_called_once_with('give_more 7H\n')
self.assertTrue(self.process.stdout.readline.called)
def test_move_returns_none_if_no_output_given(self):
self.process.stdout.readline.return_value = ''
result = self.wrapper.move([DurakCard('7H'), DurakCard('8H')])
self.assertTrue(result is None)
self.process.stdin.write.assert_called_once_with('move 7H 8H\n')
self.assertTrue(self.process.stdout.readline.called)
def test_disable_all(self):
self.sizer._buttons_dict = {
DurakCard('6H'): Mock(), DurakCard('7H'): Mock()
}
self.sizer.disable_all()
for button in self.sizer._buttons_dict.itervalues():
self.assertTrue(button.Disable.called)
def test_respond_converts_output_to_card(self):
self.process.stdout.readline.return_value = '8H'
result = self.wrapper.respond([DurakCard('7H')])
self.assertEqual(result, DurakCard('8H'))
self.process.stdin.write.assert_called_once_with('respond 7H\n')
self.assertTrue(self.process.stdout.readline.called)
def test_register_move_goes_to_responding_if_card_is_none(self):
controller = GameController()
controller._state = controller.States.MOVING
controller._on_table = [DurakCard('AC'), DurakCard('AH')]
controller.register_move(None)
self.assertEqual(controller._state, controller.States.DEALING)
def test_give_more_updates_given_more(self):
table = Table()
self.assertEqual(table.given_more, set())
cards = {DurakCard('AH'), DurakCard('6H')}
table.give_more(cards)
self.assertEqual(table.given_more, cards)
def test_durak_card_instances_are_immutable(self):
card = DurakCard('7', 'S')
with self.assertRaises(AttributeError):
card.rank = '8'
with self.assertRaises(AttributeError):
card.suit = 'D'
def test_str(self):
card = DurakCard('6', 'H')
self.assertEqual(str(card), '6H')
card = DurakCard('T', 'S')
self.assertEqual(str(card), 'TS')
card = DurakCard('A', 'D')
self.assertEqual(str(card), 'AD')
def test_sorted_cards_returns_trumps_last(self):
card_set = CardSet(['7H', '8S', 'TC', '9C', '6H'], self.trump)
self.assertEqual(card_set.sorted_cards(), [
DurakCard('8S'),
DurakCard('9C'),
DurakCard('TC'),
DurakCard('6H'),
DurakCard('7H'),
])
def test_pop_with_given_more(self):
card_mock = Mock()
self.panel._cards[DurakCard('6H')] = Mock()
self.panel._cards[DurakCard('7H')] = card_mock
self.panel._given_more = [DurakCard('7H')]
self.assertEqual(self.panel.pop(), DurakCard('7H'))
self.assertItemsEqual(self.panel._cards.keys(), [DurakCard('6H')])
card_mock.Destroy.assert_called()
def test_card_setter(self):
with patch('__builtin__.super'):
button = CardButton(parent=None, card=DurakCard('6H'))
with patch.object(button, 'SetBitmapLabel') as method_mock:
button.card = DurakCard('7S')
self.assertEqual(button._card, DurakCard('7S'))
method_mock.assert_called_once_with(
self._image_manager.get_image.return_value
)
def test_log_title(self):
self.logger.log_before_game(
'name1', 'name2', [DurakCard('6H')], DurakCard('7H')
)
self.logger.log_after_game(self.logger.PLAYER2)
self.assertEqual(
self.logger._log_title,
'%s, name1 - name2 (0-1)' % self.logger._log['started_at'].split('.')[0]
)
def test_cards_that_can_be_added_to_not_including_trumps(self):
card_set = CardSet(['7H', '7S', 'AH', 'AD', 'TS', 'QS', '8D', 'AC'],
self.trump)
results = card_set.cards_that_can_be_added_to(['9C', '7D', 'AS'],
including_trumps=False)
self.assertEqual(results, [
DurakCard('7S'),
DurakCard('AC'),
DurakCard('AD'),
])
def test_log_after_move(self):
self.logger._log['moves'].append({})
self.logger.log_after_move(
[DurakCard('6H'), DurakCard('7H')], {DurakCard('QH')}
)
self.assertEqual(len(self.logger._log['moves']), 1)
self.assertDictEqual(
self.logger._log['moves'][0],
{'moves_and_responds': ['6H', '7H'], 'given_more': ['QH']}
)
def test_remove_all_destroys_all_the_cards(self):
cards = [DurakCard('6H'), DurakCard('7H'), DurakCard('8H')]
card_values = [Mock(), Mock(), Mock()]
self.panel._cards = dict(zip(cards, card_values))
self.panel._give_more_mode = True
self.panel.remove_all()
self.assertTrue(all(card.Destroy.called for card in card_values))
self.assertEqual(self.panel._cards, {})
self.assertEqual(self.panel._given_more, [])
def test_remove_card_detaches_and_destroys_button(self):
button = Mock()
self.sizer._buttons_dict = {DurakCard('6H'): button}
with patch.object(self.sizer, 'Detach') as Detach_mock:
with patch.object(self.sizer, 'Layout') as Layout_mock:
self.sizer.remove_card(DurakCard('6H'))
Detach_mock.assert_called_once_with(button)
self.assertTrue(button.Destroy.called)
self.assertEqual(self.sizer._buttons_dict, {})
self.assertFalse(Layout_mock.called)
def test_register_move_is_error_if_player_does_have_this_card(self):
controller = GameController()
controller._state = controller.States.MOVING
controller._to_move = controller._player1
controller._trump = DurakCard('6H')
controller._player1.cards = CardSet(cards=(DurakCard('AC'),
DurakCard('AH')),
trump=controller._trump)
controller._on_table = []
with self.assertRaises(exes.PlayerDoesNotHaveCard):
controller.register_move(DurakCard('6D'))
def test_register_response_goes_to_giving_more_if_card_is_none(self):
controller = GameController()
controller._state = controller.States.RESPONDING
controller._to_move = controller._player1
controller._trump = DurakCard('6H')
controller._player1.cards = CardSet(cards=(DurakCard('AC'), ),
trump=controller._trump)
controller.register_response(None)
self.assertEqual(controller._state, controller.States.GIVING_MORE)
self.assertTrue(controller._no_response)
def test_get_image(self):
self.manager._data = {}
with patch('durak.gui.images.wx.Image') as wx_image_mock:
result = self.manager.get_image(DurakCard('6H'))
self.assertTrue(wx_image_mock.called)
self.assertEqual(result, self.manager._data[DurakCard('6H')])
wx_image_mock.reset_mock()
result = self.manager.get_image(DurakCard('6H'))
self.assertFalse(wx_image_mock.called)
self.assertEqual(result, self.manager._data[DurakCard('6H')])
def test_register_response_is_error_if_player_can_not_add_this_card(self):
controller = GameController()
controller._state = controller.States.RESPONDING
controller._to_move = controller._player2
controller._trump = DurakCard('6H')
controller._player1.cards = CardSet(cards=(DurakCard('AC'),
DurakCard('AH')),
trump=controller._trump)
controller._on_table = [DurakCard('6D')]
with self.assertRaises(exes.InvalidCard):
controller.register_response(DurakCard('AC'))
def test_set_enabled_cards_enables_certain_cards(self):
self.sizer._buttons_dict = {
DurakCard('6H'): Mock(), DurakCard('7H'): Mock()
}
self.sizer.set_enabled_cards({DurakCard('7H'), })
self.assertTrue(
self.sizer._buttons_dict[DurakCard('6H')].Disable.called
)
self.assertTrue(
self.sizer._buttons_dict[DurakCard('7H')].Enable.called
)
def test_start_new_game_players_and_deck_cards(self):
controller = GameController()
controller.start_new_game()
self.assertEqual(controller._trump, controller._deck[-1])
all_cards = []
all_cards.extend(controller._deck)
all_cards.extend(controller._player1.cards)
all_cards.extend(controller._player2.cards)
self.assertItemsEqual(all_cards, DurakCard.all())
def start_new_game(self, ignore_winner=True):
self._deck = list(DurakCard.all())
random.shuffle(self._deck)
self._trump = self._deck[-1]
self._logger.reset()
if self._logger_enabled:
self._logger.log_before_game(
self._player1.name,
self._player2.name,
self._deck,
self._trump
)
self._player1.cards = CardSet(cards=self._deck[:6], trump=self._trump)
self._player2.cards = CardSet(
cards=self._deck[6:12], trump=self._trump
)
self._deck = self._deck[12:]
if not ignore_winner and self._winner is not None:
self._to_move = self._winner
else:
self._to_move = self._get_first_to_move_by_trump()
self._winner = None
self._discarded = []
self._on_table = Table()
self._state = self.States.MOVING
self._no_response = False
if self._logger_enabled:
self._logger.log_before_move(
set(self._player1.cards),
set(self._player2.cards),
self.to_move,
self.deck_count,
)
return {
'player1_cards': CardSet(self._player1.cards, trump=self._trump),
'player2_cards': CardSet(self._player2.cards, trump=self._trump),
'trump': DurakCard(self._trump),
}
def _prepare_data(self):
wx_bitmap = (
wx.Image(self._image_path, wx.BITMAP_TYPE_GIF).ConvertToBitmap()
)
for card in DurakCard.all():
left_top_x = card.numeric_rank * self._card_width
left_top_y = card.numeric_suit * self._card_height
self._data[card] = wx_bitmap.GetSubBitmap(
(left_top_x, left_top_y, self._card_width, self._card_height)
)
hidden_bitmap = (
wx.Image(self._hidden_image_path, wx.BITMAP_TYPE_GIF)
.ConvertToBitmap()
)
self._data[self.HIDDEN] = hidden_bitmap
wx_bitmap.Destroy()
def test_start_new_game_cards_are_shuffled(self):
controller = GameController()
with patch('durak.controller.random') as random_mock:
controller.start_new_game()
random_mock.shuffle.assert_called_once_with(list(DurakCard.all()))
def test_all(self):
expected = set()
for rank in DurakCard.RANKS:
for suit in DurakCard.SUITS:
expected.add(DurakCard(rank, suit))
self.assertEqual(DurakCard.all(), expected)
