def test__hash__shouldReturnDifferentValues__whenItemArgumentIsDifferent(self): player = anon_player() location = anon_location() target_a = Target(player, anon_item(), location) target_b = Target(player, anon_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__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__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__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__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__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__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__delete__shouldThrowException__whenRepositoryContainsItemsButNotTheDeletedOne( self): # Arrange self._item_repo.save(anon_item()) self._item_repo.save(anon_item()) # Act def action(): self._item_repo.delete(anon_item()) # Assert self.assertRaises(KeyError, action)
def test__save__shouldNotThrowException__whenProvidedValidItemArg(self): # Arrange item = anon_item() # Act self._item_repo.save(item)
def test__retrieve_all__shouldReturnAllSavedItems__whenMultipleItemsStored( self): # Arrange item1 = anon_item() item2 = anon_item() item3 = anon_item() self._item_repo.save(item1) self._item_repo.save(item2) self._item_repo.save(item3) # Act items = self._item_repo.retrieve_all() # Assert self.assertEqual({item1, item2, item3}, items)
def test__save__shouldNotThrowException__whenItemAlreadyExistsInRepo(self): # Arrange item = anon_item() self._item_repo.save(item) # Act self._item_repo.save(item)
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__delete__shouldRemoveItem__whenItemExistsInRepository(self): # Arrange item = anon_item() expected_item1 = anon_item() expected_item2 = anon_item() self._item_repo.save(expected_item1) self._item_repo.save(expected_item2) self._item_repo.save(item) # Act self._item_repo.delete(item) # Assert items = self._item_repo.retrieve_all() self.assertEqual({expected_item1, expected_item2}, items)
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__delete__shouldNotModifyEntries__whenDeleteCalledWithItemNotInRepo( self): # Arrange item1 = anon_item() item2 = anon_item() self._item_repo.save(item1) self._item_repo.save(item2) # Act try: self._item_repo.delete(anon_item()) except KeyError: pass # Assert items = self._item_repo.retrieve_all() self.assertEqual({item1, item2}, items)
def test__player__shouldReturnPlayer__whenAccessing(self): # Arrange expected_player = anon_player() target = Target(expected_player, anon_item(), anon_location()) # Act actual = target.player # Assert self.assertEquals(expected_player, actual)
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__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__item__shouldReturnItem__whenAccessing(self): # Arrange expected_item = anon_item() target = Target(anon_player(), expected_item, anon_location()) # Act actual = target.item # Assert self.assertEquals(expected_item, actual)
def test__location__shouldReturnLocation__whenAccessing(self): # Arrange expected_location = anon_location() target = Target(anon_player(), anon_item(), expected_location) # Act actual = target.location # Assert self.assertEquals(expected_location, actual)
def test__name__shouldRaiseException__whenAttemptingToSet(self): # Arrange item = anon_item() # Act # noinspection PyPropertyAccess def action(): item.name = anon_string() # Assert self.assertRaises(AttributeError, action)
def test__retrieve_all__shouldReturnSavedItem__whenOnlyOneItemStored(self): # Arrange expected_item = anon_item() self._item_repo.save(expected_item) # Act items = list(self._item_repo.retrieve_all()) # Assert self.assertEqual(1, len(items)) self.assertEqual(expected_item, items[0])
def test__save__shouldNotSaveDuplicateItem__whenItemAlreadyExistsInRepo( self): # Arrange item = anon_item() self._item_repo.save(item) # Act self._item_repo.save(item) # Assert items = self._item_repo.retrieve_all() self.assertEqual(1, len(items))
def test__hash__shouldReturnSameValue__whenConstructionIsIdentical(self): player = anon_player() item = anon_item() location = anon_location() target_a = Target(player, item, location) target_b = Target(player, item, location) # Act actual = hash(target_a) == hash(target_b) # Assert self.assertTrue(actual)
def test__equals__shouldReturnTrue__whenConstructionIsIdentical(self): # Arrange player = anon_player() item = anon_item() location = anon_location() target_a = Target(player, item, location) target_b = Target(player, item, location) # Act actual = (target_a == target_b) # Assert self.assertTrue(actual)
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__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__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 action(): game.mark_kill(player, Target(player, anon_item(), anon_location())) # Assert self.assertRaises(ValueError, action)