Save player mode.

[naja.git] / naja / tests / test_gameboard.py

diff --git a/naja/tests/test_gameboard.py b/naja/tests/test_gameboard.py
index e3aa32e03be48a27e0da319219fa880e25491c77..ca031a33bee7c9e9b1a305e5f1a92c2ab2f4d859 100644 (file)
--- a/naja/tests/test_gameboard.py
+++ b/naja/tests/test_gameboard.py
@@ -1,11 +1,20 @@
 from unittest import TestCase
 
-from naja.constants import BITS, MOVES
+from naja.constants import BITS, MOVES, EXAMINE
 from naja.gameboard import GameBoard, LocationCard
+from naja.options import parse_args
 from naja import actions
 
 
 class TestGameBoard(TestCase):
+    def setUp(self):
+        parse_args([])
+
+    def make_deck(self, cards=None):
+        if cards is None:
+            cards = [{'actions': []}]
+        return {'cards': cards}
+
     def assert_state(self, state1, state2, exclude=(), player_exclude=()):
         def filter_dict(source, exclude_keys):
             return dict((k, v) for k, v in source.items()
@@ -21,7 +30,7 @@ class TestGameBoard(TestCase):
         self.assertEqual(state1, state2)
 
     def test_export_new_board(self):
-        board = GameBoard.new_game([{'actions': [
+        board = GameBoard.new_game({'cards': [{'actions': [
             {
                 'action_class': 'LoseHealthOrMSB',
                 'required_bits': [],
@@ -29,7 +38,7 @@ class TestGameBoard(TestCase):
                 'action_class': 'GainHealth',
                 'required_bits': [BITS.RED],
             },
-        ]}])
+        ]}]})
         exported_state = board.export()
         board_locations = exported_state.pop('board_locations')
         self.assertEqual(exported_state, {
@@ -47,6 +56,8 @@ class TestGameBoard(TestCase):
                 },
             ]}],
             'player': board.player.export(),
+            'puzzle': False,
+            'player_mode': EXAMINE,
         })
         positions = []
         for position, location_state in board_locations:
@@ -69,7 +80,7 @@ class TestGameBoard(TestCase):
             positions, sorted((x, y) for x in range(5) for y in range(5)))
 
     def test_lose_health(self):
-        board = GameBoard.new_game([{'actions': []}])
+        board = GameBoard.new_game(self.make_deck())
         self.assertEqual(board.health, 4)
         state_1 = board.export()
 
@@ -80,7 +91,7 @@ class TestGameBoard(TestCase):
         self.assert_state(state_1, state_2, exclude=['health'])
 
     def test_gain_health(self):
-        board = GameBoard.new_game([{'actions': []}])
+        board = GameBoard.new_game(self.make_deck())
         board.health = 2
         self.assertEqual(board.health, 2)
         state_1 = board.export()
@@ -92,7 +103,7 @@ class TestGameBoard(TestCase):
         self.assert_state(state_1, state_2, exclude=['health'])
 
     def test_gain_health_at_max(self):
-        board = GameBoard.new_game([{'actions': []}])
+        board = GameBoard.new_game(self.make_deck())
         self.assertEqual(board.health, 4)
         state_1 = board.export()
 
@@ -110,7 +121,7 @@ class TestGameBoard(TestCase):
         return locations_dict
 
     def test_shift_locations_north(self):
-        board = GameBoard.new_game([{'actions': []}])
+        board = GameBoard.new_game(self.make_deck())
         board.board_locations = self.generate_locations()
         board.shift_locations('NORTH')
         self.assertEqual(board.board_locations, self.generate_locations({
@@ -118,7 +129,7 @@ class TestGameBoard(TestCase):
         }))
 
     def test_shift_locations_south(self):
-        board = GameBoard.new_game([{'actions': []}])
+        board = GameBoard.new_game(self.make_deck())
         board.board_locations = self.generate_locations()
         board.shift_locations('SOUTH')
         self.assertEqual(board.board_locations, self.generate_locations({
@@ -126,7 +137,7 @@ class TestGameBoard(TestCase):
         }))
 
     def test_shift_locations_east(self):
