def test__status__shouldReturnCreated__whenGameJustConstructed(self): # Arrange game = anon_game() # Act actual = game.status # Assert self.assertEqual(GameState.CREATED, actual)
def test__end__shouldThrowException__whenCalledOnGameInCreatedState(self): # Arrange game = anon_game() # Act def action(): game.end() # Assert self.assertRaises(IllegalActionError, action)
def test__id__shouldReturnUuid__whenGameJustCreated(self): # Arrange game = anon_game() # Act game_id = game.id # Assert self.assertIsInstance(game_id, UUID)
def test__get_target__shouldThrowException__whenPlayerNotInGame(self): # ArrangeX game = anon_game() # Act def action(): game.get_target(anon_player()) # Assert self.assertRaises(ValueError, action)
def test__start__shouldModifyStatusToStarted__whenCalledOnGameInCreatedState(self): # Arrange game = anon_game() # Act game.start() # Assert actual = game.status self.assertEqual(GameState.STARTED, actual)
def test__start__shouldThrowException__whenCalledAfterGameAlreadyStarted(self): # Arrange game = anon_game() game.start() # Act def action(): game.start() # Assert self.assertRaises(IllegalActionError, action)
def test__get_target__shouldReturnTarget__whenGameCreated(self): # Arrange player = anon_player() game = anon_game(players={player, anon_player(), anon_player()}) # Act actual = game.get_target(player) # Assert self.assertIsNotNone(actual)
def test__end__shouldModifyStatusToEnded__whenCalledOnGameInStartedState(self): # Arrange game = anon_game() game.start() # Act game.end() # Assert self.assertEqual(GameState.ENDED, game.status)
def test__status__shouldReturnStarted__whenGameHasBeenStarted(self): # Arrange game = anon_game() game.start() # Act actual = game.status # Assert self.assertEqual(GameState.STARTED, actual)
def test__id__shouldNotChange__whenGameStarts(self): # Arrange game = anon_game() expected_id = game.id game.start() # Act actual = game.id # Assert self.assertEqual(expected_id, actual)
def test__get_score__shouldReturnZeroForEveryPlayer__whenGameJustCreated(self): # Arrange players = {anon_player(), anon_player(), anon_player()} game = anon_game(players=players) # Act actual = [game.get_score(player) for player in players] # Assert for score in actual: self.assertEqual(0, score)
def test__mark_kill__shouldThrowException__whenTargetPlayerIsKillingPlayer(self): # Arrange player = anon_player() game = anon_game(players={player, anon_player(), anon_player()}) game.start() # Act def action(): game.mark_kill(player, Target(player, anon_item(), anon_location())) # Assert self.assertRaises(ValueError, action)
def test__get_target__shouldReturnSameTarget__whenCalledAfterGameStarted(self): # Arrange player = anon_player() game = anon_game(players={player, anon_player(), anon_player()}) expected_target = game.get_target(player) game.start() # Act actual = game.get_target(player) # Assert self.assertEqual(expected_target, actual)
def test__mark_kill__shouldThrowException__whenPlayerNotInGameAndGameStarted(self): # Arrange player = anon_player() game = anon_game(players={player, anon_player()}) valid_target = game.get_target(player) game.start() # Act def action(): game.mark_kill(anon_player(), valid_target) # Assert self.assertRaises(ValueError, action)
def test__mark_kill__shouldSetLastPlayersTargetToHimself__whenOnlyOnePlayerLeft(self): # Arrange player = anon_player() game = anon_game(players={player, anon_player()}) target = game.get_target(player) game.start() # Act game.mark_kill(player, target) # Assert self.assertEqual(player, game.get_target(player).player)
def test__mark_kill__shouldRemovePlayersTarget__whenPlayerSuccessfullyKilled(self): # Arrange player = anon_player() game = anon_game(players={player, anon_player(), anon_player()}) game.start() target = game.get_target(player) killed_player = target.player # Act game.mark_kill(player, target) # Assert self.assertRaises(ValueError, lambda: game.get_target(killed_player))
def test__mark_kill__shouldGiveKilledPlayersTargetToKiller__whenKilledPlayerHasTargetThatIsNotKiller(self): # Arrange player = anon_player() game = anon_game(players={player, anon_player(), anon_player()}) target = game.get_target(player) expected_next_target = game.get_target(target.player) game.start() # Act game.mark_kill(player, target) # Assert self.assertEqual(expected_next_target, game.get_target(player))
def test__mark_kill__shouldEndGame__whenAllPlayersButLastHaveBeenKilled(self): # Arrange player = anon_player() game = anon_game(players={player, anon_player(), anon_player()}) game.start() first_target = game.get_target(player) game.mark_kill(player, first_target) final_target = game.get_target(player) # Act game.mark_kill(player, final_target) # Assert self.assertEqual(GameState.ENDED, game.status)
def test__get_target__shouldThrowException__whenPlayerIsDead(self): # Arrange player = anon_player() game = anon_game(players={player, anon_player(), anon_player()}) target = game.get_target(player) dead_player = target.player game.start() game.mark_kill(player, target) # Act def action(): game.get_target(dead_player) # Assert self.assertRaises(ValueError, action)
def test__mark_kill__shouldModifyTarget__whenTargetIsCorrectAndGameIsStarted(self): # Arrange player1 = anon_player() player2 = anon_player() player3 = anon_player() game = anon_game(players={player1, player2, player3}) target = game.get_target(player1) expected_next_target_player = player2 if target.player != player2 else player3 game.start() # Act game.mark_kill(player1, target) # Assert self.assertEqual(expected_next_target_player, game.get_target(player1).player)
def test__get_score__shouldIncrement__whenPlayerKillsSuccessiveTargets(self): # Arrange player = anon_player() game = anon_game(players={player, anon_player(), anon_player()}) game.start() target = game.get_target(player) game.mark_kill(player, target) target = game.get_target(player) game.mark_kill(player, target) # Act actual = game.get_score(player) # Assert self.assertEqual(2, actual)
def test__is_alive__shouldReturnCorrectBool__whenPlayersAreStillAliveAndGameIsNotStarted(self): # Arrange player1 = anon_player() game = anon_game(players={player1, anon_player(), anon_player()}) player2 = game.get_target(player1).player player3 = game.get_target(player2).player # Act actual1 = game.is_alive(player1) actual2 = game.is_alive(player2) actual3 = game.is_alive(player3) # Assert self.assertTrue(actual1) self.assertTrue(actual2) self.assertTrue(actual3)
def test__mark_kill__shouldNotModifyTarget__whenTargetIsCorrectButGameHasEnded(self): # Arrange player1 = anon_player() player2 = anon_player() player3 = anon_player() game = anon_game(players={player1, player2, player3}) expected_target = game.get_target(player1) game.start() game.end() # Act try: game.mark_kill(player1, expected_target) except IllegalActionError: pass # Assert self.assertEqual(expected_target, game.get_target(player1))
def test__is_alive__shouldReturnCorrectBool__whenSomePlayersAreDeadAndGameIsActive(self): # Arrange player1 = anon_player() game = anon_game(players={player1, anon_player(), anon_player()}) player1_target = game.get_target(player1) player2 = player1_target.player player3 = game.get_target(player2).player game.start() game.mark_kill(player1, player1_target) # Act actual1 = game.is_alive(player1) actual2 = game.is_alive(player2) actual3 = game.is_alive(player3) # Assert self.assertTrue(actual1) self.assertFalse(actual2) self.assertTrue(actual3)
def test__mark_kill__shouldNotModifyTarget__whenTargetIsIncorrectAndGameIsNotStarted(self): # Arrange player1 = anon_player() player2 = anon_player() player3 = anon_player() game = anon_game(players={player1, player2, player3}) target = game.get_target(player1) invalid_target = Target(player2 if target.player != player2 else player3, target.item, target.location) # Act try: game.mark_kill(player1, invalid_target) except IllegalActionError: pass # Assert p1_actual_target = game.get_target(player1) self.assertEqual(target, p1_actual_target)