def test_show_winners(self):
"""
Test being informed of winners
"""
player = BasicPlayer()
player.inform_of_winners([PlayerColor.RED, PlayerColor.WHITE])
self.assertEqual([PlayerColor.RED, PlayerColor.WHITE], player.winners)
def test_show_other_players(self):
"""
Test showing other players colors
"""
player = BasicPlayer()
player.show_other_players_colors([PlayerColor.RED, PlayerColor.WHITE])
self.assertEqual([PlayerColor.RED, PlayerColor.WHITE], player.other_colors)
def test_assign_color(self):
"""
Test assigning a color to a player
"""
player = BasicPlayer()
player.assign_color(PlayerColor.RED)
self.assertEqual(PlayerColor.RED, player.color)
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_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_basic_placement(self):
"""
Test getting basic placement from this player.
"""
test_board = FishBoardModel.create_with_same_fish_amount(4, 3, 3)
test_state = FishGameStateFactory.create_place_penguins_state(test_board,
[(PlayerColor.RED, []),
(PlayerColor.WHITE, [])])
player = BasicPlayer()
placement = player.player_place_penguin(test_state)
self.assertEqual((0, 0), placement)
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_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 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 test_basic_move(self):
"""
Test getting a basic move from this player
"""
board_json = [[1, 1, 1], [2, 3, 4], [1, 1, 1]]
board = THHelper.parse_board(board_json)
test_board_valid_row1 = [(0, 0), (2, 0), (4, 0)]
test_board_valid_row2 = [(1, 1), (3, 1), (5, 1)]
test_state = FishGameStateFactory.create_move_penguins_state(board,
[(PlayerColor.RED, test_board_valid_row1, 0),
(PlayerColor.BLACK, test_board_valid_row2, 0)],
check_penguin_amount=False,
turn=PlayerColor.BLACK)
player = BasicPlayer()
placement = player.player_move_penguin(test_state)
self.assertEqual(((5, 1), (4, 2)), placement)
def test_run_tournament(self):
server = TCPServer('127.0.0.1', 1234)
server.configure_server()
player_list = []
for i in sorted(range(0, 3)):
interface = BasicPlayer()
player_list.append((interface, i))
manager = Manager(player_list)
server.tournament_manager = manager
self.assertEqual(server.run_tournament(), [1, 0])
def test_assign_players_5(self):
player_list = []
for i in sorted(range(0, 5)):
interface = BasicPlayer()
player_list.append((interface, i))
manager = Manager(player_list)
assignments = manager.assign_players(manager.player_pool)
self.assertEqual(len(assignments[0]), 3)
self.assertEqual(len(assignments[1]), 2)
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_passing_small_pool(self):
"""
Purpose: Tests passing a pool of players that is less than enough to run a game
Signature: Void -> Void
"""
with self.assertRaises(ValueError):
player_list = []
for i in sorted(range(0, 1)):
interface = BasicPlayer()
player_list.append((interface, i))
manager = Manager(player_list)
def test_is_tournament_over_one_remaining_player(self):
player_list = []
for i in sorted(range(0, 8)):
interface = BasicPlayer()
player_list.append((interface, i))
manager = Manager(player_list)
manager.get_winners_and_cheaters = MagicMock(
return_value=([player_list[0]], []))
# manager.get_winners = MagicMock(return_value=[player_list[0]])
manager.run_tournament()
# make only one winner
self.assertEqual(manager.round, 1)
def test_run_tournament_large(self):
"""
Purpose: Runs a tournament round given a list of passed players. Checks that the tournament has finished at the
end, and checks if the remaining player pool is less than or equal to the starting pool.
Signature: Void -> Void
"""
player_list = []
for i in sorted(range(0, 20)):
interface = BasicPlayer()
player_list.append((interface, i))
manager = Manager(player_list)
manager.run_tournament()
# Checks if minimum amount of rounds has passed
self.assertTrue(manager.round >= 2)
def test_is_tournament_over_3_remaining_players_with_tie(self):
player_list = []
for i in sorted(range(0, 3)):
interface = BasicPlayer()
player_list.append((interface, i))
manager = Manager(player_list)
manager.get_winners_and_cheaters = MagicMock(
return_value=([player_list[0], player_list[1]], []))
manager.run_tournament()
#have ties with 4 players left
self.assertEqual(manager.round, 2)
self.assertEqual(manager.last_round_winners,
[player_list[0], player_list[1]])
def test_assign_players_under_max(self):
"""
Purpose: Test assigning the players when the player pool is less than than maximum number of players per game
Signature: Void -> Void
"""
player_list = []
for i in sorted(range(0, 2)):
interface = BasicPlayer()
player_list.append((interface, i))
manager = Manager(player_list)
assignments = manager.assign_players(manager.player_pool,
max_players=4)
self.assertEqual(len(assignments), 1)
def test_run_tournament(self):
"""
Purpose: Runs a tournament round given a list of passed players. Checks that the tournament has finished at the
end, and checks if the remaining player pool is less than or equal to the starting pool.
Signature: Void -> Void
"""
player_list = []
for i in sorted(range(0, 3)):
interface = BasicPlayer()
player_list.append((interface, i))
manager = Manager(player_list)
manager.run_tournament()
# Checks that the winning player pool is less than or equal to the initial passed pool
self.assertTrue(len(player_list) >= len(manager.player_pool))
# Checks if rounds advanced
self.assertTrue(manager.round > 0)
def test_assign_players_non_default(self):
"""
Purpose: Test assigning the players with less than the default (4) players allowed per a single game.
Signature: Void -> Void
"""
player_list = []
for i in sorted(range(0, 4)):
interface = BasicPlayer()
player_list.append((interface, i))
manager = Manager(player_list)
assignments = manager.assign_players(manager.player_pool,
max_players=2)
for assignment in assignments:
self.assertNotEqual(len(assignment), 1)
self.assertNotEqual(len(assignment), 0)
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
def test_is_tournament_over_duplicate_round_winners(self):
"""
Purpose: Checks to determine if a tournament has reached the end condition.
Signature: Void -> Void.
"""
player_list = []
for i in sorted(range(0, 8)):
interface = BasicPlayer()
player_list.append((interface, i))
manager = Manager(player_list)
manager.get_winners_and_cheaters = MagicMock(return_value=(player_list,
[]))
manager.last_round_winners = player_list
manager.run_tournament()
# get last round winners to equal current round winners
self.assertEqual(manager.round, 1)
def test_assign_players_max(self):
"""
Purpose: Test assigning the players with the maximum number of players in a game, 4
Signature: Void -> Void
"""
player_list = []
for i in sorted(range(0, 14)):
interface = BasicPlayer()
player_list.append((interface, i))
manager = Manager(player_list)
assignments = manager.assign_players(manager.player_pool)
for assignment in assignments:
self.assertNotEqual(len(assignment), 1)
self.assertNotEqual(len(assignment), 0)
self.assertEqual(len(assignments[0]), 4)
self.assertEqual(len(assignments[len(assignments) - 1]), 2)
class RefTests(unittest.TestCase):
"""
This is a class that will run different tests to unit-test our referee
"""
def raise_exception_while_finding_action(self, fish_game_state):
"""This mocks raising an exception on the players side"""
raise Exception('Boom')
# Here we define misbehaving players that can be used to mock a player making an invalid placement in a game
bad_player_invalid_placement = BasicPlayer()
bad_player_invalid_placement.player_place_penguin = MagicMock(return_value=(-1, -1))
bad_player_invalid_move = BasicPlayer()
bad_player_invalid_move.player_move_penguin = MagicMock(return_value=((-1, -1), (0, 0)))
# Here we define misbehaving players for failing types returned
bad_player_failing_type_placement = BasicPlayer()
bad_player_failing_type_placement.player_place_penguin = MagicMock(return_value=((1, 1), (2, 0)))
bad_player_failing_type_movement = BasicPlayer()
bad_player_failing_type_movement.player_move_penguin = MagicMock(return_value=(0, 0))
# Here we define misbehaving players for throwing an internal exception
bad_player_exception_placement = BasicPlayer()
bad_player_exception_placement.player_place_penguin = MagicMock(side_effect=raise_exception_while_finding_action)
bad_player_exception_movement = BasicPlayer()
bad_player_exception_movement.player_move_penguin = MagicMock(side_effect=raise_exception_while_finding_action)
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
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 test_init_board_4_player(self):
"""
Test basic properties about initializing a game with 4 logical players
"""
ref = Referee()
players = [(BasicPlayer(), 1), (BasicPlayer(), 2), (BasicPlayer(), 3), (BasicPlayer(), 4)]
ref._init_board(5, 5, players)
# Test the amount of players, order according to default order and turn and phase
self.assertEqual(2, ref.amount_penguins_per_player)
self.assertEqual([PlayerColor.RED, PlayerColor.WHITE,
PlayerColor.BROWN, PlayerColor.BLACK], 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,
PlayerColor.BROWN, PlayerColor.BLACK], ref.current_game_state.get_player_order())
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 test_run_placement_turn_valid(self):
"""
Test running a valid placement turn with no issues
"""
ref = self.set_up_game_phases(5, 5)
# Test that a penguin is added and turn is incremented
self.assertEqual(0, len(ref.current_game_state.get_penguins_for_player(PlayerColor.RED)))
ref._run_placement_turn()
self.assertEqual(1, len(ref.current_game_state.get_penguins_for_player(PlayerColor.RED)))
self.assertEqual(PlayerColor.WHITE, ref.current_game_state.get_current_turn())
def test_run_placement_turn_invalid(self):
"""
Test running a placement turn where someone makes an invalid move (a bad logical move)
"""
ref = self.set_up_game_phases(5, 5, num_players=4, bad_player_obj=RefTests.bad_player_invalid_placement)
ref._run_placement_turn()
# Test that player is incremented, and player is kicked when cheating
self.assertEqual(PlayerColor.WHITE, ref.current_game_state.get_current_turn())
self.assertEqual([PlayerColor.RED], ref.kicked_players[KickedPlayerType.CHEATING])
self.assertFalse(PlayerColor.RED in ref.current_game_state.get_player_order())
def test_run_placement_turn_failing_type(self):
"""
Test running a placement turn with failing type returned
"""
ref = self.set_up_game_phases(5, 5, num_players=4, bad_player_obj=RefTests.bad_player_failing_type_placement)
ref._run_placement_turn()
# Test that player is incremented, and player is kicked when failing
self.assertEqual(PlayerColor.WHITE, ref.current_game_state.get_current_turn())
self.assertEqual([PlayerColor.RED], ref.kicked_players[KickedPlayerType.FAILING])
self.assertFalse(PlayerColor.RED in ref.current_game_state.get_player_order())
def test_run_placement_turn_failing_error(self):
"""
Test running a placement turn with internal error on the player side.
"""
ref = self.set_up_game_phases(5, 5, num_players=4, bad_player_obj=RefTests.bad_player_exception_placement)
ref._run_placement_turn()
# Test that player is incremented, and player is kicked when failing
self.assertEqual(PlayerColor.WHITE, ref.current_game_state.get_current_turn())
self.assertEqual([PlayerColor.RED], ref.kicked_players[KickedPlayerType.FAILING])
self.assertFalse(PlayerColor.RED in ref.current_game_state.get_player_order())
def test_run_movement_turn_valid(self):
"""
Test running a valid movement turn with no issues
"""
# player that throws an exception when trying to place it
ref = self.set_up_game_phases(5, 5, run_placement_phase=True)
initial_pengs = ref.current_game_state.get_penguins_for_player(player_color=PlayerColor.RED)
ref._run_movement_turn()
moved_pengs = ref.current_game_state.get_penguins_for_player(player_color=PlayerColor.RED)
# Test lists of penguins and number of fish
self.assertNotEqual(initial_pengs, moved_pengs)
self.assertGreater(ref.current_game_state.get_fish_for_player(player_color=PlayerColor.RED), 0)
def test_run_movement_turn_skip(self):
"""
Test running a movement turn where someone is skipped
"""
# player that throws an exception when trying to place it
ref = self.set_up_game_phases(3, 3, num_players=4, run_placement_phase=True)
# Set player color to black, they can not go and will be skipped
ref.current_game_state.set_turn(PlayerColor.BLACK)
ref.current_game_tree = FishGameTree(copy.deepcopy(ref.current_game_state))
initial_pengs = ref.current_game_state.get_penguins_for_player(player_color=PlayerColor.BLACK)
ref._run_movement_turn()
# Player 4 can't go and is skipped so they have no penguins
moved_pengs = ref.current_game_state.get_penguins_for_player(player_color=PlayerColor.BLACK)
self.assertEqual(initial_pengs, moved_pengs)
self.assertEqual(0, ref.current_game_state.get_fish_for_player(player_color=PlayerColor.BLACK))
def test_run_movement_turn_invalid(self):
"""
Test running a movement turn where someone makes an invalid move
"""
ref = self.set_up_game_phases(4, 4, num_players=2, run_placement_phase=True,
bad_player_obj=RefTests.bad_player_invalid_move)
ref._run_movement_turn()
# Player 4 is making an invalid move so they are put in cheating category.
self.assertIsNone(ref.current_game_state.get_fish_for_player(PlayerColor.RED))
self.assertEqual({KickedPlayerType.CHEATING: [PlayerColor.RED], KickedPlayerType.FAILING: []}, ref.kicked_players)
def test_run_movement_turn_failing_type(self):
"""
Test running a movement turn with failing type
"""
ref = self.set_up_game_phases(4, 4, num_players=2, run_placement_phase=True,
bad_player_obj=RefTests.bad_player_failing_type_movement)
ref._run_movement_turn()
# Player 4 is making a move with a bad type so they are put in failing category.
self.assertIsNone(ref.current_game_state.get_fish_for_player(PlayerColor.RED))
self.assertEqual({KickedPlayerType.FAILING: [PlayerColor.RED], KickedPlayerType.CHEATING: []}, ref.kicked_players)
def test_run_movement_turn_failing_error(self):
"""
Test running a movement turn with internal error on its side.
"""
# player that makes an invalid move
ref = self.set_up_game_phases(4, 4, num_players=2, run_placement_phase=True,
bad_player_obj=RefTests.bad_player_exception_movement)
ref._run_movement_turn()
# Player 4 can't go and is skipped so they have no penguins
self.assertIsNone(ref.current_game_state.get_fish_for_player(PlayerColor.RED))
self.assertEqual({KickedPlayerType.FAILING: [PlayerColor.RED], KickedPlayerType.CHEATING: []}, ref.kicked_players)
def test_run_placement_round_valid(self):
"""
Test running a whole placement round with no errors for placement
"""
ref = self.set_up_game_phases(5, 5)
ref._run_placement_round()
# Test a new penguin gets placed each round
for color in ref.current_game_state.get_player_order():
self.assertEqual(1, len(ref.current_game_state.get_penguins_for_player(color)))
ref._run_placement_round()
for color in ref.current_game_state.get_player_order():
self.assertEqual(2, len(ref.current_game_state.get_penguins_for_player(color)))
def test_run_placement_round_invalid(self):
"""
Test running a whole placement round with errors for placement
"""
# player that makes an invalid move
ref = self.set_up_game_phases(5, 5, num_players=4, bad_player_obj=RefTests.bad_player_failing_type_placement)
ref._run_placement_round()
# Check that player gets kicked out but other players place penguin
self.assertEqual(3, len(ref.current_game_state.get_player_order()))
self.assertEqual(1, len(ref.kicked_players[KickedPlayerType.FAILING]))
for color in ref.current_game_state.get_player_order():
self.assertEqual(1, len(ref.current_game_state.get_penguins_for_player(color)))
# Check that all other players can keep playing
ref._run_placement_round()
for color in ref.current_game_state.get_player_order():
self.assertEqual(2, len(ref.current_game_state.get_penguins_for_player(color)))
self.assertEqual(3, len(ref.current_game_state.get_player_order()))
self.assertEqual(1, len(ref.kicked_players[KickedPlayerType.FAILING]))
def test_run_movement_round_valid(self):
"""
Test running a whole movement round with no errors for placement
"""
ref = self.set_up_game_phases(5, 5, run_placement_phase=True)
penguins_for_red_init = ref.current_game_state.get_penguins_for_player(PlayerColor.RED)
penguins_for_white_init = ref.current_game_state.get_penguins_for_player(PlayerColor.WHITE)
ref._run_movement_round()
penguins_for_red_new = ref.current_game_state.get_penguins_for_player(PlayerColor.RED)
penguins_for_white_new = ref.current_game_state.get_penguins_for_player(PlayerColor.WHITE)
# Test new penguins
self.assertNotEqual(penguins_for_red_init, penguins_for_red_new)
self.assertNotEqual(penguins_for_white_init, penguins_for_white_new)
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_run_movement_round_invalid(self):
"""
Test running a movement round with an invalid penguin
"""
ref = self.set_up_game_phases(5, 5, num_players=4, run_placement_phase=True,
bad_player_obj=RefTests.bad_player_invalid_move)
penguins_for_white_init = ref.current_game_state.get_penguins_for_player(PlayerColor.WHITE)
ref._run_movement_round()
penguins_for_white_new = ref.current_game_state.get_penguins_for_player(PlayerColor.WHITE)
# Test kicking a player from an invalid movement round
self.assertNotEqual(penguins_for_white_init, penguins_for_white_new)
self.assertGreater(ref.current_game_state.get_fish_for_player(PlayerColor.WHITE), 0)
self.assertFalse(PlayerColor.RED in ref.current_game_state.get_player_order())
self.assertEqual(3, len(ref.current_game_state.get_player_order()))
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_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_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_no_players_left_in_game_placement(self):
"""
Tests running a game with no players left in the game and that it exits out of the game if that happens in placement phase.
"""
players = [(RefTests.bad_player_invalid_placement, 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([], ref.winners)
self.assertListEqual([PlayerColor.RED, PlayerColor.WHITE], ref.kicked_players[KickedPlayerType.CHEATING])
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)
