public void CleanUpExistingRecords()
{
using (NemeStatsDbContext dbContext = new NemeStatsDbContext())
{
using (NemeStatsDataContext dataContext = new NemeStatsDataContext(dbContext, new SecuredEntityValidatorFactory()))
{
var games = dataContext.GetQueryable<GameDefinition>()
.Where(game => game.BoardGameGeekGameDefinitionId == null)
.ToList();
var bggSearcher = new BoardGameGeekClient(new ApiDownloaderService(), new RollbarClient());
int updateCount = 0;
foreach (GameDefinition game in games)
{
var bggResults = bggSearcher.SearchBoardGames(game.Name.Trim(), true);
if (bggResults.Count() == 1)
{
game.BoardGameGeekGameDefinitionId = bggResults.First().BoardGameId;
ApplicationUser user = new ApplicationUser
{
CurrentGamingGroupId = game.GamingGroupId
};
dataContext.Save(game, user);
dataContext.CommitAllChanges();
Console.WriteLine(game.Name + " had exactly one match and was updated.");
updateCount++;
}
}
Console.WriteLine("Updated " + updateCount + " records.");
}
}
}
public void ItOrdersPlayerGameResultsByTheDatePlayedDescending()
{
using (NemeStatsDbContext dbContext = new NemeStatsDbContext())
{
using (IDataContext dataContext = new NemeStatsDataContext(dbContext, securedEntityValidatorFactory))
{
int numberOfGamesToRetrieve = 3;
INemesisHistoryRetriever nemesisHistoryRetriever = new NemesisHistoryRetriever(dataContext);
IPlayerRepository playerRepository = new EntityFrameworkPlayerRepository(dataContext);
IPlayedGameRetriever playedGameRetriever = new PlayedGameRetriever(dataContext);
IPlayerRetriever playerRetriever = new PlayerRetriever(dataContext, playerRepository, playedGameRetriever);
PlayerDetails playerDetails = playerRetriever.GetPlayerDetails(testPlayer1.Id, numberOfGamesToRetrieve);
long lastTicks = long.MaxValue;;
Assert.IsTrue(playerDetails.PlayerGameResults.Count == numberOfGamesToRetrieve);
foreach (PlayerGameResult result in playerDetails.PlayerGameResults)
{
Assert.GreaterOrEqual(lastTicks, result.PlayedGame.DatePlayed.Ticks);
lastTicks = result.PlayedGame.DatePlayed.Ticks;
}
}
}
}
private void CleanUpChampions(NemeStatsDbContext nemeStatsDbContext)
{
List <int> gameDefinitionIdsToClearChampionId = (from gameDefinition in nemeStatsDbContext.GameDefinitions
where gameDefinition.Name == testGameName ||
gameDefinition.Name == testGameName2 ||
gameDefinition.Name == testGameNameForGameWithOtherGamingGroupId ||
gameDefinition.Name == testGameNameForAnotherGameWithOtherGamingGroupId
select gameDefinition.Id)
.ToList();
championIdsToDelete = (from champion in nemeStatsDbContext.Champions
where gameDefinitionIdsToClearChampionId.Contains(champion.GameDefinitionId)
select champion.Id)
.Distinct()
.ToList();
GameDefinition gameDefinitionNeedingChampionCleared;
foreach (int gameDefinitionId in gameDefinitionIdsToClearChampionId)
{
gameDefinitionNeedingChampionCleared = nemeStatsDbContext.GameDefinitions.Find(gameDefinitionId);
gameDefinitionNeedingChampionCleared.ChampionId = null;
}
nemeStatsDbContext.SaveChanges();
Champion championToDelete;
foreach (int championId in championIdsToDelete)
{
championToDelete = nemeStatsDbContext.Champions.Find(championId);
nemeStatsDbContext.Champions.Remove(championToDelete);
}
nemeStatsDbContext.SaveChanges();
}
private void CleanUpTestData()
{
using (NemeStatsDbContext nemeStatsDbContext = new NemeStatsDbContext())
{
CleanUpPlayerGameResults(nemeStatsDbContext);
CleanUpPlayedGames(nemeStatsDbContext);
nemeStatsDbContext.SaveChanges();
CleanUpChampions(nemeStatsDbContext);
CleanUpGameDefinitions(nemeStatsDbContext, testGameName);
CleanUpGameDefinitions(nemeStatsDbContext, testGameName2);
CleanUpGameDefinitions(nemeStatsDbContext, testGameNameForGameWithOtherGamingGroupId);
CleanUpGameDefinitions(nemeStatsDbContext, testGameNameForAnotherGameWithOtherGamingGroupId);
CleanUpGameDefinitions(nemeStatsDbContext, gameDefinitionWithNoChampionName);
CleanUpPlayers(nemeStatsDbContext);
nemeStatsDbContext.SaveChanges();
CleanUpGamingGroup(testGamingGroup1Name, nemeStatsDbContext);
CleanUpGamingGroup(testGamingGroup2Name, nemeStatsDbContext);
CleanUpGamingGroup(testGamingGroup3Name, nemeStatsDbContext);
nemeStatsDbContext.SaveChanges();
CleanUpGamingGroupInvitation(testInviteeEmail1, nemeStatsDbContext);
CleanUpGamingGroupInvitation(testInviteeEmail2, nemeStatsDbContext);
nemeStatsDbContext.SaveChanges();
CleanUpApplicationUser(testApplicationUserNameForUserWithDefaultGamingGroup, nemeStatsDbContext);
CleanUpApplicationUser(testApplicationUserNameForUserWithOtherGamingGroup, nemeStatsDbContext);
CleanUpApplicationUser(testApplicationUserNameForUserWithDefaultGamingGroupAndNoInvites, nemeStatsDbContext);
CleanUpApplicationUser(testApplicationUserNameForUserWithThirdGamingGroup, nemeStatsDbContext);
nemeStatsDbContext.SaveChanges();
}
}
public void CleanUpExistingRecords()
{
using (NemeStatsDbContext dbContext = new NemeStatsDbContext())
{
using (NemeStatsDataContext dataContext = new NemeStatsDataContext(dbContext, new SecuredEntityValidatorFactory()))
{
var games = dataContext.GetQueryable <GameDefinition>()
.Where(game => game.BoardGameGeekGameDefinitionId == null)
.ToList();
var bggSearcher = new BoardGameGeekClient(new ApiDownloaderService());
int updateCount = 0;
foreach (GameDefinition game in games)
{
var bggResults = bggSearcher.SearchBoardGames(game.Name.Trim(), true);
if (bggResults.Count() == 1)
{
game.BoardGameGeekGameDefinitionId = bggResults.First().BoardGameId;
ApplicationUser user = new ApplicationUser
{
CurrentGamingGroupId = game.GamingGroupId
};
dataContext.Save(game, user);
dataContext.CommitAllChanges();
Console.WriteLine(game.Name + " had exactly one match and was updated.");
updateCount++;
}
}
Console.WriteLine("Updated " + updateCount + " records.");
}
}
}
public virtual void FixtureSetUp()
{
//create a stub for this only since we don't want the slowdown of all of the universal analytics event tracking
eventTrackerStub = MockRepository.GenerateStub <IEventTracker>();
eventTrackerStub.Expect(stub => stub.TrackEvent(Arg <IUniversalAnalyticsEvent> .Is.Anything))
.Repeat.Any();
playedGameTracker = new UniversalAnalyticsNemeStatsEventTracker(eventTrackerStub, eventFactory);
using (NemeStatsDbContext nemeStatsDbContext = new NemeStatsDbContext())
{
CleanUpTestData();
testUserWithDefaultGamingGroup = SaveApplicationUser(
nemeStatsDbContext,
testApplicationUserNameForUserWithDefaultGamingGroup,
"*****@*****.**");
testUserWithDefaultGamingGroupAndNoInvites = SaveApplicationUser(
nemeStatsDbContext,
testApplicationUserNameForUserWithDefaultGamingGroupAndNoInvites,
"*****@*****.**");
testUserWithOtherGamingGroup = SaveApplicationUser(
nemeStatsDbContext,
testApplicationUserNameForUserWithOtherGamingGroup,
"*****@*****.**");
testUserWithThirdGamingGroup = SaveApplicationUser(
nemeStatsDbContext,
testApplicationUserNameForUserWithThirdGamingGroup,
"*****@*****.**");
using (NemeStatsDataContext dataContext = new NemeStatsDataContext())
{
testGamingGroup = SaveGamingGroup(dataContext, testGamingGroup1Name, testUserWithDefaultGamingGroup);
testUserWithDefaultGamingGroup = UpdateDatefaultGamingGroupOnUser(testUserWithDefaultGamingGroup, testGamingGroup, dataContext);
testOtherGamingGroup = SaveGamingGroup(dataContext, testGamingGroup2Name, testUserWithOtherGamingGroup);
testUserWithOtherGamingGroup = UpdateDatefaultGamingGroupOnUser(testUserWithOtherGamingGroup, testOtherGamingGroup, dataContext);
testThirdGamingGroup = SaveGamingGroup(dataContext, testGamingGroup3Name, testUserWithThirdGamingGroup);
testUserWithThirdGamingGroup = UpdateDatefaultGamingGroupOnUser(testUserWithThirdGamingGroup,
testThirdGamingGroup, dataContext);
testGameDefinition = SaveGameDefinition(nemeStatsDbContext, testGamingGroup.Id, testGameName);
testGameDefinition2 = SaveGameDefinition(nemeStatsDbContext, testGamingGroup.Id, testGameName2);
testGameDefinitionWithOtherGamingGroupId = SaveGameDefinition(nemeStatsDbContext, testOtherGamingGroup.Id, testGameNameForGameWithOtherGamingGroupId);
gameDefinitionWithNoChampion = SaveGameDefinition(nemeStatsDbContext, testThirdGamingGroup.Id,
gameDefinitionWithNoChampionName);
anotherTestGameDefinitionWithOtherGamingGroupId = SaveGameDefinition(nemeStatsDbContext,
testOtherGamingGroup.Id, testGameNameForAnotherGameWithOtherGamingGroupId);
SavePlayers(nemeStatsDbContext, testGamingGroup.Id, testOtherGamingGroup.Id);
SaveGamingGroupInvitations(nemeStatsDbContext, dataContext);
}
using (NemeStatsDataContext dataContext = new NemeStatsDataContext())
{
CreatePlayedGames(dataContext);
}
}
}
public void ItCreatesATwoPlayerPlayedGameAndSetsTheNumberOfPlayers()
{
using (NemeStatsDbContext dbContext = new NemeStatsDbContext())
{
PlayedGame playedGameFromTheDatabase = dbContext.PlayedGames.Find(testPlayedGames[0].Id);
Assert.IsTrue(playedGameFromTheDatabase.NumberOfPlayers == 2);
}
}
public void ItCreatesATwoPlayerPlayedGameAndSetsTheNumberOfPlayers()
{
using (NemeStatsDbContext dbContext = new NemeStatsDbContext())
{
PlayedGame playedGameFromTheDatabase = dbContext.PlayedGames.Find(testPlayedGames[0].Id);
Assert.IsTrue(playedGameFromTheDatabase.NumberOfPlayers == 2);
}
}
private void CleanUpBoardGameGeekGameDefinitions(NemeStatsDbContext nemeStatsDbContext, BoardGameGeekGameDefinition boardGameGeekGameDefinition)
{
try
{
nemeStatsDbContext.BoardGameGeekGameDefinitions.Remove(boardGameGeekGameDefinition);
}
catch (Exception)
{
}
}
private void SavePlayers(NemeStatsDbContext nemeStatsDbContext, int primaryGamingGroupId, int otherGamingGroupId)
{
testPlayer1 = new Player()
{
Name = testPlayer1Name, Active = true, GamingGroupId = primaryGamingGroupId
};
nemeStatsDbContext.Players.Add(testPlayer1);
testPlayer2 = new Player()
{
Name = testPlayer2Name, Active = true, GamingGroupId = primaryGamingGroupId
};
nemeStatsDbContext.Players.Add(testPlayer2);
testPlayer3 = new Player()
{
Name = testPlayer3Name, Active = true, GamingGroupId = primaryGamingGroupId
};
nemeStatsDbContext.Players.Add(testPlayer3);
testPlayer4 = new Player()
{
Name = testPlayer4Name, Active = true, GamingGroupId = primaryGamingGroupId
};
nemeStatsDbContext.Players.Add(testPlayer4);
testPlayer5 = new Player()
{
Name = testPlayer5Name, Active = false, GamingGroupId = primaryGamingGroupId
};
nemeStatsDbContext.Players.Add(testPlayer5);
testPlayer6 = new Player()
{
Name = testPlayer6Name, Active = true, GamingGroupId = primaryGamingGroupId
};
nemeStatsDbContext.Players.Add(testPlayer6);
testPlayer7WithOtherGamingGroupId = new Player()
{
Name = testPlayer7Name, Active = true, GamingGroupId = otherGamingGroupId
};
nemeStatsDbContext.Players.Add(testPlayer7WithOtherGamingGroupId);
testPlayer8WithOtherGamingGroupId = new Player()
{
Name = testPlayer8Name, Active = true, GamingGroupId = otherGamingGroupId
};
nemeStatsDbContext.Players.Add(testPlayer8WithOtherGamingGroupId);
testPlayer9UndefeatedWith5Games = new Player {
Name = testPlayer9UndefeatedWith5GamesName, Active = false, GamingGroupId = otherGamingGroupId
};
nemeStatsDbContext.Players.Add(testPlayer9UndefeatedWith5Games);
testPlayerWithNoPlayedGames = new Player {
Name = testPlayerWithNoPlayedGamesName, Active = true, GamingGroupId = primaryGamingGroupId
};
nemeStatsDbContext.Players.Add(testPlayerWithNoPlayedGames);
nemeStatsDbContext.SaveChanges();
}
public void ItOnlyFetchesRelatedEntitiesThatAreNeeded()
{
using (NemeStatsDbContext dbContext = new NemeStatsDbContext())
{
dbContext.Database.Log = s => System.Diagnostics.Debug.WriteLine(s);
var result = (from gamingGroup in dbContext.GamingGroups.Include(g => g.OwningUser.Players.Select(p => p.Nemesis))
where gamingGroup.Id == 1
select gamingGroup.OwningUser.Players.Select(p => p.Nemesis)).ToList();
;
}
}
public void ItSetsTheNemesisIdOnThePlayer()
{
using (NemeStatsDbContext nemeStatsDbContext = new NemeStatsDbContext())
{
using (NemeStatsDataContext nemeStatsDataContext = new NemeStatsDataContext())
{
Player player1 = nemeStatsDataContext.FindById <Player>(testPlayer1.Id);
Assert.NotNull(player1.NemesisId);
}
}
}
public void ItEagerlyFetchesThePlayers()
{
using (NemeStatsDbContext dbContext = new NemeStatsDbContext())
{
dbContext.Configuration.LazyLoadingEnabled = false;
using (NemeStatsDataContext dataContext = new NemeStatsDataContext(dbContext, securedEntityValidatorFactory))
{
PlayedGame playedGame = GetTestSubjectPlayedGame(dataContext);
Assert.NotNull(playedGame.PlayerGameResults[0].Player);
}
}
}
public void ItLazyLoadsByDefault()
{
using (NemeStatsDbContext dbContext = new NemeStatsDbContext())
{
dbContext.Database.Log = s => System.Diagnostics.Debug.WriteLine(s);
Player player2 = dbContext.Players.First();
//Accessing the PlayerGameResults property will lazy load these entities
Assert.NotNull(player2.PlayerGameResults);
}
}
public void ItLazyLoadsByDefault()
{
using (NemeStatsDbContext dbContext = new NemeStatsDbContext())
{
dbContext.Database.Log = s => System.Diagnostics.Debug.WriteLine(s);
Player player2 = dbContext.Players.First();
//Accessing the PlayerGameResults property will lazy load these entities
Assert.NotNull(player2.PlayerGameResults);
}
}
public void ItEagerlyFetchesThePlayers()
{
using (NemeStatsDbContext dbContext = new NemeStatsDbContext())
{
dbContext.Configuration.LazyLoadingEnabled = false;
using (NemeStatsDataContext dataContext = new NemeStatsDataContext(dbContext, securedEntityValidatorFactory))
{
PlayedGame playedGame = GetTestSubjectPlayedGame(dataContext);
Assert.NotNull(playedGame.PlayerGameResults[0].Player);
}
}
}
private GameDefinition SaveGameDefinition(NemeStatsDbContext nemeStatsDbContext, int gamingGroupId, string gameDefinitionName)
{
GameDefinition gameDefinition = new GameDefinition()
{
Name = gameDefinitionName, Description = testGameDescription, GamingGroupId = gamingGroupId
};
nemeStatsDbContext.GameDefinitions.Add(gameDefinition);
nemeStatsDbContext.SaveChanges();
return(gameDefinition);
}
public void ItClearsTheNemesisIdIfThePlayerHasNoNemesis()
{
using (NemeStatsDbContext nemeStatsDbContext = new NemeStatsDbContext())
{
using (NemeStatsDataContext nemeStatsDataContext = new NemeStatsDataContext())
{
Player player5 = nemeStatsDataContext.FindById <Player>(testPlayer5.Id);
Assert.Null(player5.NemesisId);
}
}
}
public void ItDoesNotLazyLoadIfYouDisableLazyLoadingBeforeExecutingAQuery()
{
using(NemeStatsDbContext dbContext = new NemeStatsDbContext())
{
dbContext.Database.Log = s => System.Diagnostics.Debug.WriteLine(s);
dbContext.Configuration.LazyLoadingEnabled = false;
Player player2 = dbContext.Players.First();
//with lazy loading disabled, PlayerGameResults will not result in a query to the database
Assert.Null(player2.PlayerGameResults);
}
}
public void ItDoesNotLazyLoadIfYouDisableLazyLoadingBeforeExecutingAQuery()
{
using (NemeStatsDbContext dbContext = new NemeStatsDbContext())
{
dbContext.Database.Log = s => System.Diagnostics.Debug.WriteLine(s);
dbContext.Configuration.LazyLoadingEnabled = false;
Player player2 = dbContext.Players.First();
//with lazy loading disabled, PlayerGameResults will not result in a query to the database
Assert.Null(player2.PlayerGameResults);
}
}
private static void CleanUpPlayerByPlayerName(string playerName, NemeStatsDbContext nemeStatsDbContext)
{
Player playerToDelete = nemeStatsDbContext.Players.FirstOrDefault(player => player.Name == playerName);
if (playerToDelete != null)
{
try
{
nemeStatsDbContext.Players.Remove(playerToDelete);
nemeStatsDbContext.SaveChanges();
}
catch (Exception) { }
}
}
private void SaveGamingGroupInvitations(NemeStatsDbContext nemeStatsDbContext, IDataContext dataContext)
{
EntityFrameworkGamingGroupAccessGranter accessGranter = new EntityFrameworkGamingGroupAccessGranter(dataContext);
testUnredeemedGamingGroupInvitation = accessGranter.CreateInvitation(testUserWithDefaultGamingGroup.Email, testUserWithDefaultGamingGroup);
dataContext.CommitAllChanges();
testAlreadyRedeemedGamingGroupInvitation = accessGranter.CreateInvitation(testUserWithOtherGamingGroup.Email, testUserWithDefaultGamingGroup);
//TODO simulating registration. Will need a separate method for this soon so this logic can be replaced
testAlreadyRedeemedGamingGroupInvitation.DateRegistered = DateTime.UtcNow.AddDays(1);
testAlreadyRedeemedGamingGroupInvitation.RegisteredUserId = testUserWithOtherGamingGroup.Id;
nemeStatsDbContext.GamingGroupInvitations.Add(testAlreadyRedeemedGamingGroupInvitation);
nemeStatsDbContext.SaveChanges();
}
private void CleanUpPlayerGameResults(NemeStatsDbContext nemeStatsDbContext)
{
List <PlayerGameResult> playerGameResultsToDelete = (from playerGameResult in nemeStatsDbContext.PlayerGameResults
where playerGameResult.PlayedGame.GameDefinition.Name == testGameName
select playerGameResult).ToList();
foreach (PlayerGameResult playerGameResult in playerGameResultsToDelete)
{
try
{
nemeStatsDbContext.PlayerGameResults.Remove(playerGameResult);
}
catch (Exception) { }
}
}
private void CleanUpGameDefinitions(NemeStatsDbContext nemeStatsDbContext, string gameDefinitionName)
{
List <GameDefinition> gameDefinitionsToDelete = (from game in nemeStatsDbContext.GameDefinitions
where game.Name == gameDefinitionName
select game).ToList();
foreach (GameDefinition game in gameDefinitionsToDelete)
{
try
{
nemeStatsDbContext.GameDefinitions.Remove(game);
}
catch (Exception) { }
}
}
private GameDefinition SaveGameDefinition(NemeStatsDbContext nemeStatsDbContext, int gamingGroupId, string gameDefinitionName, int?boardGameGeekGameDefinitionid = null)
{
GameDefinition gameDefinition = new GameDefinition
{
Name = gameDefinitionName,
Description = testGameDescription,
GamingGroupId = gamingGroupId,
BoardGameGeekGameDefinitionId = boardGameGeekGameDefinitionid
};
nemeStatsDbContext.GameDefinitions.Add(gameDefinition);
nemeStatsDbContext.SaveChanges();
return(gameDefinition);
}
private void CleanUpGamingGroup(string testGamingGroupName, NemeStatsDbContext nemeStatsDbContext)
{
GamingGroup gamingGroupToDelete = (from gamingGroup in nemeStatsDbContext.GamingGroups
where gamingGroup.Name == testGamingGroupName
select gamingGroup).FirstOrDefault();
if (gamingGroupToDelete != null)
{
try
{
nemeStatsDbContext.GamingGroups.Remove(gamingGroupToDelete);
}
catch (Exception) { }
}
}
private void CleanUpApplicationUser(string testApplicationUserName, NemeStatsDbContext nemeStatsDbContext)
{
ApplicationUser applicationUserToDelete = (from applicationUser in nemeStatsDbContext.Users
where applicationUser.UserName == testApplicationUserName
select applicationUser).FirstOrDefault();
if (applicationUserToDelete != null)
{
try
{
nemeStatsDbContext.Users.Remove(applicationUserToDelete);
}
catch (Exception) { }
}
}
private void CleanUpPlayers(NemeStatsDbContext nemeStatsDbContext)
{
CleanUpNemeses(nemeStatsDbContext);
CleanUpPlayerByPlayerName(testPlayer1Name, nemeStatsDbContext);
CleanUpPlayerByPlayerName(testPlayer2Name, nemeStatsDbContext);
CleanUpPlayerByPlayerName(testPlayer3Name, nemeStatsDbContext);
CleanUpPlayerByPlayerName(testPlayer4Name, nemeStatsDbContext);
CleanUpPlayerByPlayerName(testPlayer5Name, nemeStatsDbContext);
CleanUpPlayerByPlayerName(testPlayer6Name, nemeStatsDbContext);
CleanUpPlayerByPlayerName(testPlayer7Name, nemeStatsDbContext);
CleanUpPlayerByPlayerName(testPlayer8Name, nemeStatsDbContext);
CleanUpPlayerByPlayerName(testPlayer9UndefeatedWith5GamesName, nemeStatsDbContext);
CleanUpPlayerByPlayerName(testPlayerWithNoPlayedGamesName, nemeStatsDbContext);
}
private void CleanUpGamingGroupInvitation(string inviteeEmail, NemeStatsDbContext nemeStatsDbContext)
{
GamingGroupInvitation invitation = (from gamingGroupInvitation in nemeStatsDbContext.GamingGroupInvitations
where gamingGroupInvitation.InviteeEmail == inviteeEmail
select gamingGroupInvitation).FirstOrDefault();
if (invitation != null)
{
try
{
nemeStatsDbContext.GamingGroupInvitations.Remove(invitation);
}
catch (Exception) { }
}
}
public void ItSetsPlayerStatistics()
{
using (NemeStatsDbContext dbContext = new NemeStatsDbContext())
{
using (IDataContext dataContext = new NemeStatsDataContext(dbContext, securedEntityValidatorFactory))
{
INemesisHistoryRetriever nemesisHistoryRetriever = new NemesisHistoryRetriever(dataContext);
IPlayerRepository playerRepository = new EntityFrameworkPlayerRepository(dataContext);
IPlayedGameRetriever playedGameRetriever = new PlayedGameRetriever(dataContext);
IPlayerRetriever playerRetriever = new PlayerRetriever(dataContext, playerRepository, playedGameRetriever);
PlayerDetails playerDetails = playerRetriever.GetPlayerDetails(testPlayer1.Id, 1);
Assert.NotNull(playerDetails.PlayerStats);
}
}
}
public override void FixtureSetUp()
{
base.FixtureSetUp();
using (this.dbContext = new NemeStatsDbContext())
{
using (this.dataContext = new NemeStatsDataContext(this.dbContext, this.securedEntityValidatorFactory))
{
var playerRepository = new EntityFrameworkPlayerRepository(dataContext);
var gameDefinitionRetriever = new GameDefinitionRetriever(this.dataContext, playerRepository);
this.gameDefinitionSummary = gameDefinitionRetriever.GetGameDefinitionDetails(
this.testGameDefinition.Id,
this.numberOfGamesToRetrieve);
}
}
}
public void RecalculateAllPointsForGamesWithNoPlayTime()
{
//--arrange
using (var dbContext = new NemeStatsDbContext())
{
using (var dataContext = new NemeStatsDataContext(dbContext, new SecuredEntityValidatorFactory()))
{
var weightTierCalculator = new WeightTierCalculator();
var weightBonusCalculator = new WeightBonusCalculator(weightTierCalculator);
var gameDurationBonusCalculator = new GameDurationBonusCalculator();
var pointsCalculator = new PointsCalculator(weightBonusCalculator, gameDurationBonusCalculator);
//--act
new GlobalPointsRecalculator().RecalculateAllPointsForGamesWithNoPlayTime(dataContext, pointsCalculator);
}
}
}
public void ItEagerlyFetchesPlayerGameResults()
{
using (NemeStatsDbContext dbContext = new NemeStatsDbContext())
{
dbContext.Configuration.LazyLoadingEnabled = false;
dbContext.Configuration.ProxyCreationEnabled = false;
using (NemeStatsDataContext dataContext = new NemeStatsDataContext(dbContext, securedEntityValidatorFactory))
{
PlayedGameRetriever retriever = new PlayedGameRetriever(dataContext);
List <PlayedGame> playedGames = retriever.GetRecentGames(1, testUserWithDefaultGamingGroup.CurrentGamingGroupId);
ICollection <PlayerGameResult> playerGameResults = playedGames[0].PlayerGameResults;
Assert.NotNull(playerGameResults);
}
}
}
public void ItEagerlyFetchesPlayerGameResults()
{
using(NemeStatsDbContext dbContext = new NemeStatsDbContext())
{
dbContext.Configuration.LazyLoadingEnabled = false;
dbContext.Configuration.ProxyCreationEnabled = false;
using (NemeStatsDataContext dataContext = new NemeStatsDataContext(dbContext, securedEntityValidatorFactory))
{
PlayedGameRetriever retriever = new PlayedGameRetriever(dataContext);
List<PlayedGame> playedGames = retriever.GetRecentGames(1, testUserWithDefaultGamingGroup.CurrentGamingGroupId);
ICollection<PlayerGameResult> playerGameResults = playedGames[0].PlayerGameResults;
Assert.NotNull(playerGameResults);
}
}
}
public void RecalculateAllPointsForGamesWithNoPlayTime()
{
//--arrange
using (var dbContext = new NemeStatsDbContext())
{
using (var dataContext = new NemeStatsDataContext(dbContext, new SecuredEntityValidatorFactory()))
{
var weightTierCalculator = new WeightTierCalculator();
var weightBonusCalculator = new WeightBonusCalculator(weightTierCalculator);
var gameDurationBonusCalculator = new GameDurationBonusCalculator();
var pointsCalculator = new PointsCalculator(weightBonusCalculator, gameDurationBonusCalculator);
//--act
new GlobalPointsRecalculator().RecalculateAllPointsForGamesWithNoPlayTime(dataContext, pointsCalculator);
}
}
}
public virtual void TestBaseSetUp()
{
nemeStatsDbContext = MockRepository.GenerateMock<NemeStatsDbContext>();
securedEntityValidatorFactory = MockRepository.GeneratePartialMock<SecuredEntityValidatorFactory>();
dataContext = MockRepository.GeneratePartialMock<NemeStatsDataContext>(nemeStatsDbContext, securedEntityValidatorFactory);
entityWithGamingGroupAndTechnicalKey = MockRepository.GenerateStub<IEntityWithTechnicalKey>();
entityWithGamingGroupAndTechnicalKey.Expect(mock => mock.AlreadyInDatabase())
.Repeat.Once()
.Return(true);
entityWithGamingGroup = MockRepository.GenerateStub<IEntityWithTechnicalKey>();
currentUser = new ApplicationUser()
{
Id = "application user id",
CurrentGamingGroupId = 1
};
}
public void ItEagerlyFetchesGameDefinitions()
{
using (NemeStatsDbContext dbContext = new NemeStatsDbContext())
{
using (IDataContext dataContext = new NemeStatsDataContext(dbContext, securedEntityValidatorFactory))
{
dbContext.Configuration.LazyLoadingEnabled = false;
dbContext.Configuration.ProxyCreationEnabled = false;
INemesisHistoryRetriever nemesisHistoryRetriever = new NemesisHistoryRetriever(dataContext);
IPlayerRepository playerRepository = new EntityFrameworkPlayerRepository(dataContext);
IPlayedGameRetriever playedGameRetriever = new PlayedGameRetriever(dataContext);
IPlayerRetriever playerRetriever = new PlayerRetriever(dataContext, playerRepository, playedGameRetriever);
PlayerDetails testPlayerDetails = playerRetriever.GetPlayerDetails(testPlayer1.Id, 1);
Assert.NotNull(testPlayerDetails.PlayerGameResults.First().PlayedGame.GameDefinition);
}
}
}
private ApplicationUser SaveApplicationUser(NemeStatsDbContext nemeStatsDbContext, string userName, string email)
{
ApplicationUser applicationUser = new ApplicationUser()
{
Email = email,
UserName = userName,
EmailConfirmed = false,
PhoneNumberConfirmed = false,
LockoutEnabled = false,
AccessFailedCount = 0,
AnonymousClientId = new Guid().ToString()
};
nemeStatsDbContext.Users.Add(applicationUser);
nemeStatsDbContext.SaveChanges();
return(applicationUser);
}
public override void FixtureSetUp()
{
base.FixtureSetUp();
using (dbContext = new NemeStatsDbContext())
{
using (dataContext = new NemeStatsDataContext(dbContext, securedEntityValidatorFactory))
{
var playerRepository = new EntityFrameworkPlayerRepository(dataContext);
var cacheableGameDataRetriever = new BoardGameGeekGameDefinitionInfoRetriever(new DateUtilities(), new CacheService(), dataContext);
var gameDefinitionRetriever = new GameDefinitionRetriever(dataContext, playerRepository, cacheableGameDataRetriever);
gameDefinitionSummary = gameDefinitionRetriever.GetGameDefinitionDetails(
testGameDefinition.Id,
numberOfGamesToRetrieve);
}
}
}
public void TestBaseSetUp()
{
nemeStatsDbContext = MockRepository.GenerateMock <NemeStatsDbContext>();
securedEntityValidatorFactory = MockRepository.GeneratePartialMock <SecuredEntityValidatorFactory>();
dataContext = MockRepository.GeneratePartialMock <NemeStatsDataContext>(nemeStatsDbContext, securedEntityValidatorFactory);
entityWithGamingGroupAndTechnicalKey = MockRepository.GenerateStub <EntityWithTechnicalKey>();
entityWithGamingGroupAndTechnicalKey.Expect(mock => mock.AlreadyInDatabase())
.Repeat.Once()
.Return(true);
entityWithGamingGroup = MockRepository.GenerateStub <EntityWithTechnicalKey>();
currentUser = new ApplicationUser()
{
Id = "application user id",
CurrentGamingGroupId = 1
};
}
public void UpdateAllBoardGameGeekGameDefinitionData()
{
using (NemeStatsDbContext nemeStatsDbContext = new NemeStatsDbContext())
{
using (var dataContext = new NemeStatsDataContext(nemeStatsDbContext, new SecuredEntityValidatorFactory()))
{
var apiDownloaderService = new ApiDownloaderService();
//API failures won't get logged!
var rollbarClient = MockRepository.GenerateMock<IRollbarClient>();
var boardGameGeekClient = new BoardGameGeekClient(apiDownloaderService, rollbarClient);
var batchUpdateService = new BoardGameGeekBatchUpdateJobService(dataContext, boardGameGeekClient, rollbarClient);
var totalRecordsUpdated = batchUpdateService.RefreshAllBoardGameGeekData();
Debug.WriteLine("Updated {0} total BoardGameGeekGameDefinition records.", totalRecordsUpdated);
}
}
}
public void ItPullsObjectsFromMemoryIfTheyHaveAlreadyBeenLoaded()
{
using (NemeStatsDbContext dbContext = new NemeStatsDbContext())
{
dbContext.Database.Log = s => System.Diagnostics.Debug.WriteLine(s);
//normal query with no lazy loading (since I'm not accessing any of the properties of related entities)
Player player = dbContext.Players.First();
//accessing PlayerGameResults will cause this data to be lazy loaded
player.PlayerGameResults.First();
dbContext.Configuration.LazyLoadingEnabled = false;
Player player2 = dbContext.Players.First();
//even though LazyLoadingEnabled is false, it will fetch since this player has already been loaded into
// memory before
Assert.NotNull(player2.PlayerGameResults);
}
}
public void RecalculateForSingleGame()
{
using (NemeStatsDbContext dbContext = new NemeStatsDbContext())
{
SecuredEntityValidatorFactory factory = new SecuredEntityValidatorFactory();
using (NemeStatsDataContext dataContext = new NemeStatsDataContext(dbContext, factory))
{
IChampionRepository championRepository = new ChampionRepository(dataContext);
IChampionRecalculator championRecalculator = new ChampionRecalculator(dataContext, championRepository);
ApplicationUser user = new ApplicationUser
{
Id = "80629c07-b8df-4deb-a9e3-5b503ce7d7df",
CurrentGamingGroupId = 1
};
championRecalculator.RecalculateChampion(2005, user);
}
}
}
public void ItGetsResultsForExistingGameNames()
{
using (NemeStatsDbContext dbContext = new NemeStatsDbContext())
{
using (NemeStatsDataContext dataContext = new NemeStatsDataContext())
{
//gets a distinct list of all game names
//var gameNames2 = dataContext.GetQueryable<GameDefinition>()
// .GroupBy(game => game.Name)
// .Select(game => game.FirstOrDefault())
// .ToList();
var gameNames = new List<string>
{
"7 Wonders",
"Citadels",
"Cosmic encounter ",
"Coup",
"Dead of winter",
"Dominion",
"Five Tribes",
"Samurai Sword",
"Suburbia",
"Agricola",
"Arkham Horror",
"Bang!",
"Carcassonne",
"Castle Ravenloft",
"Race For The Galaxy",
"Settlers of Catan",
"Shadows of Brimstone",
"Sushi Go!",
"Twilight Imperium",
"Apples to Apples Kids",
"At the Gates of Loyang",
"Avalon",
"Boggle",
"Bohnanza",
"Carson City",
"Caverna",
"Chess",
"Cinque Terre",
"Clue",
"Coin Age",
"Cranium",
"Cranium Zigity",
"Cribbage",
"Cthulhu Gloom",
"Dominoes",
"Dungeon Fighter",
"Dungeon Petz",
"Dungeon Roll",
"Dutch Blitz",
"Eight Minute Empire",
"Famiglia",
"Fearsome Floors",
"Forbidden Island",
"Formula D",
"Freedom: The Underground Railroad",
"Galaxy Trucker",
"Game of thrones boardgame",
"Guillotine",
"Hive",
"Jaipur",
"Kaosball",
"Kemet",
"King of Tokyo",
"Legend of Drizzt",
"Legends of Andor",
"Lewis & Clark",
"Lords of Waterdeep",
"Love Letter",
"Machi Koro",
"Mage Knight Board Game",
"Mage Knight Dungeons",
"Magic the Gathering",
"Magic: The Gathering",
"Mascarade",
"Merchants & Marauders",
"Nations",
"Nuts",
"Once Upon a Time",
"Pairs (Calamity Variant)",
"Pandemic",
"Pathfinder ACG",
"Pirate Fluxx",
"Puerto Rico",
"Quantum",
"Quiddler",
"Quoridor",
"Race for the galaxy",
"Rampage",
"Risk: The Lord of the Rings Trilogy Edition",
"Risk: The Walking Dead",
"RoboRally",
"Rummikub",
"Saboteur",
"Saboteur 2",
"Samurai Swords",
"SanGuoSha: Legends of the Three Kingdoms",
"Scattergories",
"Scotland yard",
"Scrabble",
"Settlers of America: Trails to Rails",
"Settlers of the Stone Age",
"Seven Wonders",
"Small World",
"Spartacus",
"Splendor",
"Star Realms",
"Star Trek Battle Force",
"Star Trek: Fleet Captains",
"Star Wars: X-Wing Miniatures Game",
"Survive!",
"Taboo",
"Tales of the Arabian Nights",
"The Little Prince",
"The Princes of Florence",
"The Resistance",
"Thunderstone Advance: Towers of Ruin",
"Ticket to Ride",
"Ticket to Ride Europe",
"Tiny Epic Kingdoms",
"Troyes",
"tzolkin",
"Warhammer 40K",
"Wits & Wagers",
"Wrath of Ashardalon",
"Zombicide"
};
var rollbarMock = MockRepository.GenerateMock<IRollbarClient>();
var bggSearcher = new BoardGameGeekClient(new ApiDownloaderService(), rollbarMock);
foreach (string gameName in gameNames)
{
var results = bggSearcher.SearchBoardGames(gameName, true);
if (results.Count() != 1)
{
Console.WriteLine(gameName + " has "+ results.Count() + " results.");
}
}
}
}
}
private void CleanUpNemeses(NemeStatsDbContext nemeStatsDbContext)
{
List<int> playerIdsToClearNemesisId = (from player in nemeStatsDbContext.Players
where player.Name == testPlayer1Name
|| player.Name == testPlayer1Name
|| player.Name == testPlayer2Name
|| player.Name == testPlayer3Name
|| player.Name == testPlayer3Name
|| player.Name == testPlayer4Name
|| player.Name == testPlayer5Name
|| player.Name == testPlayer6Name
|| player.Name == testPlayer7Name
|| player.Name == testPlayer8Name
|| player.Name == testPlayer9UndefeatedWith5GamesName
select player.Id)
.ToList();
nemesisIdsToDelete = (from nemesis in nemeStatsDbContext.Nemeses
where playerIdsToClearNemesisId.Contains(nemesis.NemesisPlayerId)
select nemesis.Id)
.Distinct()
.ToList();
Player playerNeedingNemesisCleared;
foreach (int playerId in playerIdsToClearNemesisId)
{
playerNeedingNemesisCleared = nemeStatsDbContext.Players.Find(playerId);
if (playerNeedingNemesisCleared.NemesisId != null)
{
playerNeedingNemesisCleared.NemesisId = null;
}
}
nemeStatsDbContext.SaveChanges();
Nemesis nemesisToDelete;
foreach (int nemesisId in nemesisIdsToDelete)
{
nemesisToDelete = nemeStatsDbContext.Nemeses.Find(nemesisId);
nemeStatsDbContext.Nemeses.Remove(nemesisToDelete);
}
nemeStatsDbContext.SaveChanges();
}
private void CleanUpApplicationUser(string testApplicationUserName, NemeStatsDbContext nemeStatsDbContext)
{
ApplicationUser applicationUserToDelete = (from applicationUser in nemeStatsDbContext.Users
where applicationUser.UserName == testApplicationUserName
select applicationUser).FirstOrDefault();
if (applicationUserToDelete != null)
{
try
{
nemeStatsDbContext.Users.Remove(applicationUserToDelete);
}
catch (Exception) { }
}
}
private void CleanUpGamingGroup(string testGamingGroupName, NemeStatsDbContext nemeStatsDbContext)
{
GamingGroup gamingGroupToDelete = (from gamingGroup in nemeStatsDbContext.GamingGroups
where gamingGroup.Name == testGamingGroupName
select gamingGroup).FirstOrDefault();
if (gamingGroupToDelete != null)
{
try
{
nemeStatsDbContext.GamingGroups.Remove(gamingGroupToDelete);
}
catch (Exception) { }
}
}
private void CleanUpPlayerGameResults(NemeStatsDbContext nemeStatsDbContext)
{
List<PlayerGameResult> playerGameResultsToDelete = (from playerGameResult in nemeStatsDbContext.PlayerGameResults
where playerGameResult.PlayedGame.GameDefinition.Name == testGameName
select playerGameResult).ToList();
foreach (PlayerGameResult playerGameResult in playerGameResultsToDelete)
{
try
{
nemeStatsDbContext.PlayerGameResults.Remove(playerGameResult);
}
catch (Exception) { }
}
}
private void CleanUpGameDefinitions(NemeStatsDbContext nemeStatsDbContext, string gameDefinitionName)
{
List<GameDefinition> gameDefinitionsToDelete = (from game in nemeStatsDbContext.GameDefinitions
where game.Name == gameDefinitionName
select game).ToList();
foreach (GameDefinition game in gameDefinitionsToDelete)
{
try
{
nemeStatsDbContext.GameDefinitions.Remove(game);
}
catch (Exception) { }
}
}
private void CleanUpBoardGameGeekGameDefinitions(NemeStatsDbContext nemeStatsDbContext, BoardGameGeekGameDefinition boardGameGeekGameDefinition)
{
try
{
nemeStatsDbContext.BoardGameGeekGameDefinitions.Remove(boardGameGeekGameDefinition);
}
catch (Exception)
{
}
}
private static void CleanUpPlayerByPlayerName(string playerName, NemeStatsDbContext nemeStatsDbContext)
{
Player playerToDelete = nemeStatsDbContext.Players.FirstOrDefault(player => player.Name == playerName);
if (playerToDelete != null)
{
try
{
nemeStatsDbContext.Players.Remove(playerToDelete);
nemeStatsDbContext.SaveChanges();
}
catch (Exception) { }
}
}
public void ItOrdersPlayerGameResultsByTheDatePlayedDescending()
{
using (NemeStatsDbContext dbContext = new NemeStatsDbContext())
{
using (IDataContext dataContext = new NemeStatsDataContext(dbContext, securedEntityValidatorFactory))
{
int numberOfGamesToRetrieve = 3;
INemesisHistoryRetriever nemesisHistoryRetriever = new NemesisHistoryRetriever(dataContext);
IPlayerRepository playerRepository = new EntityFrameworkPlayerRepository(dataContext);
IPlayedGameRetriever playedGameRetriever = new PlayedGameRetriever(dataContext);
IPlayerRetriever playerRetriever = new PlayerRetriever(dataContext, playerRepository, playedGameRetriever);
PlayerDetails playerDetails = playerRetriever.GetPlayerDetails(testPlayer1.Id, numberOfGamesToRetrieve);
long lastTicks = long.MaxValue; ;
Assert.IsTrue(playerDetails.PlayerGameResults.Count == numberOfGamesToRetrieve);
foreach (PlayerGameResult result in playerDetails.PlayerGameResults)
{
Assert.GreaterOrEqual(lastTicks, result.PlayedGame.DatePlayed.Ticks);
lastTicks = result.PlayedGame.DatePlayed.Ticks;
}
}
}
}
public void ItOnlyGetsTheSpecifiedNumberOfRecentGames()
{
using (NemeStatsDbContext dbContext = new NemeStatsDbContext())
{
using (IDataContext dataContext = new NemeStatsDataContext(dbContext, securedEntityValidatorFactory))
{
int numberOfGamesToRetrieve = 1;
INemesisHistoryRetriever nemesisHistoryRetriever = new NemesisHistoryRetriever(dataContext);
IPlayerRepository playerRepository = new EntityFrameworkPlayerRepository(dataContext);
IPlayedGameRetriever playedGameRetriever = new PlayedGameRetriever(dataContext);
IPlayerRetriever playerRetriever = new PlayerRetriever(dataContext, playerRepository, playedGameRetriever);
PlayerDetails playerDetails = playerRetriever.GetPlayerDetails(testPlayer1.Id, numberOfGamesToRetrieve);
Assert.AreEqual(numberOfGamesToRetrieve, playerDetails.PlayerGameResults.Count);
}
}
}
public void ItSetsPlayerStatistics()
{
using (NemeStatsDbContext dbContext = new NemeStatsDbContext())
{
using (IDataContext dataContext = new NemeStatsDataContext(dbContext, securedEntityValidatorFactory))
{
INemesisHistoryRetriever nemesisHistoryRetriever = new NemesisHistoryRetriever(dataContext);
IPlayerRepository playerRepository = new EntityFrameworkPlayerRepository(dataContext);
IPlayedGameRetriever playedGameRetriever = new PlayedGameRetriever(dataContext);
IPlayerRetriever playerRetriever = new PlayerRetriever(dataContext, playerRepository, playedGameRetriever);
PlayerDetails playerDetails = playerRetriever.GetPlayerDetails(testPlayer1.Id, 1);
Assert.NotNull(playerDetails.PlayerStats);
}
}
}
public void ItThrowsAnEntityDoesNotExistExceptionIfTheIdIsntValid()
{
using (dbContext = new NemeStatsDbContext())
{
using (dataContext = new NemeStatsDataContext(dbContext, securedEntityValidatorFactory))
{
var playerRepository = new EntityFrameworkPlayerRepository(dataContext);
int invalidId = -1;
var expectedException = new EntityDoesNotExistException(typeof(GameDefinition), invalidId);
var cacheableGameDataRetriever = new BoardGameGeekGameDefinitionInfoRetriever(new DateUtilities(), new CacheService(), dataContext);
var gameDefinitionRetriever = new GameDefinitionRetriever(dataContext, playerRepository, cacheableGameDataRetriever);
var actualException = Assert.Throws<EntityDoesNotExistException>(() =>
gameDefinitionRetriever.GetGameDefinitionDetails(invalidId, 0));
actualException.Message.ShouldBe(expectedException.Message);
}
}
}
public void ItOnlyFetchesRelatedEntitiesThatAreNeeded()
{
using (NemeStatsDbContext dbContext = new NemeStatsDbContext())
{
dbContext.Database.Log = s => System.Diagnostics.Debug.WriteLine(s);
var result = (from gamingGroup in dbContext.GamingGroups.Include(g => g.OwningUser.Players.Select(p => p.Nemesis))
where gamingGroup.Id == 1
select gamingGroup.OwningUser.Players.Select(p => p.Nemesis)).ToList();
;
}
}
private void CleanUpChampions(NemeStatsDbContext nemeStatsDbContext)
{
List<int> gameDefinitionIdsToClearChampionId = (from gameDefinition in nemeStatsDbContext.GameDefinitions
where gameDefinition.Name == testGameName
|| gameDefinition.Name == testGameName2
|| gameDefinition.Name == testGameNameForGameWithOtherGamingGroupId
|| gameDefinition.Name == testGameNameForAnotherGameWithOtherGamingGroupId
select gameDefinition.Id)
.ToList();
championIdsToDelete = (from champion in nemeStatsDbContext.Champions
where gameDefinitionIdsToClearChampionId.Contains(champion.GameDefinitionId)
select champion.Id)
.Distinct()
.ToList();
GameDefinition gameDefinitionNeedingChampionCleared;
foreach (int gameDefinitionId in gameDefinitionIdsToClearChampionId)
{
gameDefinitionNeedingChampionCleared = nemeStatsDbContext.GameDefinitions.Find(gameDefinitionId);
gameDefinitionNeedingChampionCleared.ChampionId = null;
}
nemeStatsDbContext.SaveChanges();
Champion championToDelete;
foreach (int championId in championIdsToDelete)
{
championToDelete = nemeStatsDbContext.Champions.Find(championId);
nemeStatsDbContext.Champions.Remove(championToDelete);
}
nemeStatsDbContext.SaveChanges();
}
public void ItSetsTheNemesisIdOnThePlayer()
{
using(NemeStatsDbContext nemeStatsDbContext = new NemeStatsDbContext())
{
using(NemeStatsDataContext nemeStatsDataContext = new NemeStatsDataContext())
{
Player player1 = nemeStatsDataContext.FindById<Player>(testPlayer1.Id);
Assert.NotNull(player1.NemesisId);
}
}
}
public void ItClearsTheNemesisIdIfThePlayerHasNoNemesis()
{
using (NemeStatsDbContext nemeStatsDbContext = new NemeStatsDbContext())
{
using (NemeStatsDataContext nemeStatsDataContext = new NemeStatsDataContext())
{
Player player5 = nemeStatsDataContext.FindById<Player>(testPlayer5.Id);
Assert.Null(player5.NemesisId);
}
}
}
private void CleanUpPlayers(NemeStatsDbContext nemeStatsDbContext)
{
CleanUpNemeses(nemeStatsDbContext);
CleanUpPlayerByPlayerName(testPlayer1Name, nemeStatsDbContext);
CleanUpPlayerByPlayerName(testPlayer2Name, nemeStatsDbContext);
CleanUpPlayerByPlayerName(testPlayer3Name, nemeStatsDbContext);
CleanUpPlayerByPlayerName(testPlayer4Name, nemeStatsDbContext);
CleanUpPlayerByPlayerName(testPlayer5Name, nemeStatsDbContext);
CleanUpPlayerByPlayerName(testPlayer6Name, nemeStatsDbContext);
CleanUpPlayerByPlayerName(testPlayer7Name, nemeStatsDbContext);
CleanUpPlayerByPlayerName(testPlayer8Name, nemeStatsDbContext);
CleanUpPlayerByPlayerName(testPlayer9UndefeatedWith5GamesName, nemeStatsDbContext);
CleanUpPlayerByPlayerName(testPlayerWithNoPlayedGamesName, nemeStatsDbContext);
}
