1 from unittest import TestCase
3 from naja.constants import BITS
4 from naja.gameboard import GameBoard, LocationCard
5 from naja.player import Player
6 from naja import actions
9 class TestActions(TestCase):
10 def make_player(self, *bits):
13 player_bits |= (1 << bit)
14 return Player(player_bits, None)
16 def make_board(self, player_bits=None, locations=None):
18 locations = [{'actions': []}]
19 board = GameBoard.new_game(locations)
20 if player_bits is not None:
21 board.player.bits.bits = 0
22 board.player.bits.set_bits(player_bits)
25 def assert_player_bits(self, board, *bits):
26 self.assertEqual(sum(1 << bit for bit in bits), board.player.bits.bits)
28 def assert_state(self, state1, state2, exclude=(), player_exclude=()):
29 def filter_dict(source, exclude_keys):
30 return dict((k, v) for k, v in source.items()
31 if k not in exclude_keys)
33 state1 = filter_dict(state1, exclude)
34 if 'player' in state1:
35 state1['player'] = filter_dict(state1['player'], player_exclude)
36 state2 = filter_dict(state2, exclude)
37 if 'player' in state2:
38 state2['player'] = filter_dict(state2['player'], player_exclude)
40 self.assertEqual(state1, state2)
42 def test_check_available(self):
43 def check_available(action_bits, player_bits, expected_result):
44 action = actions.LocationAction(action_bits)
45 player = self.make_player(*player_bits)
46 self.assertEqual(action.check_available(player), expected_result)
48 check_available(set(), [], True)
49 check_available(set(), [BITS.MSB], True)
50 check_available(set([BITS.MSB]), [], False)
51 check_available(set([BITS.MSB]), [BITS.MSB], True)
53 def test_get_text(self):
54 class LocationAction1(actions.LocationAction):
56 action1 = LocationAction1([])
57 self.assertEqual(action1.get_text(), "foo")
59 class LocationAction2(actions.LocationAction):
61 action2 = LocationAction2([], bar="baz")
62 self.assertEqual(action2.get_text(), "foo baz")
64 def test_get_text_row_column(self):
65 class DirectionAction(actions.LocationAction):
66 TEXT = "foo %(direction)s %(rowcol)s"
68 action_north = DirectionAction([], direction='NORTH')
69 self.assertEqual(action_north.get_text(), "foo NORTH column")
71 action_south = DirectionAction([], direction='SOUTH')
72 self.assertEqual(action_south.get_text(), "foo SOUTH column")
74 action_east = DirectionAction([], direction='EAST')
75 self.assertEqual(action_east.get_text(), "foo EAST row")
77 action_west = DirectionAction([], direction='WEST')
78 self.assertEqual(action_west.get_text(), "foo WEST row")
80 def test_bits_translation(self):
81 action = actions.LocationAction(set([BITS.NORTH, 'MSB']))
82 self.assertEqual(action.required_bits, set([BITS.NORTH, BITS.MSB]))
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(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(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(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(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(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(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(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'])