def test_game_invalid_placements(self):
"""test that a player who gives invalid placements loses
test that end_of_game is called on both players
"""
player1 = LegitPlayer()
player1.end_of_game = mock.MagicMock()
player2 = BadPlacementPlayer()
player2.end_of_game = mock.MagicMock()
player1guard = PlayerGuard(player1)
player2guard = PlayerGuard(player2)
uuids_to_player = {
self.uuidp1: player1guard,
self.uuidp2: player2guard
}
ref = Referee(uuids_to_player, self.uuids_to_name, self.obs_man)
result = ref.run_game()
player1.end_of_game.assert_called_once_with("p1")
player2.end_of_game.assert_not_called()
bad_players, game_results = result
expected_bad_players = [self.uuidp2]
for actual, expected in zip(bad_players, expected_bad_players):
self.assertEqual(actual, expected)
expected_game_results = [self.uuidp1]
for actual, expected in zip(game_results, expected_game_results):
self.assertEqual(actual, expected)
def test_normal_run_n_games(self):
"""test a normal game series between two good players
"""
player1 = LegitPlayer()
player1.end_of_game = mock.MagicMock()
player1.get_name = mock.MagicMock(return_value="p1")
player2 = LegitPlayer()
player2.end_of_game = mock.MagicMock()
player2.get_name = mock.MagicMock(return_value="p2")
player1guard = PlayerGuard(player1)
player2guard = PlayerGuard(player2)
uuids_to_player = {
self.uuidp1: player1guard,
self.uuidp2: player2guard
}
ref = Referee(uuids_to_player, self.uuids_to_name, self.obs_man)
bad_players, game_results = ref.run_n_games(3)
self.assertEqual(player1.end_of_game.call_count, 3)
self.assertEqual(player2.end_of_game.call_count, 3)
player1.end_of_game.assert_called_with("p1")
player2.end_of_game.assert_called_with("p1")
self.assertEqual(bad_players, [])
self.assertEqual(game_results, [self.uuidp1, self.uuidp2, self.uuidp1])
def setUp(self):
self.p1name = "p1"
self.uuidp1 = uuid.UUID('00000000000000000000000000000000')
self.player1 = LegitPlayer()
self.player1.end_of_game = mock.MagicMock()
self.player1.get_name = mock.MagicMock(return_value=self.p1name)
self.p2name = "p2"
self.uuidp2 = uuid.UUID('11111111111111111111111111111111')
self.player2 = LegitPlayer()
self.player2.end_of_game = mock.MagicMock()
self.player2.get_name = mock.MagicMock(return_value=self.p2name)
self.obs_man = ObserverManager()
self.uuids_to_name = {
self.uuidp1: self.p1name,
self.uuidp2: self.p2name
}
self.player1guard = PlayerGuard(self.player1)
self.player2guard = PlayerGuard(self.player2)
self.uuids_to_player = {
self.uuidp1: self.player1guard,
self.uuidp2: self.player2guard
}
self.ref = Referee(self.uuids_to_player, self.uuids_to_name,
self.obs_man)
def test_n_games_malformed_turn(self):
"""tests that a player who gives a malformed turn
loses and end_of_games is not called on it in n games
"""
player1 = LegitPlayer()
player1.end_of_game = mock.MagicMock()
player1.get_name = mock.MagicMock(return_value="p1")
player2 = LegitPlayer()
player2.end_of_game = mock.MagicMock()
player2.get_name = mock.MagicMock(return_value="p2")
player2.play_turn = mock.MagicMock(return_value="lolol")
player1guard = PlayerGuard(player1)
player2guard = PlayerGuard(player2)
uuids_to_player = {
self.uuidp1: player1guard,
self.uuidp2: player2guard
}
ref = Referee(uuids_to_player, self.uuids_to_name, self.obs_man)
result = ref.run_n_games(3)
player1.end_of_game.assert_called_once_with("p1")
player2.end_of_game.assert_not_called()
bad_players, game_results = result
expected_bad_players = [self.uuidp2]
for actual, expected in zip(bad_players, expected_bad_players):
self.assertEqual(actual, expected)
expected_game_results = [self.uuidp1]
for actual, expected in zip(game_results, expected_game_results):
self.assertEqual(actual, expected)
def test_n_games_invalid_turns(self):
"""tests that a player who gives invalid turns
always loses in a series of n games but all games are played
"""
player1 = LegitPlayer()
player1.end_of_game = mock.MagicMock()
player2 = BadTurnPlayer()
player2.end_of_game = mock.MagicMock()
player1guard = PlayerGuard(player1)
player2guard = PlayerGuard(player2)
uuids_to_player = {
self.uuidp1: player1guard,
self.uuidp2: player2guard
}
ref = Referee(uuids_to_player, self.uuids_to_name, self.obs_man)
result = ref.run_n_games(3)
self.assertEqual(player1.end_of_game.call_count, 1)
self.assertEqual(player2.end_of_game.call_count, 0)
player1.end_of_game.assert_called_with("p1")
bad_players, game_results = result
expected_bad_players = [self.uuidp2]
for actual, expected in zip(bad_players, expected_bad_players):
self.assertEqual(actual, expected)
expected_game_results = [self.uuidp1]
for actual, expected in zip(game_results, expected_game_results):
self.assertEqual(actual, expected)
def __init__(self, hostname, port, player, player_name):
""" Create a connection to the server and setup PlayerGuard.
:param String hostname: the name of the host
:param nat port: port number to connect to
:param Player player: the player that's playing over this
connection
:param String playername: name of the player
"""
self._player = PlayerGuard(player)
self._player_name = player_name
self._client_msger = ClientMessager(hostname, port)
self._relay_state = RelayState.REGISTRATION
self._our_uuid = uuid.uuid4()
self._opp_uuid = uuid.uuid4()
self._uuid_to_name = {self._our_uuid: player_name}
self._player.set_id(self._our_uuid)