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)
