naja/tests/test_actions.py

   1 from unittest import TestCase
   2
   3 from naja.constants import BITS
   4 from naja.gameboard import GameBoard, LocationCard
   5 from naja.player import Player
   6 from naja import actions
   7
   8
   9 class TestActions(TestCase):
  10     def make_player(self, *bits):
  11         player_bits = 0
  12         for bit in bits:
  13             player_bits |= (1 << bit)
  14         return Player(player_bits, None)
  15
  16     def make_board(self, player_bits=None, locations=None):
  17         if locations is 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)
  23         return board
  24
  25     def assert_player_bits(self, board, *bits):
  26         self.assertEqual(sum(1 << bit for bit in bits), board.player.bits.bits)
  27
  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)
  32
  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)
  39
  40         self.assertEqual(state1, state2)
  41
  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)
  47
  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)
  52
  53     def test_get_text(self):
  54         class LocationAction1(actions.LocationAction):
  55             TEXT = "foo"
  56         action1 = LocationAction1([])
  57         self.assertEqual(action1.get_text(), "foo")
  58
  59         class LocationAction2(actions.LocationAction):
  60             TEXT = "foo %(bar)s"
  61         action2 = LocationAction2([], bar="baz")
  62         self.assertEqual(action2.get_text(), "foo baz")
  63
  64     def test_get_text_row_column(self):
  65         class DirectionAction(actions.LocationAction):
  66             TEXT = "foo %(direction)s %(rowcol)s"
  67
  68         action_north = DirectionAction([], direction='NORTH')
  69         self.assertEqual(action_north.get_text(), "foo NORTH column")
  70
  71         action_south = DirectionAction([], direction='SOUTH')
  72         self.assertEqual(action_south.get_text(), "foo SOUTH column")
  73
  74         action_east = DirectionAction([], direction='EAST')
  75         self.assertEqual(action_east.get_text(), "foo EAST row")
  76
  77         action_west = DirectionAction([], direction='WEST')
  78         self.assertEqual(action_west.get_text(), "foo WEST row")
  79
  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]))
  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(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(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(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(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(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(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(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'])