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_bits_translation(self):
54 action = actions.LocationAction(set([BITS.NORTH, 'MSB']))
55 self.assertEqual(action.required_bits, set([BITS.NORTH, BITS.MSB]))
57 def test_DoNothing(self):
58 board = self.make_board()
59 state_before = board.export()
60 actions.DoNothing(set()).perform_action(board, None)
61 state_after = board.export()
62 self.assert_state(state_before, state_after)
64 def test_LoseHealthOrMSB_MSB_clear(self):
65 board = self.make_board()
66 state_before = board.export()
67 actions.LoseHealthOrMSB(set()).perform_action(board, None)
68 state_after = board.export()
69 self.assertEqual(state_after['health'], state_before['health'] - 1)
70 self.assert_state(state_before, state_after, exclude=['health'])
72 def test_LoseHealthOrMSB_MSB_set(self):
73 board = self.make_board(player_bits=[BITS.MSB])
74 state_before = board.export()
75 actions.LoseHealthOrMSB(set()).perform_action(board, None)
76 state_after = board.export()
77 self.assertEqual(board.player.bits.check_bit(BITS.MSB), False)
78 self.assert_state(state_before, state_after, player_exclude=['bits'])
80 def test_SetBits(self):
81 board = self.make_board()
82 state_before = board.export()
83 card = LocationCard(set([BITS.MSB, BITS.NORTH]), [])
84 actions.SetBits(set()).perform_action(board, card)
85 state_after = board.export()
87 board.player.bits.check_bits([BITS.MSB, BITS.NORTH]), True)
88 self.assert_state(state_before, state_after, player_exclude=['bits'])
90 def test_ToggleBits(self):
91 board = self.make_board(player_bits=[BITS.NORTH])
92 state_before = board.export()
93 card = LocationCard(set([BITS.MSB, BITS.NORTH]), [])
94 actions.ToggleBits(set()).perform_action(board, card)
95 state_after = board.export()
96 self.assertEqual(board.player.bits.check_bit(BITS.MSB), True)
97 self.assertEqual(board.player.bits.check_bit(BITS.NORTH), False)
98 self.assert_state(state_before, state_after, player_exclude=['bits'])
100 def test_LoseHealthOrMSBAndSetBits_MSB_clear(self):
101 board = self.make_board(player_bits=[])
102 state_before = board.export()
103 card = LocationCard(set([BITS.CYAN, BITS.NORTH]), [])
104 actions.LoseHealthOrMSBAndSetBits(set()).perform_action(board, card)
105 state_after = board.export()
106 self.assertEqual(state_after['health'], state_before['health'] - 1)
107 self.assert_player_bits(board, BITS.CYAN, BITS.NORTH)
109 state_before, state_after, exclude=['health'],
110 player_exclude=['bits'])
112 def test_LoseHealthOrMSBAndSetBits_MSB_set(self):
113 board = self.make_board(player_bits=[BITS.MSB])
114 state_before = board.export()
115 card = LocationCard(set([BITS.CYAN, BITS.NORTH]), [])
116 actions.LoseHealthOrMSBAndSetBits(set()).perform_action(board, card)
117 state_after = board.export()
118 self.assert_player_bits(board, BITS.CYAN, BITS.NORTH)
119 self.assert_state(state_before, state_after, player_exclude=['bits'])
121 def test_LoseHealthOrMSBAndSetBits_MSB_set_and_on_card(self):
122 board = self.make_board(player_bits=[BITS.MSB])
123 state_before = board.export()
124 card = LocationCard(set([BITS.MSB, BITS.NORTH]), [])
125 actions.LoseHealthOrMSBAndSetBits(set()).perform_action(board, card)
126 state_after = board.export()
127 self.assert_player_bits(board, BITS.MSB, BITS.NORTH)
128 self.assert_state(state_before, state_after, player_exclude=['bits'])
130 def test_AcquireWinToken(self):
131 board = self.make_board(
132 player_bits=[BITS.CYAN, BITS.MAGENTA, BITS.YELLOW, BITS.MSB])
133 state_before = board.export()
134 actions.AcquireWinToken(set()).perform_action(board, None)
135 state_after = board.export()
136 self.assertEqual(state_after['wins'], state_before['wins'] + 1)
137 self.assertEqual(board.player.bits.bits, 0)
139 state_before, state_after, exclude=['wins'],
140 player_exclude=['bits'])