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_no_players_left_in_game_movement(self):
"""
Tests running a game with no players left in the game and that it exits out of the game in movement phase
"""
players = [(RefTests.bad_player_invalid_move, 1), (RefTests.bad_player_invalid_move, 2)]
ref = Referee()
ref.initialize_and_run_game(3, 3, players)
self.assertEqual(GamePhase.END_GAME, ref.current_game_state.get_game_phase())
self.assertEqual([], ref.winners)
self.assertListEqual([PlayerColor.RED, PlayerColor.WHITE], ref.kicked_players[KickedPlayerType.CHEATING])
def test_run_larger_game(self):
"""
Tests running a larger more non-trivial game
"""
players = [(BasicPlayer(), 1), (BasicPlayer(), 2)]
ref = Referee()
ref.initialize_and_run_game(7, 4, players)
self.assertEqual(GamePhase.END_GAME, ref.current_game_state.get_game_phase())
self.assertTrue(PlayerColor.RED in ref.winners or PlayerColor.WHITE in ref.winners)
self.assertGreater(ref.current_game_state.get_fish_for_player(PlayerColor.RED), 0)
self.assertGreater(ref.current_game_state.get_fish_for_player(PlayerColor.WHITE), 0)
def test_single_player_left_game(self):
"""
Tests running a game when only a single player left
"""
players = [(BasicPlayer(), 1), (RefTests.bad_player_invalid_placement, 2)]
ref = Referee()
ref.initialize_and_run_game(3, 3, players)
self.assertEqual(GamePhase.END_GAME, ref.current_game_state.get_game_phase())
self.assertEqual([PlayerColor.RED], ref.winners)
self.assertGreater(ref.current_game_state.get_fish_for_player(PlayerColor.RED), 0)
self.assertEqual([PlayerColor.WHITE], ref.kicked_players[KickedPlayerType.CHEATING])
def test_run_whole_basic_game_multiple_winners(self):
"""
Test running a whole game and getting 2 winners
"""
players = [(BasicPlayer(), 1), (BasicPlayer(), 2), (BasicPlayer(), 3)]
ref = Referee()
ref.initialize_and_run_game(3, 3, players)
self.assertEqual(GamePhase.END_GAME, ref.current_game_state.get_game_phase())
self.assertEqual([PlayerColor.RED, PlayerColor.WHITE, PlayerColor.BROWN], ref.winners)
self.assertEqual([], ref.kicked_players[KickedPlayerType.FAILING])
self.assertEqual([], ref.kicked_players[KickedPlayerType.CHEATING])
def test_run_whole_basic_game(self):
"""
Test running a whole game and getting a winner
"""
players = [(BasicPlayer(), 1), (BasicPlayer(), 2)]
ref = Referee()
ref.initialize_and_run_game(3, 3, players)
# In this 3x3 board only one player can move so RED will always win
self.assertEqual(GamePhase.END_GAME, ref.current_game_state.get_game_phase())
self.assertEqual([PlayerColor.RED], ref.winners)
self.assertEqual([], ref.kicked_players[KickedPlayerType.FAILING])
self.assertEqual([], ref.kicked_players[KickedPlayerType.CHEATING])
def test_init_board_2_player(self):
"""
Test basic properties about initializing a game with 2 logical players
"""
ref = Referee()
players = [(BasicPlayer(), 1), (BasicPlayer(), 2)]
ref._init_board(3, 3, players)
# Test the amount of players, order according to default order and turn and phase
self.assertEqual(4, ref.amount_penguins_per_player)
self.assertEqual([PlayerColor.RED, PlayerColor.WHITE], list(ref.players.keys()))
self.assertEqual(PlayerColor.RED, ref.current_game_state.get_current_turn())
self.assertEqual(GamePhase.PLACE_PENGUINS, ref.current_game_state.get_game_phase())
self.assertEqual([PlayerColor.RED, PlayerColor.WHITE], ref.current_game_state.get_player_order())
def _create_round(allocations):
"""
Purpose: Creates and runs the round of the Fish game given player allocations. Creates multiple games,
initializes them, and runs the games in order to get the winners/results.
Signature: List[List[LogicalPlayers]] -> Dict[Referee]
:param allocations: The determined player allocations for a single game
:return rounds: Dictionary of referees that have finished each game
"""
rounds = {}
for i in range(len(allocations)):
new_ref = Referee()
state = FishGameStateFactory().create_game_state_with_num_fish(
row=5,
col=5,
num_fish=2,
player_colors=FishGameStateFactory.
DEFAULT_COLOR_ORDER[:len(allocations[i])])
new_ref.initialize_and_run_from_game_state(allocations[i], state)
rounds[i] = new_ref
if new_ref.current_game_state.get_game_phase(
) != GamePhase.END_GAME:
raise ValueError("Game has not reached the end.")
return rounds
def test_kick_player_place_penguins(self):
"""
Test kicking a player in the place_penguins state
"""
ref = Referee()
players = [(BasicPlayer(), 1), (BasicPlayer(), 2), (BasicPlayer(), 3), (BasicPlayer(), 4)]
ref._init_board(5, 5, players)
ref._add_kicked_player(PlayerColor.RED, GamePhase.PLACE_PENGUINS, cheating=True)
# Test kicking a player functionality works well
self.assertEqual({KickedPlayerType.CHEATING: [PlayerColor.RED], KickedPlayerType.FAILING: []}, ref.kicked_players)
self.assertEqual({KickedPlayerType.CHEATING: [PlayerColor.RED], KickedPlayerType.FAILING: []}, ref.kicked_players)
self.assertFalse(PlayerColor.RED in ref.current_game_state.get_player_order())
self.assertFalse(PlayerColor.RED in ref.players.keys())
def set_up_game_phases(self, rows, columns, num_players=2, run_placement_phase=False, bad_player_obj=None):
"""
Purpose: Set up basic game phases for use in testing movement and placement phases
Signature: Int Int Int Bool PlayerInterface -> Referee
"""
ref = Referee()
players = []
for i in range(num_players):
if bad_player_obj and i == 0:
append_obj = bad_player_obj, i + 1
else:
append_obj = BasicPlayer(), i + 1
players.append(append_obj)
ref._init_board(rows, columns, players)
if run_placement_phase:
ref._run_placement_phase()
return ref
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]))