-        board = GameBoard.new_game([{'actions': []}])
+        board = GameBoard.new_game(self.make_deck())
         board.board_locations = self.generate_locations()
         board.shift_locations('EAST')
         self.assertEqual(board.board_locations, self.generate_locations({
@@ -134,7 +145,7 @@ class TestGameBoard(TestCase):
         }))
 
     def test_shift_locations_west(self):
-        board = GameBoard.new_game([{'actions': []}])
+        board = GameBoard.new_game(self.make_deck())
         board.board_locations = self.generate_locations()
         board.shift_locations('WEST')
         self.assertEqual(board.board_locations, self.generate_locations({
@@ -142,7 +153,7 @@ class TestGameBoard(TestCase):
         }))
 
     def test_rotate_locations_clockwise(self):
-        board = GameBoard.new_game([{'actions': []}])
+        board = GameBoard.new_game(self.make_deck())
         board.board_locations = self.generate_locations()
         board.rotate_locations('CLOCKWISE')
         self.assertEqual(board.board_locations, self.generate_locations({
@@ -152,7 +163,7 @@ class TestGameBoard(TestCase):
         }))
 
     def test_rotate_locations_clockwise_top(self):
-        board = GameBoard.new_game([{'actions': []}], initial_pos=(2, 0))
+        board = GameBoard.new_game(self.make_deck(), initial_pos=(2, 0))
         board.board_locations = self.generate_locations()
         board.rotate_locations('CLOCKWISE')
         self.assertEqual(board.board_locations, self.generate_locations({
@@ -161,7 +172,7 @@ class TestGameBoard(TestCase):
         }))
 
     def test_rotate_locations_clockwise_right(self):
-        board = GameBoard.new_game([{'actions': []}], initial_pos=(0, 2))
+        board = GameBoard.new_game(self.make_deck(), initial_pos=(0, 2))
         board.board_locations = self.generate_locations()
         board.rotate_locations('CLOCKWISE')
         self.assertEqual(board.board_locations, self.generate_locations({
@@ -171,7 +182,7 @@ class TestGameBoard(TestCase):
         }))
 
     def test_rotate_locations_clockwise_corner(self):
-        board = GameBoard.new_game([{'actions': []}], initial_pos=(0, 4))
+        board = GameBoard.new_game(self.make_deck(), initial_pos=(0, 4))
         board.board_locations = self.generate_locations()
         board.rotate_locations('CLOCKWISE')
         self.assertEqual(board.board_locations, self.generate_locations({
@@ -180,7 +191,7 @@ class TestGameBoard(TestCase):
         }))
 
     def test_rotate_locations_anticlockwise(self):
-        board = GameBoard.new_game([{'actions': []}])
+        board = GameBoard.new_game(self.make_deck())
         board.board_locations = self.generate_locations()
         board.rotate_locations('ANTICLOCKWISE')
         self.assertEqual(board.board_locations, self.generate_locations({
@@ -190,17 +201,17 @@ class TestGameBoard(TestCase):
         }))
 
     def test_allow_chess_move_knight(self):
-        board = GameBoard.new_game([{'actions': []}])
+        board = GameBoard.new_game(self.make_deck())
         board.allow_chess_move(MOVES.KNIGHT)
         self.assertEqual(board.player.movement_mode, MOVES.KNIGHT)
 
     def test_allow_chess_move_bishop(self):
-        board = GameBoard.new_game([{'actions': []}])
+        board = GameBoard.new_game(self.make_deck())
         board.allow_chess_move(MOVES.BISHOP)
         self.assertEqual(board.player.movement_mode, MOVES.BISHOP)
 
     def test_allow_chess_move_castle(self):
-        board = GameBoard.new_game([{'actions': []}])
+        board = GameBoard.new_game(self.make_deck())
         board.allow_chess_move(MOVES.CASTLE)
         self.assertEqual(board.player.movement_mode, MOVES.CASTLE)