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 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 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 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 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()); } }