def test_random_actions_computes_valid_actions():
""" Runs computation 100 times and expects that it returns valid actions in each run """
card_factory = MazeCardFactory()
orig_board = Board(create_maze(MAZE_STRING, card_factory), leftover_card=card_factory.create_instance("NE", 0))
for _ in range(100):
board = copy.deepcopy(orig_board)
maze = board.maze
piece = board.create_piece()
piece.maze_card = maze[BoardLocation(0, 0)]
game = Mock()
game.get_enabled_shift_locations.return_value = board.shift_locations
game.board = board
computer_player = ComputerPlayer(library_binding_factory=Mock(), move_url="move-url", shift_url="shift-url",
game=game, identifier=9, board=board, piece=piece)
shift_action, move_location = computer_player.random_actions()
shift_location, shift_rotation = shift_action
assert shift_rotation in [0, 90, 180, 270]
assert shift_location in board.shift_locations
allowed_coordinates = [(0, 0)]
if shift_location == BoardLocation(0, 1) and shift_rotation == 270:
allowed_coordinates += [(0, 1)]
elif shift_location == BoardLocation(0, 1) and shift_rotation == 180:
allowed_coordinates += [(0, 1), (1, 1)]
elif shift_location == BoardLocation(1, 0) and shift_rotation == 270:
allowed_coordinates += [(1, 0)]
elif shift_location == BoardLocation(1, 0) and shift_rotation == 0:
allowed_coordinates += [(1, 0), (1, 1), (1, 2), (2, 1), (2, 2), (3, 1), (3, 2)]
elif shift_location == BoardLocation(6, 1):
allowed_coordinates += [(0, 1), (0, 2), (1, 1), (2, 1)]
allowed_moves = {
BoardLocation(*coordinates) for coordinates in allowed_coordinates
}
assert move_location in allowed_moves
def test_computer_player_random_algorith_when_piece_is_pushed_out(post_move, post_shift, time_sleep):
""" Tests case where piece is positioned on a shift location, so that it is pushed out.
Runs computation 100 times. Push-out expectation rate is 1/12.
Probability that no push-out takes place in 100 runs is negligible
.start() is patched so that the compute method runs sequentially.
This test recreates a bug, where the pushed-out piece is not updated correctly, leading
to exceptions thrown when computer makes a move.
"""
card_factory = MazeCardFactory()
board = Board(create_maze(MAZE_STRING, card_factory), leftover_card=card_factory.create_instance("NE", 0))
piece = board.create_piece()
piece.maze_card = board.maze[BoardLocation(3, 6)]
game = Mock()
game.get_enabled_shift_locations.return_value = board.shift_locations
game.board = board
computer_player = ComputerPlayer(library_binding_factory=Mock(), move_url="move-url", shift_url="shift-url",
game=game, identifier=9, board=board, piece=piece)
for _ in range(100):
shift_action, move_location = computer_player.random_actions()
shift_location, _ = shift_action
allowed_coordinates = [(3, 6)]
if shift_location == BoardLocation(3, 6):
allowed_coordinates = [(3, 5)]
elif shift_location == BoardLocation(3, 0):
allowed_coordinates = [(3, 0)]
allowed_moves = {BoardLocation(*coordinates) for coordinates in allowed_coordinates}
assert move_location in allowed_moves
def param_tuple_to_param_dict(maze_string, leftover_out_paths, piece_starts,
objective):
""" Converts a tuple of board state defining parameters to a dictionary,
which can be used by create_board_and_pieces.
:param maze_string: a string defining a maze
:param leftover_out_paths: the out paths of the leftover maze card
:param piece_starts: a list of starting locations of pieces on the board. The number of pieces will be equal to
the size of this list. Each location is a 2-tuple.
:param objective: the location (2-tuple) of the objective,
or 'leftover' to denote that the objective is the leftover maze card
"""
maze_card_factory = MazeCardFactory()
maze = create_maze(maze_string, maze_card_factory)
leftover_card = maze_card_factory.create_instance(leftover_out_paths, 0)
param_dict = {
"maze":
maze,
"leftover_card":
leftover_card,
"piece_locations":
[BoardLocation(*piece_start) for piece_start in piece_starts]
}
if type(objective) == tuple:
param_dict["objective_location"] = BoardLocation(*objective)
elif objective == "leftover":
param_dict["objective_maze_card"] = leftover_card
return param_dict
def create_random_maze(maze_card_factory=None):
""" Generates a random maze state.
Corners of the maze are fixed as corners
"""
fixed_cards = {
BoardLocation(0, 0): MazeCard(out_paths=MazeCard.CORNER, rotation=90),
BoardLocation(0, 6): MazeCard(out_paths=MazeCard.CORNER, rotation=180),
BoardLocation(6, 6): MazeCard(out_paths=MazeCard.CORNER, rotation=270),
BoardLocation(6, 0): MazeCard(out_paths=MazeCard.CORNER, rotation=0)
}
if not maze_card_factory:
maze_card_factory = MazeCardFactory()
maze = Maze()
def card_at(location):
if location in fixed_cards:
return maze_card_factory.create_instance(
fixed_cards[location].out_paths,
fixed_cards[location].rotation)
return maze_card_factory.create_random_maze_card()
for location in maze.maze_locations:
maze[location] = card_at(location)
return maze
def test_random_actions_should_respect_no_pushback_rule():
""" Runs computation 50 times and checks that none of the computed shifts reverts the previous shift action """
card_factory = MazeCardFactory()
orig_board = Board(create_maze(MAZE_STRING, card_factory), leftover_card=card_factory.create_instance("NE", 0))
for _ in range(50):
board = copy.deepcopy(orig_board)
maze = board.maze
piece = board.create_piece()
piece.maze_card = maze[BoardLocation(0, 0)]
game = Game(0, board=orig_board)
game.previous_shift_location = BoardLocation(0, 3)
computer_player = ComputerPlayer(library_binding_factory=Mock(), move_url="move-url", shift_url="shift-url",
game=game, identifier=9, board=board, piece=piece)
shift_action, _ = computer_player.random_actions()
shift_location, _ = shift_action
assert shift_location != BoardLocation(6, 3)
def test_computer_player_calls_start_on_compute_method(post_move, post_shift, time_sleep):
""" Tests that the computer player calls start() one its computation method.
"""
card_factory = MazeCardFactory()
board = Board(create_maze(MAZE_STRING, card_factory), leftover_card=card_factory.create_instance("NE", 0))
piece = board.create_piece()
game = Mock()
type(game).identifier = PropertyMock(return_value=7)
game.get_enabled_shift_locations.return_value = board.shift_locations
mock_method = Mock()
mock_method.start = Mock()
mock_method.shift_action = BoardLocation(0, 1), 90
mock_method.move_action = board.maze.maze_card_location(piece.maze_card)
mock_method_factory = Mock()
mock_method_factory.return_value = mock_method
player = ComputerPlayer(library_binding_factory=mock_method_factory, move_url="move-url", shift_url="shift-url",
game=game, identifier=9, board=board, piece=piece)
player.run()
mock_method.start.assert_called_once()
post_shift.assert_called_once()
post_move.assert_called_once()
def _create_test_game(with_computer=False):
""" Creates a Game instance by hand """
card_factory = MazeCardFactory()
board = Board(leftover_card=MazeCard(0, MazeCard.T_JUNCT, 0))
for row in range(board.maze.maze_size):
for column in range(board.maze.maze_size):
if row == 0 and column == 0:
board.maze[BoardLocation(
row, column)] = card_factory.create_instance(
MazeCard.STRAIGHT, 0)
elif row == 1 and column == 1:
board.maze[BoardLocation(
row, column)] = card_factory.create_instance(
MazeCard.CORNER, 0)
elif row == 2 and column == 2:
board.maze[BoardLocation(
row, column)] = card_factory.create_instance(
MazeCard.T_JUNCT, 270)
else:
board.maze[BoardLocation(
row, column)] = card_factory.create_instance(
MazeCard.T_JUNCT, 0)
player_ids = [3, 4]
players = [
Player(identifier=player_id, game=None) for player_id in player_ids
]
if with_computer:
player_ids.append(42)
players.append(
create_computer_player(player_id=42,
compute_method="dynamic-foo",
shift_url="shift-url",
move_url="move-url"))
for player in players:
player.set_board(board)
players[0].piece.maze_card = board.maze[BoardLocation(3, 3)]
players[1].piece.maze_card = board.maze[BoardLocation(5, 5)]
players[0].piece.piece_index = 1
players[1].piece.piece_index = 0
players[0].score = 7
players[1].score = 8
board._objective_maze_card = board.maze[BoardLocation(1, 4)]
turns = Turns(players,
next_action=PlayerAction(players[1],
PlayerAction.MOVE_ACTION))
game = Game(identifier=7, turns=turns, board=board, players=players)
for player in players:
player._game = game
game.previous_shift_location = BoardLocation(0, 3)
return game, player_ids