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.player1 = Player(3)
self.player2 = Player(5)
self.player3 = Player(7)
self.player4 = Player(1)
self.player5 = Player(1)
self.ext_players = [self.player1, self.player2, self.player3]
self.referee = Referee()
def test_constructor(self):
LogicalToLegacyPlayer(PlayerInterface())
LogicalToLegacyPlayer(Player())
with self.assertRaises(ValueError):
LogicalToLegacyPlayer(LogicalPlayerInterface())
with self.assertRaises(ValueError):
LogicalToLegacyPlayer(None)
def main(address):
"""
Create a remote Fish.com player and connect it to a
Fish.com server at the given address.
"""
name = '"' + uuid.uuid4().hex[:6].upper() + '"'
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(address)
sock.sendall(name.encode())
depth = 1
player = Player(depth)
adapter = LogicalToLegacyPlayer(player)
server_proxy = ServerProxy(adapter, JSONSocket(sock))
server_proxy.listen()
sock.close()
def setUp(self):
self.player1 = Player(1)
self.player2 = Player(1)
self.player3 = Player(2)
self.player4 = Player(1)
self.player5 = Player(1)
self.player6 = Player(2)
self.players = [self.player1, self.player2, self.player3,
self.player4, self.player5, self.player6]
self.manager = Manager()
class RefereeTestCase(unittest.TestCase):
def setUp(self):
self.player1 = Player(3)
self.player2 = Player(5)
self.player3 = Player(7)
self.player4 = Player(1)
self.player5 = Player(1)
self.ext_players = [self.player1, self.player2, self.player3]
self.referee = Referee()
def test_initialize_game(self):
game = self.referee.initialize_game(self.ext_players)
self.assertEqual(type(game), GameTree)
self.assertEqual(len(game.state.get_all_penguins()), 9)
self.assertEqual(self.player1.get_color(), Color.RED)
self.assertEqual(self.player2.get_color(), Color.WHITE)
self.assertEqual(self.player3.get_color(), Color.BROWN)
self.assertFalse(self.referee.has_game_ended())
def test_initialize_game_player_kicked(self):
self.player1.choose_placement = MagicMock(return_value=(-1, 0))
game = self.referee.initialize_game(self.ext_players)
self.assertEqual(self.referee.get_players_as_colors(),
[Color.WHITE, Color.BROWN])
def test_initialize_game_too_few_players(self):
self.assertRaisesRegex(ValueError, "Invalid number of players",
self.referee.initialize_game, [])
def test_initialize_game_too_many_players(self):
too_many_players = [
self.player1, self.player2, self.player3, self.player4,
self.player5
]
self.assertRaisesRegex(ValueError, "Invalid number of players",
self.referee.initialize_game, too_many_players)
def test_check_move_validity(self):
game = self.referee.initialize_game(self.ext_players)
game_tree = self.referee.check_move_validity(Move((2, 0), (3, 0)))
self.assertEqual(type(game_tree), GameTree)
def test_check_move_validity_false(self):
game = self.referee.initialize_game(self.ext_players)
self.assertFalse(self.referee.check_move_validity(Move((2, 0),
(1, 0))))
def test_check_move_validity_game_setup(self):
self.assertFalse(self.referee.check_move_validity(Move((2, 0),
(3, 0))))
def test_play_game(self):
game_result = self.referee.play_game(self.ext_players)
self.assertEqual(type(game_result), dict)
self.assertEqual(game_result["winners"], self.ext_players)
self.assertEqual(game_result["kicked_players"], set())
def test_play_game_player_kicked(self):
self.player1.choose_next_move = MagicMock(
return_value=Move((0, 0), (1, 1)))
game_result = self.referee.play_game(self.ext_players)
self.assertEqual(game_result["winners"], [self.player2])
self.assertEqual(game_result["kicked_players"], {self.player1})
def test_alert_winners(self):
with patch.object(Player, "game_over") as mock_game_over:
game_result = self.referee.play_game(self.ext_players)
self.referee.alert_players(game_result)
mock_game_over.assert_called()
def test_alert_winners_no_winners(self):
with patch.object(Player, "game_over") as mock_game_over:
game = self.referee.initialize_game(self.ext_players)
self.referee.alert_players({})
mock_game_over.assert_not_called()
def test_get_winners(self):
self.referee.play_game(self.ext_players)
self.assertEqual(self.referee.get_winners(), self.ext_players)
def test_get_winners_game_not_played(self):
self.referee.initialize_game(self.ext_players)
self.assertFalse(self.referee.get_winners())
def test_get_current_scores(self):
self.referee.initialize_game(self.ext_players)
self.assertEqual(self.referee.get_current_scores(),
[(self.player1, 0), (self.player2, 0),
(self.player3, 0)])
def test_has_game_ended(self):
self.assertFalse(self.referee.has_game_ended())
self.referee.play_game(self.ext_players)
self.assertTrue(self.referee.has_game_ended())
def test_player_timeout(self):
def slow_func():
sleep(10)
self.player1.choose_placement = slow_func
self.player2.choose_next_move = slow_func
game_result = self.referee.play_game(
[self.player1, self.player2, self.player5])
self.assertEqual(type(game_result), dict)
self.assertEqual(game_result["winners"], [self.player5])
self.assertEqual(game_result["kicked_players"],
set([self.player1, self.player2]))
def test_player_exception(self):
def bad_func():
raise Exception
self.player1.choose_placement = bad_func
self.player2.choose_next_move = bad_func
game_result = self.referee.play_game(
[self.player1, self.player2, self.player5])
self.assertEqual(type(game_result), dict)
self.assertEqual(game_result["winners"], [self.player5])
self.assertEqual(game_result["kicked_players"],
set([self.player1, self.player2]))
def test_bad_player(self):
self.assertRaisesRegex(
ValueError,
"logical_player must a subclass of LogicalPlayerInterface",
LegacyToLogicalPlayer, Player())
def setUp(self):
self.legacy_player = Player()
self.adapter = LogicalToLegacyPlayer(self.legacy_player)
class TestLogicalToLegacyPlayer(unittest.TestCase):
def setUp(self):
self.legacy_player = Player()
self.adapter = LogicalToLegacyPlayer(self.legacy_player)
def test_constructor(self):
LogicalToLegacyPlayer(PlayerInterface())
LogicalToLegacyPlayer(Player())
with self.assertRaises(ValueError):
LogicalToLegacyPlayer(LogicalPlayerInterface())
with self.assertRaises(ValueError):
LogicalToLegacyPlayer(None)
def test_start(self):
self.legacy_player.tournament_start = MagicMock()
self.adapter.start(True)
self.legacy_player.tournament_start.assert_called_once()
self.adapter.start(False)
self.assertEqual(2, self.legacy_player.tournament_start.call_count)
def test_end(self):
self.legacy_player.tournament_end = MagicMock()
self.adapter.end(True)
self.legacy_player.tournament_end.assert_called_once()
self.adapter.end(False)
self.legacy_player.tournament_end.assert_has_calls(
[call(True), call(False)])
def test_play_as(self):
for color in Color:
self.adapter.play_as(color)
self.assertEqual(color, self.legacy_player.get_color())
def test_play_with(self):
self.legacy_player.play_with = MagicMock()
self.adapter.play_with(list(Color))
self.legacy_player.play_with.assert_called_once()
self.adapter.play_with([])
self.legacy_player.play_with.assert_has_calls(
[call(list(Color)), call([])])
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)
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.player1 = Player(2)
self.player2 = Player(2)
self.player3 = Player(1)
self.players = [self.player1, self.player2, self.player3]
self.ref = ExtendedReferee()
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)