def test_from_json(self):
players_json = [
{
'color': "red",
'score': 0,
'places': []
},
{
'color': "black",
'score': 123,
'places': [[2, 3]]
},
{
'color': "white",
'score': 321,
'places': [[0, 0], [4, 5]]
},
{
'color': "brown",
'score': 7,
'places': [[0, 1], [321, 123]]
},
]
board_json = [
[1, 2],
[4, 0, 0, 5],
[1, 1, 0, 1]
]
state_json = {'players': players_json, 'board': board_json}
players = [PlayerData.from_json(player) for player in players_json]
board = Board.from_json(board_json)
self.assertEqual(State(players, board), State.from_json(state_json))
def setUp(self):
self.state = State([
PlayerData(Color.RED),
PlayerData(Color.BROWN),
PlayerData(Color.WHITE)
], Board(4, 4))
self.sock = socket.socket()
self.json_sock = JSONSocket(self.sock)
self.json_sock.send_json = MagicMock()
self.json_sock.recv_json = MagicMock()
self.proxy_player = RemotePlayerProxy(self.json_sock)
class PlayerTestCase(unittest.TestCase):
def setUp(self):
self.player1 = Player()
self.player2 = Player()
mini_board_array = [[1, 5], [2, 1], [1, 5]]
self.mini_board = Board(3, 2)
self.mini_board.create_board_from_json(mini_board_array)
self.strategy = Strategy()
self.in_player1 = PlayerData(Color.RED)
self.in_player2 = PlayerData(Color.WHITE)
self.players = [self.in_player1, self.in_player2]
self.mini_state = State(self.players, self.mini_board)
self.mini_tree = GameTree(self.mini_state)
def test_choose_placement(self):
self.assertEqual(self.player1.choose_placement(self.mini_state),
(0, 0))
next_state = self.mini_state.place_penguin_for_player(
Color.RED, (0, 0))
self.assertEqual(self.player1.choose_placement(next_state), (0, 1))
def test_choose_placement_wrap(self):
next_state = self.mini_state.place_penguin_for_player(
Color.RED, (0, 0))
next_state = next_state.place_penguin_for_player(Color.RED, (0, 1))
self.assertEqual(self.player1.choose_placement(next_state), (1, 0))
def test_choose_next_move(self):
next_state = self.mini_state.place_penguin_for_player(
Color.RED, (0, 0))
next_state = next_state.place_penguin_for_player(Color.WHITE, (0, 1))
self.player1.set_state(next_state)
self.assertEqual(self.player1.choose_next_move().print_json(),
[(0, 0), (2, 1)])
def test_choose_next_move_no_moves(self):
next_state = self.mini_state.place_penguin_for_player(
Color.RED, (0, 0))
next_state = next_state.place_penguin_for_player(Color.WHITE, (1, 0))
next_state = next_state.place_penguin_for_player(Color.WHITE, (2, 0))
self.player1.set_state(next_state)
self.assertEqual(self.player1.choose_next_move().print_json(), False)
def test_assign_color(self):
self.assertEqual(self.player1.get_color(), None)
self.player1.assign_color(Color.RED)
self.assertEqual(self.player1.get_color(), Color.RED)
def test_assign_color_twice(self):
self.assertEqual(self.player1.get_color(), None)
self.player1.assign_color(Color.RED)
self.assertEqual(self.player1.get_color(), Color.RED)
self.player1.assign_color(Color.WHITE)
self.assertEqual(self.player1.get_color(), Color.WHITE)
def setUp(self):
self.player1 = Player()
self.player2 = Player()
mini_board_array = [[1, 5], [2, 1], [1, 5]]
self.mini_board = Board(3, 2)
self.mini_board.create_board_from_json(mini_board_array)
self.strategy = Strategy()
self.in_player1 = PlayerData(Color.RED)
self.in_player2 = PlayerData(Color.WHITE)
self.players = [self.in_player1, self.in_player2]
self.mini_state = State(self.players, self.mini_board)
self.mini_tree = GameTree(self.mini_state)
def setUp(self):
self.board_full = Board(4, 3)
self.board_full.create_board_without_holes(4)
self.board_holes = Board(4, 3)
self.board_holes.create_board_with_holes([(0, 0), (1, 1)], 3)
self.player1 = PlayerData(Color.RED, 5)
self.player2 = PlayerData(Color.WHITE, 10)
self.player3 = PlayerData(Color.BROWN)
self.player4 = PlayerData(Color.BLACK)
self.player5 = PlayerData(Color.BLACK)
self.players = [self.player1, self.player2]
self.state_full = State(self.players, self.board_full)
self.state_holes = State(self.players, self.board_holes)
def test_tt(self):
self.legacy_player.set_state = MagicMock(
wraps=self.legacy_player.set_state)
self.legacy_player.choose_next_move = MagicMock(
wraps=self.legacy_player.choose_next_move)
board = Board(3, 3)
board.create_board_without_holes(1)
state = State([PlayerData(Color.RED)], board)
state = state.place_penguin_for_player(Color.RED, (0, 0))
self.adapter.play_as(Color.RED)
actions = [Action(), Action(), Action()]
self.assertIsInstance(self.adapter.tt(state, actions), Action)
self.legacy_player.set_state.assert_called_once_with(state)
self.legacy_player.choose_next_move.assert_called_once_with()
def setUp(self):
self.logical_player = LogicalPlayerInterface()
self.adapted_player = LegacyToLogicalPlayer(self.logical_player)
self.board = Board(4, 4)
self.board.create_board_without_holes(1)
self.players = [
PlayerData(Color.RED),
PlayerData(Color.WHITE),
PlayerData(Color.BROWN)
]
state = State(self.players, self.board)
state = state.place_penguin_for_player(Color.RED, (0, 0))
state = state.place_penguin_for_player(Color.WHITE, (1, 1))
state = state.place_penguin_for_player(Color.BROWN, (1, 3))
self.state = state
def initialize_game(self, players):
"""
Start the game. Initializes the game board, the game state,
and the resulting game tree with the parameters.
The resulting GameTree is ready to play.
1. Takes care of what kind of Board to make (does it have holes, number of fish, etc),
and makes sure that the board is big enough for the number of players and their penguins
2. Calls on Players to place their penguins
EFFECT: Sets the current Game to be the GameTree.
[List-of PlayerInterface] -> GameTree
"""
if len(players) < MIN_PLAYERS or len(players) > MAX_PLAYERS:
raise ValueError("Invalid number of players")
if type(self.__game) is not GameSetup:
raise ValueError("Cannot initialize game: Game already started")
internal_players = self.__assign_player_colors(players)
board = self.__create_board()
state = State(internal_players, board)
self.__game = GameTree(state)
self.__run_penguin_placement()
self.__broadcast_current_state()
return self.__game
def __handle_setup(self, arguments):
"""
Handle a start message.
JSON value -> JSON value
"""
state = State.from_json(arguments[0])
return self.__player.setup(state)
def __handle_take_turn(self, arguments):
"""
Handle a start message.
JSON value -> JSON value
"""
state = State.from_json(arguments[0])
actions = [Move.from_json(action) for action in arguments[1]]
return self.__player.tt(state, actions).print_json()
def setUp(self):
self.state = State(
[PlayerData(Color.RED), PlayerData(Color.BROWN), PlayerData(Color.WHITE)],
Board(4, 4))
self.sock = socket.socket()
self.json_sock = JSONSocket(self.sock)
self.player = LogicalPlayerInterface()
self.player.start = MagicMock()
self.player.end = MagicMock()
self.player.play_as = MagicMock()
self.player.play_with = MagicMock()
self.posn = (0, 0)
self.player.setup = MagicMock(return_value=self.posn)
self.move = Move((0, 0), (1, 0))
self.player.tt = MagicMock(return_value=self.move)
self.server_proxy = ServerProxy(self.player, self.json_sock)
class RemotePlayerProxyTest(unittest.TestCase):
def setUp(self):
self.state = State([
PlayerData(Color.RED),
PlayerData(Color.BROWN),
PlayerData(Color.WHITE)
], Board(4, 4))
self.sock = socket.socket()
self.json_sock = JSONSocket(self.sock)
self.json_sock.send_json = MagicMock()
self.json_sock.recv_json = MagicMock()
self.proxy_player = RemotePlayerProxy(self.json_sock)
def tearDown(self):
self.sock.close()
# __init__() ##########################################################
def test_constructor(self):
self.assertRaisesRegex(ValueError,
"json_sock must be an instance of JSONSocket",
RemotePlayerProxy, None)
# start() ##############################################################
def test_start_pass(self):
self.json_sock.recv_json.return_value = "void"
self.proxy_player.start(True)
self.json_sock.send_json.assert_called_once_with(["start", [True]])
self.json_sock.recv_json.assert_called_once()
def test_start_fail(self):
self.json_sock.recv_json.return_value = False
self.assertRaisesRegex(RuntimeError,
"Player did not return 'void' to start method",
self.proxy_player.start, True)
self.json_sock.send_json.assert_called_once_with(["start", [True]])
self.json_sock.recv_json.assert_called_once()
# end() ##############################################################
def test_end_pass(self):
self.json_sock.recv_json.return_value = "void"
self.proxy_player.end(True)
self.json_sock.send_json.assert_called_once_with(["end", [True]])
self.json_sock.recv_json.assert_called_once()
def test_end_fail(self):
self.json_sock.recv_json.return_value = False
self.assertRaisesRegex(RuntimeError,
"Player did not return 'void' to end method",
self.proxy_player.end, True)
self.json_sock.send_json.assert_called_once_with(["end", [True]])
self.json_sock.recv_json.assert_called_once()
# play_as() ##############################################################
def test_play_as_pass(self):
self.json_sock.recv_json.return_value = "void"
self.proxy_player.play_as(Color.RED)
self.json_sock.send_json.assert_called_once_with(
["playing-as", [Color.RED.value]])
self.json_sock.recv_json.assert_called_once()
def test_play_as_fail(self):
self.json_sock.recv_json.return_value = False
self.assertRaisesRegex(
RuntimeError, "Player did not return 'void' to play_as method",
self.proxy_player.play_as, Color.RED)
self.json_sock.send_json.assert_called_once_with(
["playing-as", [Color.RED.value]])
self.json_sock.recv_json.assert_called_once()
# play_with() ##############################################################
def test_play_with_pass(self):
self.json_sock.recv_json.return_value = "void"
self.proxy_player.play_with([Color.BROWN, Color.WHITE])
self.json_sock.send_json.assert_called_once_with(
["playing-with", [[Color.BROWN.value, Color.WHITE.value]]])
self.json_sock.recv_json.assert_called_once()
def test_play_with_fail(self):
self.json_sock.recv_json.return_value = False
self.assertRaisesRegex(
RuntimeError, "Player did not return 'void' to play_with method",
self.proxy_player.play_with, [Color.BROWN, Color.WHITE])
self.json_sock.send_json.assert_called_once_with(
["playing-with", [[Color.BROWN.value, Color.WHITE.value]]])
self.json_sock.recv_json.assert_called_once()
# setup() ##############################################################
def test_setup_pass(self):
self.json_sock.recv_json.return_value = (0, 0)
result = self.proxy_player.setup(self.state)
self.assertEqual((0, 0), result)
self.json_sock.send_json.assert_called_once_with(
["setup", [self.state.print_json()]])
self.json_sock.recv_json.assert_called_once()
def test_setup_fail(self):
self.json_sock.recv_json.return_value = ("1", "0")
self.assertRaisesRegex(
RuntimeError,
"Player did not return an int, int 2-tuple to setup method",
self.proxy_player.setup, self.state)
self.json_sock.send_json.assert_called_once_with(
["setup", [self.state.print_json()]])
self.json_sock.recv_json.assert_called_once()
# tt() ##############################################################
def test_tt_move_pass(self):
self.json_sock.recv_json.return_value = [[0, 0], [0, 2]]
result = self.proxy_player.tt(self.state, [])
self.assertEqual(Move((0, 0), (0, 2)), result)
self.json_sock.send_json.assert_called_once_with(
["take-turn", [self.state.print_json(), []]])
self.json_sock.recv_json.assert_called_once()
def test_tt_skip_pass(self):
self.json_sock.recv_json.return_value = False
result = self.proxy_player.tt(self.state, [])
self.assertEqual(Skip(), result)
self.json_sock.send_json.assert_called_once_with(
["take-turn", [self.state.print_json(), []]])
self.json_sock.recv_json.assert_called_once()
def test_tt_fail(self):
self.json_sock.recv_json.return_value = ((0, 0), ("1", "0"))
self.assertRaisesRegex(RuntimeError,
"Player did not return an Action to tt method",
self.proxy_player.tt, self.state, [])
self.json_sock.send_json.assert_called_once_with(
["take-turn", [self.state.print_json(), []]])
self.json_sock.recv_json.assert_called_once()
class StateTestCase(unittest.TestCase):
def setUp(self):
self.board_full = Board(4, 3)
self.board_full.create_board_without_holes(4)
self.board_holes = Board(4, 3)
self.board_holes.create_board_with_holes([(0, 0), (1, 1)], 3)
self.player1 = PlayerData(Color.RED, 5)
self.player2 = PlayerData(Color.WHITE, 10)
self.player3 = PlayerData(Color.BROWN)
self.player4 = PlayerData(Color.BLACK)
self.player5 = PlayerData(Color.BLACK)
self.players = [self.player1, self.player2]
self.state_full = State(self.players, self.board_full)
self.state_holes = State(self.players, self.board_holes)
def test_duplicate_player_colors(self):
duplicate_colors = [self.player1, self.player3, self.player4, self.player5]
self.assertRaisesRegex(ValueError, "Players cannot have duplicate colors",
State, duplicate_colors, self.board_full)
def test_place_penguin_for_player_success(self):
self.assertEqual(self.state_full.get_all_penguins(), [])
new_state = self.state_full.place_penguin_for_player(Color.RED, (1, 2))
self.assertEqual(new_state.get_all_penguins(), [(1, 2)])
def test_place_penguin_for_player_out_of_bounds(self):
self.assertEqual(self.state_full.get_all_penguins(), [])
self.assertFalse(self.state_full.place_penguin_for_player(Color.RED, (4, 3)))
def test_place_penguin_for_player_hole(self):
self.assertEqual(self.state_holes.get_all_penguins(), [])
self.assertFalse(self.state_holes.place_penguin_for_player(Color.RED, (0, 0)))
def test_place_penguin_for_player_no_player(self):
self.assertEqual(self.state_full.get_all_penguins(), [])
self.assertFalse(self.state_full.place_penguin_for_player(Color.BROWN, (1, 2)))
def test_get_all_penguins(self):
self.assertEqual(self.state_full.get_all_penguins(), [])
self.player1.get_penguins = MagicMock(return_value=[])
self.player2.get_penguins = MagicMock(return_value=[(0, 0), (3, 2)])
self.assertEqual(self.state_full.get_all_penguins(), [(0, 0), (3, 2)])
def test_get_player_success(self):
self.assertEqual(self.state_full.get_player(Color.RED), self.player1)
self.assertEqual(self.state_full.get_player(Color.WHITE), self.player2)
def test_get_player_no_player(self):
self.assertFalse(self.state_full.get_player(Color.BROWN))
def test_is_tile_available_true(self):
self.assertTrue(self.state_full.is_tile_available((1, 1)))
self.assertTrue(self.state_holes.is_tile_available((2, 2)))
def test_is_tile_available_holes(self):
self.assertFalse(self.state_holes.is_tile_available((0, 0)))
self.assertFalse(self.state_holes.is_tile_available((1, 1)))
def test_is_tile_available_out_of_bounds(self):
self.assertFalse(self.state_full.is_tile_available((4, 3)))
self.assertFalse(self.state_full.is_tile_available((-2, 3)))
def test_is_tile_available_occupied(self):
new_state = self.state_full.place_penguin_for_player(Color.RED, (1, 2))
self.assertFalse(new_state.is_tile_available((1, 2)))
def test_valid_move_success(self):
self.state_full.get_all_penguins = MagicMock(return_value=[(0, 0), (1, 0), (3, 2)])
self.assertTrue(self.state_full.valid_move((0, 0), (2, 0)))
def test_valid_move_occupied(self):
self.state_full.get_all_penguins = MagicMock(return_value=[(0, 0), (1, 0), (3, 2)])
self.assertFalse(self.state_full.valid_move((0, 0), (1, 0)))
def test_valid_move_hole(self):
self.state_holes.get_all_penguins = MagicMock(return_value=[(0, 1), (1, 0), (3, 2)])
self.assertFalse(self.state_holes.valid_move((0, 1), (1, 1)))
def test_valid_move_no_penguin(self):
self.state_holes.get_all_penguins = MagicMock(return_value=[(0, 1), (1, 0), (3, 2)])
self.assertFalse(self.state_holes.valid_move((0, 0), (2, 0)))
def test_valid_move_not_reachable(self):
self.state_holes.get_all_penguins = MagicMock(return_value=[(0, 1), (1, 0), (3, 2)])
self.assertFalse(self.state_holes.valid_move((0, 0), (3, 0)))
def test_get_player_from_penguin_exists(self):
self.player1.get_penguins = MagicMock(return_value=[(0, 0), (1, 0)])
self.player2.get_penguins = MagicMock(return_value=[(3, 2)])
self.assertEqual(self.state_full.get_player_from_penguin((3, 2)), self.player2)
def test_get_player_from_penguin_no_player(self):
self.player1.get_penguins = MagicMock(return_value=[(0, 0), (1, 0)])
self.assertFalse(self.state_full.get_player_from_penguin((3, 2)))
def test_move_penguin_success(self):
self.player1.add_penguin((0, 0))
self.assertTrue((0, 0) in self.state_full.get_all_penguins())
self.assertFalse((2, 0) in self.state_full.get_all_penguins())
self.assertEqual(self.state_full.get_current_player_color(), Color.RED)
new_state = self.state_full.move_penguin((0, 0), (2, 0))
self.assertTrue((2, 0) in new_state.get_all_penguins())
self.assertFalse((0, 0) in new_state.get_all_penguins())
self.assertEqual(new_state.get_current_player_color(), Color.WHITE)
def test_move_penguin_occupied(self):
self.player1.add_penguin((0, 0))
self.player2.add_penguin((2, 0))
self.assertEqual(self.state_full.get_all_penguins(), [(0, 0), (2, 0)])
self.assertEqual(self.state_full.get_current_player_color(), Color.RED)
self.assertFalse(self.state_full.move_penguin((0, 0), (2, 0)))
self.assertEqual(self.state_full.get_all_penguins(), [(0, 0), (2, 0)])
self.assertEqual(self.state_full.get_current_player_color(), Color.RED)
def test_any_remaining_moves_true(self):
self.player1.add_penguin((0, 0))
self.player2.add_penguin((2, 0))
self.assertTrue(self.state_full.any_remaining_moves())
def test_any_remaining_moves_no_penguins(self):
self.assertFalse(self.state_full.any_remaining_moves())
def test_any_remaining_moves_no_moves(self):
board = Board(4, 3)
board.create_board_with_holes([(1, 0), (2, 0)], 0)
state = State(self.players, board)
self.player1.add_penguin((0, 0))
self.assertFalse(state.any_remaining_moves())
def test_get_possible_moves(self):
self.player1.add_penguin((0, 0))
actions = [Move((0, 0), (1, 0)), Move((0, 0), (2, 0)),
Move((0, 0), (2, 1)), Move((0, 0), (3, 1))]
for action in self.state_full.get_possible_moves():
self.assertTrue(action in actions)
self.assertEqual(len(self.state_full.get_possible_moves()), len(actions))
def test_get_possible_moves_another_penguin(self):
self.player1.add_penguin((0, 0))
self.player2.add_penguin((2, 1))
actions = [Move((0, 0), (1, 0)), Move((0, 0), (2, 0))]
for action in self.state_full.get_possible_moves():
self.assertTrue(action in actions)
self.assertEqual(len(self.state_full.get_possible_moves()), len(actions))
def test_get_players_score_after_move(self):
self.assertEqual(self.state_full.get_players_score(Color.RED), 0)
self.player1.add_penguin((0, 0))
new_state = self.state_full.move_penguin((0, 0), (1, 0))
self.assertEqual(new_state.get_players_score(Color.RED), 4)
self.assertEqual(self.state_full.get_players_score(Color.WHITE), 0)
def test_get_players_score_mutate_player(self):
self.assertEqual(self.state_full.get_players_score(Color.RED), 0)
self.player1.add_to_score(10)
self.assertEqual(self.state_full.get_players_score(Color.RED), 10)
def test_from_json(self):
players_json = [
{
'color': "red",
'score': 0,
'places': []
},
{
'color': "black",
'score': 123,
'places': [[2, 3]]
},
{
'color': "white",
'score': 321,
'places': [[0, 0], [4, 5]]
},
{
'color': "brown",
'score': 7,
'places': [[0, 1], [321, 123]]
},
]
board_json = [
[1, 2],
[4, 0, 0, 5],
[1, 1, 0, 1]
]
state_json = {'players': players_json, 'board': board_json}
players = [PlayerData.from_json(player) for player in players_json]
board = Board.from_json(board_json)
self.assertEqual(State(players, board), State.from_json(state_json))
def test_any_remaining_moves_no_moves(self):
board = Board(4, 3)
board.create_board_with_holes([(1, 0), (2, 0)], 0)
state = State(self.players, board)
self.player1.add_penguin((0, 0))
self.assertFalse(state.any_remaining_moves())
def test_setup(self):
self.legacy_player.choose_placement = MagicMock(
wraps=self.legacy_player.choose_placement)
state = State([], Board(3, 3))
self.assertEqual(self.adapter.setup(state), (0, 0))
self.legacy_player.choose_placement.assert_called_once_with(state)
class ServerProxyTest(unittest.TestCase):
def setUp(self):
self.state = State(
[PlayerData(Color.RED), PlayerData(Color.BROWN), PlayerData(Color.WHITE)],
Board(4, 4))
self.sock = socket.socket()
self.json_sock = JSONSocket(self.sock)
self.player = LogicalPlayerInterface()
self.player.start = MagicMock()
self.player.end = MagicMock()
self.player.play_as = MagicMock()
self.player.play_with = MagicMock()
self.posn = (0, 0)
self.player.setup = MagicMock(return_value=self.posn)
self.move = Move((0, 0), (1, 0))
self.player.tt = MagicMock(return_value=self.move)
self.server_proxy = ServerProxy(self.player, self.json_sock)
def tearDown(self):
self.sock.close()
def test_constructor(self):
ServerProxy(self.player, self.json_sock)
with self.assertRaises(ValueError):
ServerProxy(self.player, None)
with self.assertRaises(ValueError):
ServerProxy(None, self.json_sock)
def test_listen(self):
self.json_sock.send_json = MagicMock()
self.json_sock.recv_json = MagicMock()
self.json_sock.recv_json.side_effect = [
["start", [True]],
["playing-as", ["red"]],
["playing-with", [["red", "black"]]],
["setup", [self.state.print_json()]],
["take-turn", [self.state.print_json(), []]],
["end", [True]]
]
self.server_proxy.listen()
self.json_sock.send_json.assert_has_calls([
call("void"),
call("void"),
call("void"),
call(self.posn),
call(self.move.print_json()),
call("void")
])
def test_start(self):
request = ["start", [True]]
self.server_proxy._ServerProxy__handle_request(request)
request = ["start", [False]]
self.assertEqual("void", self.server_proxy._ServerProxy__handle_request(request))
self.player.start.assert_has_calls([call(True), call(False)])
def test_end(self):
request = ["end", [True]]
self.server_proxy._ServerProxy__handle_request(request)
request = ["end", [False]]
self.assertEqual("void", self.server_proxy._ServerProxy__handle_request(request))
self.player.end.assert_has_calls([call(True), call(False)])
def test_play_as(self):
request = ["playing-as", ["red"]]
self.server_proxy._ServerProxy__handle_request(request)
request = ["playing-as", ["black"]]
self.assertEqual("void", self.server_proxy._ServerProxy__handle_request(request))
self.player.play_as.assert_has_calls([call(Color.RED), call(Color.BLACK)])
def test_play_with(self):
request = ["playing-with", [["red", "black"]]]
self.server_proxy._ServerProxy__handle_request(request)
request = ["playing-with", [["white", "brown"]]]
self.assertEqual("void", self.server_proxy._ServerProxy__handle_request(request))
self.player.play_with.assert_has_calls([call([Color.RED, Color.BLACK]),
call([Color.WHITE, Color.BROWN])])
def test_setup(self):
request = ["setup", [self.state.print_json()]]
self.assertEqual(self.posn,
self.server_proxy._ServerProxy__handle_request(request))
self.player.setup.assert_called_once_with(self.state)
def test_tt(self):
actions = [self.move.print_json()]
request = ["take-turn", [self.state.print_json(), actions]]
self.assertEqual(self.move.print_json(),
self.server_proxy._ServerProxy__handle_request(request))
self.player.tt.assert_called_once_with(self.state, [self.move])