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__constructor__shouldThrowException__whenNumTargetArgIsLessThanOne(self):
# Arrange
players = {anon_player(), anon_player(), anon_player()}
items = {anon_item(), anon_item(), anon_item()}
locations = {anon_location(), anon_location(), anon_location()}
# Act
def action(): Game(players, items, locations, num_targets=0)
# Assert
self.assertRaises(ValueError, action)
def test__hash__shouldReturnDifferentValues__whenPlayerArgumentIsDifferent(self):
item = anon_item()
location = anon_location()
target_a = Target(anon_player(), item, location)
target_b = Target(anon_player(), item, location)
# Act
actual = hash(target_a) == hash(target_b)
# Assert
self.assertFalse(actual)
def test__constructor__shouldThrowException__whenLessThanOneLocationProvided(self):
# Arrange
players = {anon_player(), anon_player(), anon_player()}
items = {anon_item(), anon_item(), anon_item()}
locations = set()
# Act
def action(): Game(players, items, locations)
# Assert
self.assertRaises(ValueError, action)
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__constructor__shouldThrowException__whenNumTargetArgIsNotOne(self):
# TODO GH 2018-Sep-15: Add functionality to support multiple targets and change this test to match new behaviour
# Arrange
players = {anon_player(), anon_player(), anon_player()}
items = {anon_item(), anon_item(), anon_item()}
locations = {anon_location(), anon_location(), anon_location()}
# Act
def action(): Game(players, items, locations, num_targets=2)
# Assert
self.assertRaises(NotImplementedError, action)
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__constructor__shouldThrowException__whenLocationsArgIsNotSetOfLocations(self):
# Arrange
players = {anon_player(), anon_player(), anon_player()}
items = {anon_item(), anon_item(), anon_item()}
invalid_locations = {2, 3, 4}
# Act
# noinspection PyTypeChecker
def action(): Game(players, items, invalid_locations)
# Assert
self.assertRaises(TypeError, action)
def test__constructor__shouldGenerateUniqueIdentifiers__whenGameInfoIsOtherwiseIdentical(self):
# Arrange
players = {anon_player(), anon_player(), anon_player()}
items = {anon_item(), anon_item(), anon_item()}
locations = {anon_location(), anon_location(), anon_location()}
# Act
game1 = Game(players, items, locations)
game2 = Game(players, items, locations)
# Assert
self.assertNotEqual(game1.id, game2.id)
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__constructor__shouldThrowException__whenNumTargetsArgIsNotAnInt(self):
# Arrange
players = {anon_player(), anon_player(), anon_player()}
items = {anon_item(), anon_item(), anon_item()}
locations = {anon_location(), anon_location(), anon_location()}
# Act
# noinspection PyTypeChecker
def action(): Game(players, items, locations, num_targets=None)
# Assert
self.assertRaises(TypeError, 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__shouldThrowException__whenGameIsNotStarted(self):
# Arrange
player1 = anon_player()
player2 = anon_player()
location = anon_location()
item = anon_item()
game = Game({player1, player2}, {item}, {location})
# Act
def action(): game.mark_kill(player1, Target(player2, item, location))
# Assert
self.assertRaises(IllegalActionError, action)
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__equals__shouldReturnFalse__whenGamesCreatedWithIdenticalOptions(self):
# Arrange
players = {anon_player(), anon_player(), anon_player()}
items = {anon_item(), anon_item(), anon_item()}
locations = {anon_location(), anon_location(), anon_location()}
game1 = Game(players, items, locations)
game2 = Game(players, items, locations)
# Act
actual = (game1 == game2)
# Assert
self.assertFalse(actual)
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__get_score__shouldReturnOne__whenPlayerSuccessfullyKillsTarget(self):
# Arrange
first_player = anon_player()
target_player = anon_player()
target_item = anon_item()
target_location = anon_location()
game = Game({first_player, target_player}, {target_item}, {target_location})
game.start()
game.mark_kill(first_player, Target(target_player, target_item, target_location))
# Act
actual = game.get_score(first_player)
# Assert
self.assertEqual(1, actual)
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__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__mark_kill__shouldRaiseException__whenPlayerIsNotInGame(self):
# Arrange
player1 = anon_player()
player2 = anon_player()
location = anon_location()
item1 = anon_item()
item2 = anon_item()
game = Game({player1, player2}, {item1, item2}, {location})
target = game.get_target(player1)
game.start()
# Act
def action(): game.mark_kill(anon_player(), target)
# Assert
self.assertRaises(ValueError, action)
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__shouldRaiseException__whenTargetIsIncorrect(self):
# Arrange
player1 = anon_player()
player2 = anon_player()
location = anon_location()
item1 = anon_item()
item2 = anon_item()
game = Game({player1, player2}, {item1, item2}, {location})
target = game.get_target(player1)
other_item = item1 if target.item != item1 else item2
game.start()
# Act
def action(): game.mark_kill(player1, Target(player2, other_item, location))
# Assert
self.assertRaises(ValueError, action)
def test__mark_kill__shouldNotModifyTarget__whenTargetIsCorrectButGameIsNotStarted(self):
# Arrange
player1 = anon_player()
players = {player1, anon_player(), anon_player()}
location = anon_location()
item = anon_item()
game = Game(players, {item}, {location})
p1_initial_target = game.get_target(player1)
# Act
try:
game.mark_kill(player1, p1_initial_target)
except IllegalActionError:
pass
# Assert
p1_actual_target_player = game.get_target(player1).player
self.assertEqual(p1_initial_target.player, p1_actual_target_player)
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__constructor__shouldGenerateSingleCompleteLoopOfPlayerTargets__whenNumTargetsArgIsOne(self):
# Arrange
initial_player = anon_player()
players = {initial_player, anon_player(), anon_player(), anon_player(), anon_player(), anon_player()}
items = {anon_item(), anon_item(), anon_item()}
locations = {anon_location(), anon_location(), anon_location()}
# Act
game = Game(players, items, locations, num_targets=1)
# Assert
current_player = initial_player
seen_players = set()
for index in range(0, len(players)):
next_player = game.get_target(current_player).player
self.assertNotIn(next_player, seen_players)
seen_players.add(next_player)
current_player = next_player
self.assertEqual(current_player, initial_player)
def test__constructor__shouldGenerateTargetsForEachPlayerFromProvidedOptions__whenGameJustCreated(self):
# Arrange
player1 = anon_player()
player2 = anon_player()
items = {anon_item(), anon_item(), anon_item()}
locations = {anon_location(), anon_location(), anon_location()}
# Act
game = Game({player1, player2}, items, locations)
# Assert
player1_target = game.get_target(player1)
player2_target = game.get_target(player2)
self.assertEqual(player2, player1_target.player)
self.assertEqual(player1, player2_target.player)
self.assertIn(player1_target.item, items)
self.assertIn(player2_target.item, items)
self.assertIn(player2_target.location, locations)
self.assertIn(player2_target.location, locations)
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)
