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_bits_translation(self):
  54         action = actions.LocationAction(set([BITS.NORTH, 'MSB']))
  55         self.assertEqual(action.required_bits, set([BITS.NORTH, BITS.MSB]))
  56
  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)
  63
  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'])
  71
  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'])
  79
  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()
  86         self.assertEqual(
  87             board.player.bits.check_bits([BITS.MSB, BITS.NORTH]), True)
  88         self.assert_state(state_before, state_after, player_exclude=['bits'])
  89
  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'])
  99
 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)
 108         self.assert_state(
 109             state_before, state_after, exclude=['health'],
 110             player_exclude=['bits'])
 111
 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'])
 120
 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'])
 129
 130     def test_AcquireWinToken(self):
 131         board = self.make_board(
 132             player_bits=[BITS.CYAN, BITS.MAGENTA, BITS.YELLOW])
 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)
 138         self.assert_state(
 139             state_before, state_after, exclude=['wins'],
 140             player_exclude=['bits'])
 141
 142     def test_GainHealthAndClearBitsOrMSB_MSB_clear(self):
 143         board = self.make_board(player_bits=[BITS.NORTH])
 144         board.lose_health()
 145         state_before = board.export()
 146         card = LocationCard(set([BITS.CYAN, BITS.NORTH]), [])
 147         actions.GainHealthAndClearBitsOrMSB(set()).perform_action(board, card)
 148         state_after = board.export()
 149         self.assertEqual(state_after['health'], state_before['health'] + 1)
 150         self.assert_player_bits(board)
 151         self.assert_state(
 152             state_before, state_after, exclude=['health'],
 153             player_exclude=['bits'])
 154
 155     def test_GainHealthAndClearBitsOrMSB_MSB_set(self):
 156         board = self.make_board(player_bits=[BITS.MSB, BITS.NORTH])
 157         board.lose_health()
 158         state_before = board.export()
 159         card = LocationCard(set([BITS.CYAN, BITS.NORTH]), [])
 160         actions.GainHealthAndClearBitsOrMSB(set()).perform_action(board, card)
 161         state_after = board.export()
 162         self.assertEqual(state_after['health'], state_before['health'] + 1)
 163         self.assert_player_bits(board, BITS.NORTH)
 164         self.assert_state(
 165             state_before, state_after, exclude=['health'],
 166             player_exclude=['bits'])