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 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 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 ItGetsTheTotalPoints()
{
using (IDataContext dataContext = new NemeStatsDataContext())
{
IPlayerRepository playerRepository = new EntityFrameworkPlayerRepository(dataContext);
IPlayedGameRetriever playedGameRetriever = new PlayedGameRetriever(dataContext);
IPlayerRetriever playerRetriever = new PlayerRetriever(dataContext, playerRepository, playedGameRetriever);
PlayerStatistics playerStatistics = playerRetriever.GetPlayerStatistics(testPlayer1.Id);
int totalBasePoints = 0;
int totalGameDurationPoints = 0;
int totalWeightBonusPoints = 0;
foreach (PlayedGame playedGame in testPlayedGames)
{
if (playedGame.PlayerGameResults.Any(result => result.PlayerId == testPlayer1.Id))
{
var playerGameResult = playedGame.PlayerGameResults.First(result => result.PlayerId == testPlayer1.Id);
totalBasePoints += playerGameResult.NemeStatsPointsAwarded;
totalGameDurationPoints += playerGameResult.GameDurationBonusPoints;
totalWeightBonusPoints += playerGameResult.GameWeightBonusPoints;
}
}
Assert.AreEqual(totalBasePoints, playerStatistics.NemePointsSummary.BaseNemePoints);
Assert.AreEqual(totalGameDurationPoints, playerStatistics.NemePointsSummary.GameDurationBonusNemePoints);
Assert.AreEqual(totalWeightBonusPoints, playerStatistics.NemePointsSummary.WeightBonusNemePoints);
}
}
public void ItGetsTheGamesPlayedMetrics()
{
using (IDataContext dataContext = new NemeStatsDataContext())
{
IPlayerRepository playerRepository = new EntityFrameworkPlayerRepository(dataContext);
IPlayedGameRetriever playedGameRetriever = new PlayedGameRetriever(dataContext);
IPlayerRetriever playerRetriever = new PlayerRetriever(dataContext, playerRepository, playedGameRetriever);
PlayerStatistics playerStatistics = playerRetriever.GetPlayerStatistics(testPlayer1.Id);
int totalGamesForPlayer1 = testPlayedGames
.Count(playedGame => playedGame.PlayerGameResults
.Any(playerGameResult => playerGameResult.PlayerId == testPlayer1.Id));
Assert.That(playerStatistics.TotalGames, Is.EqualTo(totalGamesForPlayer1));
int totalWinsForPlayer1 = testPlayedGames
.Count(playedGame => playedGame.PlayerGameResults
.Any(playerGameResult => playerGameResult.PlayerId == testPlayer1.Id && playerGameResult.GameRank == 1));
Assert.That(playerStatistics.TotalGamesWon, Is.EqualTo(totalWinsForPlayer1));
int totalLossesForPlayer1 = testPlayedGames
.Count(playedGame => playedGame.PlayerGameResults
.Any(playerGameResult => playerGameResult.PlayerId == testPlayer1.Id && playerGameResult.GameRank != 1));
Assert.That(playerStatistics.TotalGamesLost, Is.EqualTo(totalLossesForPlayer1));
int winPercentageForPlayer1 = (int)((decimal)totalWinsForPlayer1 / (totalGamesForPlayer1) * 100);
Assert.That(playerStatistics.WinPercentage, Is.EqualTo(winPercentageForPlayer1));
}
}
public void ItGetsTheGamesPlayedMetrics()
{
using (IDataContext dataContext = new NemeStatsDataContext())
{
IPlayerRepository playerRepository = new EntityFrameworkPlayerRepository(dataContext);
IPlayedGameRetriever playedGameRetriever = new PlayedGameRetriever(dataContext);
IPlayerRetriever playerRetriever = new PlayerRetriever(dataContext, playerRepository, playedGameRetriever);
PlayerStatistics playerStatistics = playerRetriever.GetPlayerStatistics(testPlayer1.Id);
int totalGamesForPlayer1 = testPlayedGames
.Count(playedGame => playedGame.PlayerGameResults
.Any(playerGameResult => playerGameResult.PlayerId == testPlayer1.Id));
Assert.That(playerStatistics.TotalGames, Is.EqualTo(totalGamesForPlayer1));
int totalWinsForPlayer1 = testPlayedGames
.Count(playedGame => playedGame.PlayerGameResults
.Any(playerGameResult => playerGameResult.PlayerId == testPlayer1.Id && playerGameResult.GameRank == 1));
Assert.That(playerStatistics.TotalGamesWon, Is.EqualTo(totalWinsForPlayer1));
int totalLossesForPlayer1 = testPlayedGames
.Count(playedGame => playedGame.PlayerGameResults
.Any(playerGameResult => playerGameResult.PlayerId == testPlayer1.Id && playerGameResult.GameRank != 1));
Assert.That(playerStatistics.TotalGamesLost, Is.EqualTo(totalLossesForPlayer1));
int winPercentageForPlayer1 = (int)((decimal)totalWinsForPlayer1 / (totalGamesForPlayer1) * 100);
Assert.That(playerStatistics.WinPercentage, Is.EqualTo(winPercentageForPlayer1));
}
}
public void ItGetsTheTotalPoints()
{
using (IDataContext dataContext = new NemeStatsDataContext())
{
IPlayerRepository playerRepository = new EntityFrameworkPlayerRepository(dataContext);
IPlayedGameRetriever playedGameRetriever = new PlayedGameRetriever(dataContext);
IPlayerRetriever playerRetriever = new PlayerRetriever(dataContext, playerRepository, playedGameRetriever);
PlayerStatistics playerStatistics = playerRetriever.GetPlayerStatistics(testPlayer1.Id);
int totalBasePoints = 0;
int totalGameDurationPoints = 0;
int totalWeightBonusPoints = 0;
foreach(PlayedGame playedGame in testPlayedGames)
{
if(playedGame.PlayerGameResults.Any(result => result.PlayerId == testPlayer1.Id))
{
var playerGameResult = playedGame.PlayerGameResults.First(result => result.PlayerId == testPlayer1.Id);
totalBasePoints += playerGameResult.NemeStatsPointsAwarded;
totalGameDurationPoints += playerGameResult.GameDurationBonusPoints;
totalWeightBonusPoints += playerGameResult.GameWeightBonusPoints;
}
}
Assert.AreEqual(totalBasePoints, playerStatistics.NemePointsSummary.BaseNemePoints);
Assert.AreEqual(totalGameDurationPoints, playerStatistics.NemePointsSummary.GameDurationBonusNemePoints);
Assert.AreEqual(totalWeightBonusPoints, playerStatistics.NemePointsSummary.WeightBonusNemePoints);
}
}
private BoardGameGeekGameDefinition SaveBoardGameGeekGameDefinition(NemeStatsDataContext dataContext)
{
var boardGameGeekDefinitionCreator = new BoardGameGeekGameDefinitionCreator(dataContext, new BoardGameGeekClient(new ApiDownloaderService(), MockRepository.GenerateMock <IRollbarClient>()));
return(boardGameGeekDefinitionCreator.CreateBoardGameGeekGameDefinition(BOARD_GAME_GEEK_ID_FOR_RACE_FOR_THE_GALAXY,
testUserWithDefaultGamingGroup));
}
public PlayedGameController(
NemeStatsDataContext dataContext,
IPlayedGameRetriever playedGameRetriever,
IPlayerRetriever playerRetriever,
IPlayedGameDetailsViewModelBuilder builder,
IGameDefinitionRetriever gameDefinitionRetriever,
IPlayedGameSaver playedGameSaver,
IPlayedGameDeleter playedGameDeleter,
IPlayerSaver playerSaver,
IMapperFactory mapperFactory,
ICreatePlayedGameComponent createPlayedGameComponent,
ICreateGameDefinitionComponent createGameDefinitionComponent)
{
_dataContext = dataContext;
_playedGameRetriever = playedGameRetriever;
_playerRetriever = playerRetriever;
_playedGameDetailsBuilder = builder;
_gameDefinitionRetriever = gameDefinitionRetriever;
_playedGameSaver = playedGameSaver;
_playedGameDeleter = playedGameDeleter;
_playerSaver = playerSaver;
_mapperFactory = mapperFactory;
_createPlayedGameComponent = createPlayedGameComponent;
_createGameDefinitionComponent = createGameDefinitionComponent;
}
public void SetUp()
{
dataContextMock = MockRepository.GenerateMock<NemeStatsDataContext>();
retriever = new PendingGamingGroupInvitationRetriever(dataContextMock);
currentUser = new ApplicationUser()
{
Id = "application user id"
};
expectedApplicationUser = new ApplicationUser()
{
Id = currentUser.Id,
Email = "*****@*****.**"
};
dataContextMock.Expect(mock => mock.FindById<ApplicationUser>(currentUser.Id))
.Return(expectedApplicationUser);
expectedGamingGroupInvitations = new List<GamingGroupInvitation>();
expectedGamingGroupInvitation = new GamingGroupInvitation() { InviteeEmail = expectedApplicationUser.Email };
expectedGamingGroupInvitations.Add(expectedGamingGroupInvitation);
expectedGamingGroupInvitations.Add(new GamingGroupInvitation() { InviteeEmail = "some other email that shouldnt be included" });
dataContextMock.Expect(mock => mock.GetQueryable<GamingGroupInvitation>())
.Return(expectedGamingGroupInvitations.AsQueryable());
}
public void SetUp()
{
dataContextMock = MockRepository.GenerateMock <NemeStatsDataContext>();
retriever = new PendingGamingGroupInvitationRetriever(dataContextMock);
currentUser = new ApplicationUser()
{
Id = "application user id"
};
expectedApplicationUser = new ApplicationUser()
{
Id = currentUser.Id,
Email = "*****@*****.**"
};
dataContextMock.Expect(mock => mock.FindById <ApplicationUser>(currentUser.Id))
.Return(expectedApplicationUser);
expectedGamingGroupInvitations = new List <GamingGroupInvitation>();
expectedGamingGroupInvitation = new GamingGroupInvitation()
{
InviteeEmail = expectedApplicationUser.Email
};
expectedGamingGroupInvitations.Add(expectedGamingGroupInvitation);
expectedGamingGroupInvitations.Add(new GamingGroupInvitation()
{
InviteeEmail = "some other email that shouldnt be included"
});
dataContextMock.Expect(mock => mock.GetQueryable <GamingGroupInvitation>())
.Return(expectedGamingGroupInvitations.AsQueryable());
}
public void ItRetrievesThePlayedGame()
{
using (NemeStatsDataContext dbContext = new NemeStatsDataContext())
{
PlayedGame playedGame = GetTestSubjectPlayedGame(dbContext);
Assert.NotNull(playedGame);
}
}
public override TOutput Execute(TInput inputParameter, ApplicationUser currentUser)
{
//TODO how to use the IContainer here instead?
using (var dataContext = new NemeStatsDataContext())
{
return(ExecuteTransaction(inputParameter, currentUser, dataContext));
}
}
public void ItRetrievesThePlayedGame()
{
using (NemeStatsDataContext dbContext = new NemeStatsDataContext())
{
PlayedGame playedGame = GetTestSubjectPlayedGame(dbContext);
Assert.NotNull(playedGame);
}
}
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 ItSetsTheNemesisIdOnThePlayer()
{
using (NemeStatsDataContext nemeStatsDataContext = new NemeStatsDataContext())
{
Player player1 = nemeStatsDataContext.FindById <Player>(testPlayer1.Id);
Assert.NotNull(player1.NemesisId);
}
}
public void TestFixtureSetUp()
{
using(IDataContext dataContext = new NemeStatsDataContext())
{
playerSummaryBuilderImpl = new PlayerSummaryBuilder(dataContext);
topPlayersResult = playerSummaryBuilderImpl.GetTopPlayers(3);
}
}
public void LocalFixtureSetUp()
{
using (NemeStatsDataContext dataContext = new NemeStatsDataContext())
{
PlayedGameRetriever retriever = new PlayedGameRetriever(dataContext);
publicGameSummaryResults = retriever.GetRecentPublicGames(NUMBER_OF_GAMES_TO_RETRIEVE);
}
}
public void ItClearsTheNemesisIdIfThePlayerHasNoNemesis()
{
using (NemeStatsDataContext nemeStatsDataContext = new NemeStatsDataContext())
{
Player player5 = nemeStatsDataContext.FindById <Player>(testPlayer5.Id);
Assert.Null(player5.NemesisId);
}
}
public void TestFixtureSetUp()
{
using (IDataContext dataContext = new NemeStatsDataContext())
{
playerSummaryBuilderImpl = new PlayerSummaryBuilder(dataContext);
topPlayersResult = playerSummaryBuilderImpl.GetTopPlayers(3);
}
}
public void SetUp()
{
using (NemeStatsDataContext dataContext = new NemeStatsDataContext())
{
var playerRepository = new EntityFrameworkPlayerRepository(dataContext);
retriever = new GameDefinitionRetriever(dataContext, playerRepository);
this.actualGameDefinitionSummaries = retriever.GetAllGameDefinitions(testUserWithDefaultGamingGroup.CurrentGamingGroupId);
}
}
public void ItReturnsOnlyOneGameIfOneGameIsSpecified()
{
using (NemeStatsDataContext dataContext = new NemeStatsDataContext())
{
PlayedGameRetriever retriever = new PlayedGameRetriever(dataContext);
int one = 1;
List <PlayedGame> playedGames = retriever.GetRecentGames(one, testUserWithDefaultGamingGroup.CurrentGamingGroupId);
Assert.AreEqual(one, playedGames.Count());
}
}
public void ItOnlyReturnsGamesForTheCurrentUsersGamingGroup()
{
using (NemeStatsDataContext dataContext = new NemeStatsDataContext())
{
PlayedGameRetriever retriever = new PlayedGameRetriever(dataContext);
List <PlayedGame> playedGames = retriever.GetRecentGames(20, testUserWithOtherGamingGroup.CurrentGamingGroupId);
Assert.True(playedGames.All(game => game.GamingGroupId == testUserWithOtherGamingGroup.CurrentGamingGroupId));
}
}
public void ItReturnsOnlyTwoGamesIfTwoGamesAreSpecified()
{
using (NemeStatsDataContext dataContext = new NemeStatsDataContext())
{
PlayedGameRetriever retriever = new PlayedGameRetriever(dataContext);
int two = 2;
List <PlayedGame> playedGames = retriever.GetRecentGames(two, testUserWithDefaultGamingGroup.CurrentGamingGroupId);
Assert.AreEqual(two, playedGames.Count());
}
}
public void SetUp()
{
using(NemeStatsDataContext dataContext = new NemeStatsDataContext())
{
var playerRepository = new EntityFrameworkPlayerRepository(dataContext);
var cacheableGameDataRetriever = new BoardGameGeekGameDefinitionInfoRetriever(new DateUtilities(), new CacheService(), dataContext);
retriever = new GameDefinitionRetriever(dataContext, playerRepository, cacheableGameDataRetriever);
actualGameDefinitionSummaries = retriever.GetAllGameDefinitions(testUserWithDefaultGamingGroup.CurrentGamingGroupId);
}
}
public void SetUp()
{
using (NemeStatsDataContext dataContext = new NemeStatsDataContext())
{
var playerRepository = new EntityFrameworkPlayerRepository(dataContext);
var cacheableGameDataRetriever = new BoardGameGeekGameDefinitionInfoRetriever(new DateUtilities(), new CacheService(), dataContext);
retriever = new GameDefinitionRetriever(dataContext, playerRepository, cacheableGameDataRetriever);
actualGameDefinitionSummaries = retriever.GetAllGameDefinitions(testUserWithDefaultGamingGroup.CurrentGamingGroupId);
}
}
private GamingGroup SaveGamingGroup(NemeStatsDataContext dataContext, string gamingGroupName, ApplicationUser owningUser)
{
GamingGroup gamingGroup = new GamingGroup {
Name = gamingGroupName, OwningUserId = owningUser.Id
};
dataContext.Save(gamingGroup, owningUser);
dataContext.CommitAllChanges();
return(gamingGroup);
}
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 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 LocalFixtureSetUp()
{
using (NemeStatsDataContext dataContext = new NemeStatsDataContext())
{
var retriever = new PlayedGameRetriever(dataContext);
var recentlyPlayedGamesFilter = new RecentlyPlayedGamesFilter
{
NumberOfGamesToRetrieve = NUMBER_OF_GAMES_TO_RETRIEVE
};
publicGameSummaryResults = retriever.GetRecentPublicGames(recentlyPlayedGamesFilter);
}
}
public void LocalFixtureSetUp()
{
using (NemeStatsDataContext dataContext = new NemeStatsDataContext())
{
var retriever = new PlayedGameRetriever(dataContext);
var recentlyPlayedGamesFilter = new RecentlyPlayedGamesFilter
{
NumberOfGamesToRetrieve = NUMBER_OF_GAMES_TO_RETRIEVE
};
publicGameSummaryResults = retriever.GetRecentPublicGames(recentlyPlayedGamesFilter);
}
}
private static void Cleanup(
NemeStatsDataContext dbContext,
GamingGroup gamingGroup,
ApplicationUser currentUser)
{
GamingGroup gamingGroupToDelete = dbContext.GetQueryable<GamingGroup>()
.Where(game => game.Name == gamingGroup.Name).FirstOrDefault();
if (gamingGroupToDelete != null)
{
dbContext.Delete(gamingGroupToDelete, currentUser);
dbContext.CommitAllChanges();
}
}
public void It_Doesnt_Get_Exceptions_While_Processing_Lots_Of_Events_For_The_Same_Player()
{
//--arrange
//--act
var playedGameEvent = new PlayedGameCreatedEvent
{
//--any playedGame from the integration test base should be sufficient to generate at least one achievement
TriggerEntityId = testPlayedGames[0].Id
};
var taskList = new List <Task <bool> >();
var dataContexts = new List <NemeStatsDataContext>();
int NUMBER_OF_CALLS = 3;
for (int i = 0; i < NUMBER_OF_CALLS; i++)
{
var dataContext = new NemeStatsDataContext();
dataContexts.Add(dataContext);
}
for (int i = 0; i < NUMBER_OF_CALLS; i++)
{
var achievementsEventHandler = new AchievementsEventHandler(dataContexts[i], MockRepository.GenerateMock <IRollbarClient>());
var lastTask = new Task <bool>(() => achievementsEventHandler.Handle(playedGameEvent));
lastTask.Start();
taskList.Add(lastTask);
}
try
{
if (taskList.Any(task => !task.Result))
{
throw new AssertionException("There was an exception from one of the tasks.");
}
}
finally
{
foreach (var dataContext in dataContexts)
{
try
{
dataContext.Dispose();
}
catch (Exception)
{
//squish
}
}
}
}
public void ItThrowsAnEntityDoesNotExistExceptionIfTheIdIsInvalid()
{
int invalidId = -1;
var expectedException = new EntityDoesNotExistException(typeof(PlayedGame), invalidId);
using (NemeStatsDataContext dataContext = new NemeStatsDataContext())
{
PlayedGameRetriever retriever = new PlayedGameRetriever(dataContext);
Exception actualException = Assert.Throws <EntityDoesNotExistException>(() => retriever.GetPlayedGameDetails(invalidId));
Assert.That(expectedException.Message, Is.EqualTo(actualException.Message));
}
}
private static void Cleanup(
NemeStatsDataContext dbContext,
GamingGroup gamingGroup,
ApplicationUser currentUser)
{
GamingGroup gamingGroupToDelete = dbContext.GetQueryable <GamingGroup>()
.Where(game => game.Name == gamingGroup.Name).FirstOrDefault();
if (gamingGroupToDelete != null)
{
dbContext.Delete(gamingGroupToDelete, currentUser);
dbContext.CommitAllChanges();
}
}
public void It_Doesnt_Get_Exceptions_While_Processing_Lots_Of_Events_For_The_Same_Player()
{
//--arrange
//--act
var playedGameEvent = new PlayedGameCreatedEvent
{
//--any playedGame from the integration test base should be sufficient to generate at least one achievement
TriggerEntityId = testPlayedGames[0].Id
};
var taskList = new List<Task<bool>>();
var dataContexts = new List<NemeStatsDataContext>();
int NUMBER_OF_CALLS = 3;
for (int i = 0; i < NUMBER_OF_CALLS; i++)
{
var dataContext = new NemeStatsDataContext();
dataContexts.Add(dataContext);
}
for (int i = 0; i < NUMBER_OF_CALLS; i++)
{
var achievementsEventHandler = new AchievementsEventHandler(dataContexts[i], MockRepository.GenerateMock<IRollbarClient>());
var lastTask = new Task<bool>(() => achievementsEventHandler.Handle(playedGameEvent));
lastTask.Start();
taskList.Add(lastTask);
}
try
{
if (taskList.Any(task => !task.Result))
{
throw new AssertionException("There was an exception from one of the tasks.");
}
}
finally
{
foreach (var dataContext in dataContexts)
{
try
{
dataContext.Dispose();
}
catch (Exception)
{
//squish
}
}
}
}
public void ItGetsTheAveragePlayersPerGame()
{
using (IDataContext dataContext = new NemeStatsDataContext())
{
IPlayerRepository playerRepository = new EntityFrameworkPlayerRepository(dataContext);
IPlayedGameRetriever playedGameRetriever = new PlayedGameRetriever(dataContext);
IPlayerRetriever playerRetriever = new PlayerRetriever(dataContext, playerRepository, playedGameRetriever);
PlayerStatistics playerStatistics = playerRetriever.GetPlayerStatistics(testPlayer1.Id);
float averagePlayersPerGame = (float)testPlayedGames.Where(game => game.PlayerGameResults.Any(result => result.PlayerId == testPlayer1.Id))
.Average(game => game.NumberOfPlayers);
Assert.AreEqual(averagePlayersPerGame, playerStatistics.AveragePlayersPerGame);
}
}
public void EagerLoadTest()
{
using (NemeStatsDataContext dataContext = new NemeStatsDataContext())
{
var result = (from gameDefinition in dataContext.GetQueryable<GameDefinition>()
.Include(game => game.Champion.Player)
where gameDefinition.Id == 2004
select gameDefinition
/*select new {
Champion = gameDefinition.Champion
}*/).First();
Assert.That(result.Champion, Is.Not.Null);
Assert.That(result.Champion.Player, Is.Not.Null);
}
}
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 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 EagerLoadTest()
{
using (NemeStatsDataContext dataContext = new NemeStatsDataContext())
{
var result = (from gameDefinition in dataContext.GetQueryable <GameDefinition>()
.Include(game => game.Champion.Player)
where gameDefinition.Id == 2004
select gameDefinition
/*select new {
* Champion = gameDefinition.Champion
* }*/).First();
Assert.That(result.Champion, Is.Not.Null);
Assert.That(result.Champion.Player, Is.Not.Null);
}
}
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 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);
}
}
}
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 ItReturnsZeroesWhenThereAreNoPlayedGames()
{
using (IDataContext dataContext = new NemeStatsDataContext())
{
IPlayedGameRetriever playedGameRetriever = new PlayedGameRetriever(dataContext);
var playerRetriever = new PlayerRetriever(dataContext, new EntityFrameworkPlayerRepository(dataContext), playedGameRetriever);
var statistics = playerRetriever.GetPlayerStatistics(testPlayerWithNoPlayedGames.Id);
Assert.That(statistics.TotalGames, Is.EqualTo(0));
Assert.That(statistics.TotalGamesLost, Is.EqualTo(0));
Assert.That(statistics.TotalGamesWon, Is.EqualTo(0));
Assert.That(statistics.NemePointsSummary, Is.EqualTo(new NemePointsSummary(0, 0, 0)));
Assert.That(statistics.WinPercentage, Is.EqualTo(0));
Assert.That(statistics.AveragePlayersPerGame, Is.EqualTo(0));
Assert.That(statistics.GameDefinitionTotals.SummariesOfGameDefinitionTotals.Count, Is.EqualTo(0));
}
}
public void TestIncludeMethod()
{
using (NemeStatsDataContext dataContext = new NemeStatsDataContext(
new NemeStatsDbContext(),
new SecuredEntityValidatorFactory()))
{
List<Player> players = dataContext.GetQueryable<Player>()
.Where(player => player.Active && player.GamingGroupId == 1)
.Include(player => player.Nemesis)
.Include(player => player.Nemesis.NemesisPlayer)
.OrderBy(player => player.Name)
.ToList();
List<Player> playersWithNemesisid = players.Where(player => player.NemesisId != null).ToList();
Assert.Greater(playersWithNemesisid.Count, 0);
}
}
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 TheAddOrInsertExtensionMethodSetsTheIdOnNewEntities()
{
using(NemeStatsDataContext dataContext = new NemeStatsDataContext(
new NemeStatsDbContext(),
new SecuredEntityValidatorFactory()))
{
GamingGroup gamingGroup = new GamingGroup()
{
Name = "new gaming group without an ID yet",
OwningUserId = testUserWithDefaultGamingGroup.Id
};
dataContext.Save(gamingGroup, testUserWithDefaultGamingGroup);
dataContext.CommitAllChanges();
Cleanup(dataContext, gamingGroup, testUserWithDefaultGamingGroup);
Assert.AreNotEqual(default(int), gamingGroup.Id);
}
}
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 ItReturnsTheCorrectStatisticsForAnUndefeatedPlayer()
{
using (IDataContext dataContext = new NemeStatsDataContext())
{
IPlayedGameRetriever playedGameRetriever = new PlayedGameRetriever(dataContext);
var playerRetriever = new PlayerRetriever(dataContext, new EntityFrameworkPlayerRepository(dataContext), playedGameRetriever);
var statistics = playerRetriever.GetPlayerStatistics(testPlayer9UndefeatedWith5Games.Id);
Assert.That(statistics.TotalGames, Is.EqualTo(5));
Assert.That(statistics.TotalGamesLost, Is.EqualTo(0));
Assert.That(statistics.TotalGamesWon, Is.EqualTo(5));
Assert.That(statistics.WinPercentage, Is.EqualTo(100));
var summariesOfGameDefinitionTotals = statistics.GameDefinitionTotals.SummariesOfGameDefinitionTotals;
Assert.That(summariesOfGameDefinitionTotals.Count, Is.EqualTo(1));
var gameDefinitionTotal = summariesOfGameDefinitionTotals[0];
Assert.That(gameDefinitionTotal.GameDefinitionId, Is.EqualTo(anotherTestGameDefinitionWithOtherGamingGroupId.Id));
}
}
public PlayedGameController(
NemeStatsDataContext dataContext,
IPlayedGameRetriever playedGameRetriever,
IPlayerRetriever playerRetriever,
IPlayedGameDetailsViewModelBuilder builder,
IGameDefinitionRetriever gameDefinitionRetriever,
IPlayedGameSaver playedGameSaver,
IPlayedGameDeleter playedGameDeleter,
IGameDefinitionSaver gameDefinitionSaver,
IPlayerSaver playerSaver,
IMapperFactory mapperFactory)
{
_dataContext = dataContext;
_playedGameRetriever = playedGameRetriever;
_playerRetriever = playerRetriever;
_playedGameDetailsBuilder = builder;
_gameDefinitionRetriever = gameDefinitionRetriever;
_playedGameSaver = playedGameSaver;
_playedGameDeleter = playedGameDeleter;
_gameDefinitionSaver = gameDefinitionSaver;
_playerSaver = playerSaver;
_mapperFactory = mapperFactory;
}
public void ItReturnsOnlyTwoGamesIfTwoGamesAreSpecified()
{
using (NemeStatsDataContext dataContext = new NemeStatsDataContext())
{
PlayedGameRetriever retriever = new PlayedGameRetriever(dataContext);
int two = 2;
List<PlayedGame> playedGames = retriever.GetRecentGames(two, testUserWithDefaultGamingGroup.CurrentGamingGroupId);
Assert.AreEqual(two, playedGames.Count());
}
}
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 SetUp()
{
dataContext = new NemeStatsDataContext();
}
public void ItReturnsGamesInDescendingOrderByDatePlayed()
{
using (NemeStatsDataContext dataContext = new NemeStatsDataContext())
{
PlayedGameRetriever retriever = new PlayedGameRetriever(dataContext);
int five = 5;
List<PlayedGame> playedGames = retriever.GetRecentGames(five, testUserWithDefaultGamingGroup.CurrentGamingGroupId);
List<PlayedGame> allPlayedGames = dataContext.GetQueryable<PlayedGame>()
.Where(game => game.GamingGroupId == testUserWithDefaultGamingGroup.CurrentGamingGroupId)
.ToList()
.OrderByDescending(playedGame => playedGame.DatePlayed)
.ToList();
for(int i = 0; i<five; i++)
{
Assert.AreEqual(allPlayedGames[i].Id, playedGames[i].Id);
}
}
}
public void ItReturnsOrderedPlayerRankDescendingWithinAGivenGame()
{
using (NemeStatsDataContext dataContext = new NemeStatsDataContext())
{
PlayedGameRetriever retriever = new PlayedGameRetriever(dataContext);
int five = 5;
List<PlayedGame> playedGames = retriever.GetRecentGames(five, testUserWithDefaultGamingGroup.CurrentGamingGroupId);
int lastRank = -1;
foreach(PlayedGame playedGame in playedGames)
{
foreach(PlayerGameResult playerGameResult in playedGame.PlayerGameResults)
{
Assert.True(lastRank <= playerGameResult.GameRank);
lastRank = playerGameResult.GameRank;
}
lastRank = -1;
}
}
}
public void ItOnlyReturnsGamesForTheCurrentUsersGamingGroup()
{
using (NemeStatsDataContext dataContext = new NemeStatsDataContext())
{
PlayedGameRetriever retriever = new PlayedGameRetriever(dataContext);
List<PlayedGame> playedGames = retriever.GetRecentGames(20, testUserWithOtherGamingGroup.CurrentGamingGroupId);
Assert.True(playedGames.All(game => game.GamingGroupId == testUserWithOtherGamingGroup.CurrentGamingGroupId));
}
}
public void ItReturnsOnlyOneGameIfOneGameIsSpecified()
{
using (NemeStatsDataContext dataContext = new NemeStatsDataContext())
{
PlayedGameRetriever retriever = new PlayedGameRetriever(dataContext);
int one = 1;
List<PlayedGame> playedGames = retriever.GetRecentGames(one, testUserWithDefaultGamingGroup.CurrentGamingGroupId);
Assert.AreEqual(one, playedGames.Count());
}
}
