1 from unittest import TestCase
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
10 class TestActions(TestCase):
14 def make_player(self, *bits):
17 player_bits |= (1 << bit)
18 return Player(player_bits, None)
20 def make_board(self, player_bits=None, locations=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)
29 def assert_player_bits(self, board, *bits):
30 self.assertEqual(sum(1 << bit for bit in bits), board.player.bits.bits)
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)
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)
44 self.assertEqual(state1, state2)
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)
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)
57 def test_get_text(self):
58 class LocationAction1(actions.LocationAction):
60 action1 = LocationAction1([])
61 self.assertEqual(action1.get_text(), "foo")
63 class LocationAction2(actions.LocationAction):
65 action2 = LocationAction2([], bar="baz")
66 self.assertEqual(action2.get_text(), "foo baz")
68 def test_get_text_row_column(self):
69 class DirectionAction(actions.LocationAction):
70 TEXT = "foo %(direction)s %(rowcol)s"
72 action_north = DirectionAction([], direction='NORTH')
73 self.assertEqual(action_north.get_text(), "foo {NORTH} column")
75 action_south = DirectionAction([], direction='SOUTH')
76 self.assertEqual(action_south.get_text(), "foo {SOUTH} column")
78 action_east = DirectionAction([], direction='EAST')
79 self.assertEqual(action_east.get_text(), "foo {EAST} row")
81 action_west = DirectionAction([], direction='WEST')
82 self.assertEqual(action_west.get_text(), "foo {WEST} row")
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)
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'])
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'])
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()
114 board.player.bits.check_bits([BITS.MSB, BITS.NORTH]), True)
115 self.assert_state(state_before, state_after, player_exclude=['bits'])
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'])
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)
136 state_before, state_after, exclude=['health'],
137 player_exclude=['bits'])
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'])
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'])
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)
166 state_before, state_after, exclude=['wins'],
167 player_exclude=['bits'])
169 def test_GainHealthAndClearBitsOrMSB_MSB_clear(self):
170 board = self.make_board(player_bits=[BITS.NORTH])
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)
179 state_before, state_after, exclude=['health'],
180 player_exclude=['bits'])
182 def test_GainHealthAndClearBitsOrMSB_MSB_set(self):
183 board = self.make_board(player_bits=[BITS.MSB, BITS.NORTH])
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)
192 state_before, state_after, exclude=['health'],
193 player_exclude=['bits'])
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)
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)
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)