naja/tests/test_actions.py

   1 from unittest import TestCase
   2
   3 from naja.constants import BITS, MOVES
   4 from naja.gameboard import GameBoard, LocationCard
   5 from naja.options import parse_args
   6 from naja.player import Player
   7 from naja import actions
   8
   9
  10 class TestActions(TestCase):
  11     def setUp(self):
  12         parse_args([])
  13
  14     def make_player(self, *bits):
  15         player_bits = 0
  16         for bit in bits:
  17             player_bits |= (1 << bit)
  18         return Player(player_bits, None)
  19
  20     def make_board(self, player_bits=None, locations=None):
  21         if locations is None:
  22             locations = [{'card_name': 'card', 'actions': []}]
  23         board = GameBoard.new_game({'cards': locations})
  24         if player_bits is not None:
  25             board.player.bits.bits = 0
  26             board.player.bits.set_bits(player_bits)
  27         return board
  28
  29     def assert_player_bits(self, board, *bits):
  30         self.assertEqual(sum(1 << bit for bit in bits), board.player.bits.bits)
  31
  32     def assert_state(self, state1, state2, exclude=(), player_exclude=()):
  33         def filter_dict(source, exclude_keys):
  34             return dict((k, v) for k, v in source.items()
  35                         if k not in exclude_keys)
  36
  37         state1 = filter_dict(state1, exclude)
  38         if 'player' in state1:
  39             state1['player'] = filter_dict(state1['player'], player_exclude)
  40         state2 = filter_dict(state2, exclude)
  41         if 'player' in state2:
  42             state2['player'] = filter_dict(state2['player'], player_exclude)
  43
  44         self.assertEqual(state1, state2)
  45
  46     def test_check_available(self):
  47         def check_available(action_bits, player_bits, expected_result):
  48             action = actions.LocationAction(action_bits)
  49             player = self.make_player(*player_bits)
  50             self.assertEqual(action.check_available(player), expected_result)
  51
  52         check_available(set(), [], True)
  53         check_available(set(), [BITS.MSB], True)
  54         check_available(set([BITS.MSB]), [], False)
  55         check_available(set([BITS.MSB]), [BITS.MSB], True)
  56
  57     def test_get_text(self):
  58         class LocationAction1(actions.LocationAction):
  59             TEXT = "foo"
  60         action1 = LocationAction1([])
  61         self.assertEqual(action1.get_text(), "foo")
  62
  63         class LocationAction2(actions.LocationAction):
  64             TEXT = "foo %(bar)s"
  65         action2 = LocationAction2([], bar="baz")
  66         self.assertEqual(action2.get_text(), "foo baz")
  67
  68     def test_get_text_row_column(self):
  69         class DirectionAction(actions.LocationAction):
  70             TEXT = "foo %(direction)s %(rowcol)s"
  71
  72         action_north = DirectionAction([], direction='NORTH')
  73         self.assertEqual(action_north.get_text(), "foo {NORTH} column")
  74
  75         action_south = DirectionAction([], direction='SOUTH')
  76         self.assertEqual(action_south.get_text(), "foo {SOUTH} column")
  77
  78         action_east = DirectionAction([], direction='EAST')
  79         self.assertEqual(action_east.get_text(), "foo {EAST} row")
  80
  81         action_west = DirectionAction([], direction='WEST')
  82         self.assertEqual(action_west.get_text(), "foo {WEST} row")
  83
  84     def test_DoNothing(self):
  85         board = self.make_board()
  86         state_before = board.export()
  87         actions.DoNothing(set()).perform_action(board, None)
  88         state_after = board.export()
  89         self.assert_state(state_before, state_after)
  90
  91     def test_LoseHealthOrMSB_MSB_clear(self):
  92         board = self.make_board()
  93         state_before = board.export()
  94         actions.LoseHealthOrMSB(set()).perform_action(board, None)
  95         state_after = board.export()
  96         self.assertEqual(state_after['health'], state_before['health'] - 1)
  97         self.assert_state(state_before, state_after, exclude=['health'])
  98
  99     def test_LoseHealthOrMSB_MSB_set(self):
 100         board = self.make_board(player_bits=[BITS.MSB])
 101         state_before = board.export()
 102         actions.LoseHealthOrMSB(set()).perform_action(board, None)
 103         state_after = board.export()
 104         self.assertEqual(board.player.bits.check_bit(BITS.MSB), False)
 105         self.assert_state(state_before, state_after, player_exclude=['bits'])
 106
 107     def test_SetBits(self):
 108         board = self.make_board()
 109         state_before = board.export()
 110         card = LocationCard('card', set([BITS.MSB, BITS.NORTH]), [])
 111         actions.SetBits(set()).perform_action(board, card)
 112         state_after = board.export()
 113         self.assertEqual(
 114             board.player.bits.check_bits([BITS.MSB, BITS.NORTH]), True)
 115         self.assert_state(state_before, state_after, player_exclude=['bits'])
 116
 117     def test_ToggleBits(self):
 118         board = self.make_board(player_bits=[BITS.NORTH])
 119         state_before = board.export()
 120         card = LocationCard('card', set([BITS.MSB, BITS.NORTH]), [])
 121         actions.ToggleBits(set()).perform_action(board, card)
 122         state_after = board.export()
 123         self.assertEqual(board.player.bits.check_bit(BITS.MSB), True)
 124         self.assertEqual(board.player.bits.check_bit(BITS.NORTH), False)
 125         self.assert_state(state_before, state_after, player_exclude=['bits'])
 126
 127     def test_LoseHealthOrMSBAndSetBits_MSB_clear(self):
 128         board = self.make_board(player_bits=[])
 129         state_before = board.export()
 130         card = LocationCard('card', set([BITS.BLUE, BITS.NORTH]), [])
 131         actions.LoseHealthOrMSBAndSetBits(set()).perform_action(board, card)
 132         state_after = board.export()
 133         self.assertEqual(state_after['health'], state_before['health'] - 1)
 134         self.assert_player_bits(board, BITS.BLUE, BITS.NORTH)
 135         self.assert_state(
 136             state_before, state_after, exclude=['health'],
 137             player_exclude=['bits'])
 138
 139     def test_LoseHealthOrMSBAndSetBits_MSB_set(self):
 140         board = self.make_board(player_bits=[BITS.MSB])
 141         state_before = board.export()
 142         card = LocationCard('card', set([BITS.BLUE, BITS.NORTH]), [])
 143         actions.LoseHealthOrMSBAndSetBits(set()).perform_action(board, card)
 144         state_after = board.export()
 145         self.assert_player_bits(board, BITS.BLUE, BITS.NORTH)
 146         self.assert_state(state_before, state_after, player_exclude=['bits'])
 147
 148     def test_LoseHealthOrMSBAndSetBits_MSB_set_and_on_card(self):
 149         board = self.make_board(player_bits=[BITS.MSB])
 150         state_before = board.export()
 151         card = LocationCard('card', set([BITS.MSB, BITS.NORTH]), [])
 152         actions.LoseHealthOrMSBAndSetBits(set()).perform_action(board, card)
 153         state_after = board.export()
 154         self.assert_player_bits(board, BITS.MSB, BITS.NORTH)
 155         self.assert_state(state_before, state_after, player_exclude=['bits'])
 156
 157     def test_AcquireWinToken(self):
 158         board = self.make_board(
 159             player_bits=[BITS.RED, BITS.GREEN, BITS.BLUE])
 160         state_before = board.export()
 161         actions.AcquireWinToken(set()).perform_action(board, None)
 162         state_after = board.export()
 163         self.assertEqual(state_after['wins'], state_before['wins'] + 1)
 164         self.assertEqual(board.player.bits.bits, 0)
 165         self.assert_state(
 166             state_before, state_after, exclude=['wins'],
 167             player_exclude=['bits'])
 168
 169     def test_GainHealthAndClearBitsOrMSB_MSB_clear(self):
 170         board = self.make_board(player_bits=[BITS.NORTH])
 171         board.lose_health()
 172         state_before = board.export()
 173         card = LocationCard('card', set([BITS.BLUE, BITS.NORTH]), [])
 174         actions.GainHealthAndClearBitsOrMSB(set()).perform_action(board, card)
 175         state_after = board.export()
 176         self.assertEqual(state_after['health'], state_before['health'] + 1)
 177         self.assert_player_bits(board)
 178         self.assert_state(
 179             state_before, state_after, exclude=['health'],
 180             player_exclude=['bits'])
 181
 182     def test_GainHealthAndClearBitsOrMSB_MSB_set(self):
 183         board = self.make_board(player_bits=[BITS.MSB, BITS.NORTH])
 184         board.lose_health()
 185         state_before = board.export()
 186         card = LocationCard('card', set([BITS.BLUE, BITS.NORTH]), [])
 187         actions.GainHealthAndClearBitsOrMSB(set()).perform_action(board, card)
 188         state_after = board.export()
 189         self.assertEqual(state_after['health'], state_before['health'] + 1)
 190         self.assert_player_bits(board, BITS.NORTH)
 191         self.assert_state(
 192             state_before, state_after, exclude=['health'],
 193             player_exclude=['bits'])
 194
 195     def test_AllowKnightMove(self):
 196         board = self.make_board(player_bits=[BITS.RED, BITS.BLUE])
 197         actions.AllowChessMove(
 198             set([BITS.RED, BITS.BLUE]), chesspiece="KNIGHT"
 199         ).perform_action(board, None)
 200         self.assertEqual(board.player.movement_mode, MOVES.KNIGHT)
 201
 202     def test_AllowBishopMove(self):
 203         board = self.make_board(player_bits=[BITS.RED, BITS.BLUE])
 204         actions.AllowChessMove(
 205             set([BITS.RED, BITS.BLUE]), chesspiece="BISHOP"
 206         ).perform_action(board, None)
 207         self.assertEqual(board.player.movement_mode, MOVES.BISHOP)
 208
 209     def test_AllowCastleMove(self):
 210         board = self.make_board(player_bits=[BITS.RED, BITS.BLUE])
 211         actions.AllowChessMove(
 212             set([BITS.RED, BITS.BLUE]), chesspiece="CASTLE"
 213         ).perform_action(board, None)
 214         self.assertEqual(board.player.movement_mode, MOVES.CASTLE)