public virtual ActionResult Details(int id, ApplicationUser currentUser, [System.Web.Http.FromUri] BasicDateRangeFilter dateRangeFilter = null)
{
if (dateRangeFilter == null)
{
dateRangeFilter = new BasicDateRangeFilter();
}
string errorMessage;
if (!dateRangeFilter.IsValid(out errorMessage))
{
ModelState.AddModelError("dateRangeFilter", errorMessage);
}
var gamingGroupSummary = GetGamingGroupSummary(id, dateRangeFilter);
var viewModel = new GamingGroupViewModel
{
PublicDetailsView = new GamingGroupPublicDetailsViewModel
{
GamingGroupId = gamingGroupSummary.Id,
GamingGroupName = gamingGroupSummary.Name,
PublicDescription = gamingGroupSummary.PublicDescription,
Website = gamingGroupSummary.PublicGamingGroupWebsite,
Active = gamingGroupSummary.Active
},
DateRangeFilter = dateRangeFilter,
UserCanEdit = currentUser.CurrentGamingGroupId == id
};
return(View(MVC.GamingGroup.Views.Details, viewModel));
}
public void ItOnlySumsUpPointsFromGamesThatHappenedBeforeTheEndDate()
{
//--arrange
var playersWithNemeses = new List <PlayerWithNemesis>
{
new PlayerWithNemesis
{
PlayerId = _playerOneId
}
};
_playerGameResults.Add(MakePlayerGameResult(_playerOneId));
_autoMocker.Get <IDataContext>().Expect(mock => mock.GetQueryable <PlayerGameResult>()).Return(_playerGameResults.AsQueryable());
var dateRangeFilter = new BasicDateRangeFilter
{
ToDate = DateTime.Now.AddDays(-2)
};
//--act
_autoMocker.ClassUnderTest.PopulateNemePointsSummary(_expectedGamingGroupId, playersWithNemeses, dateRangeFilter);
//--assert
Assert.That(playersWithNemeses[0].NemePointsSummary, Is.Not.Null);
var actualNemePointsSummary = playersWithNemeses[0].NemePointsSummary;
Assert.That(actualNemePointsSummary.GameDurationBonusNemePoints, Is.EqualTo(0));
Assert.That(actualNemePointsSummary.BaseNemePoints, Is.EqualTo(0));
Assert.That(actualNemePointsSummary.WeightBonusNemePoints, Is.EqualTo(0));
}
public virtual ActionResult GetGamingGroupStats(int gamingGroupId, [System.Web.Http.FromUri] BasicDateRangeFilter dateRangeFilter = null)
{
var gamingGroupStats = _gamingGroupRetriever.GetGamingGroupStats(gamingGroupId, dateRangeFilter);
var viewModel = _transformer.Transform <GamingGroupStatsViewModel>(gamingGroupStats);
return(PartialView(MVC.GamingGroup.Views._GamingGroupStatsPartial, viewModel));
}
public List <PlayedGame> GetRecentGames(int numberOfGames, int gamingGroupId, IDateRangeFilter dateRangeFilter = null)
{
if (dateRangeFilter == null)
{
dateRangeFilter = new BasicDateRangeFilter();
}
List <PlayedGame> playedGames = dataContext.GetQueryable <PlayedGame>()
.Where(game => game.GamingGroupId == gamingGroupId &&
game.DatePlayed >= dateRangeFilter.FromDate &&
game.DatePlayed <= dateRangeFilter.ToDate)
.Include(playedGame => playedGame.GameDefinition.BoardGameGeekGameDefinition)
.Include(playedGame => playedGame.GamingGroup)
.Include(playedGame => playedGame.PlayerGameResults
.Select(playerGameResult => playerGameResult.Player))
.OrderByDescending(orderBy => orderBy.DatePlayed)
.ThenByDescending(orderBy => orderBy.DateCreated)
.Take(numberOfGames)
.ToList();
//TODO this seems ridiculous but I can't see how to order a related entity in Entity Framework :(
foreach (PlayedGame playedGame in playedGames)
{
playedGame.PlayerGameResults = playedGame.PlayerGameResults.OrderBy(orderBy => orderBy.GameRank).ToList();
}
return(playedGames);
}
public virtual ActionResult GetRecentChanges(int gamingGroupId, [System.Web.Http.FromUri] BasicDateRangeFilter dateRangeFilter = null)
{
var recentChanges = _gamingGroupRetriever.GetRecentChanges(gamingGroupId, dateRangeFilter);
var getRecentNemesisChangesRequest = new GetRecentNemesisChangesRequest
{
GamingGroupId = gamingGroupId,
NumberOfRecentChangesToRetrieve = NUMBER_OF_RECENT_NEMESIS_TO_SHOW
};
var recentNemesisChanges = _nemesisHistoryRetriever.GetRecentNemesisChanges(getRecentNemesisChangesRequest);
var recentNemesisChangesViewModel = _transformer.Transform <List <NemesisChangeViewModel> >(recentNemesisChanges);
var recentAchievemments =
recentChanges.RecentAchievements
.ToTransformedPagedList <PlayerAchievementWinner, PlayerAchievementWinnerViewModel>(_transformer);
var getRecentChampionChangesFilter =
new GetRecentChampionChangesFilter(gamingGroupId, NUMBER_OF_RECENT_CHAMPION_CHANGES_TO_SHOW);
var recentChampionChanges =
_recentChampionRetriever.GetRecentChampionChanges(getRecentChampionChangesFilter);
var recentChampionChangesViewModels =
_transformer.Transform <List <ChampionChangeViewModel> >(recentChampionChanges);
var viewModel = new RecentGamingGroupChangesViewModel
{
RecentAchievements = recentAchievemments,
RecentNemesisChanges = recentNemesisChangesViewModel,
RecentChampionChanges = recentChampionChangesViewModels
};
return(PartialView(MVC.GamingGroup.Views._GamingGroupRecentChanges, viewModel));
}
public virtual ActionResult Details(int id, ApplicationUser currentUser, [System.Web.Http.FromUri] BasicDateRangeFilter dateRangeFilter = null)
{
if (dateRangeFilter == null)
{
dateRangeFilter = new BasicDateRangeFilter();
}
string errorMessage;
if (!dateRangeFilter.IsValid(out errorMessage))
{
ModelState.AddModelError("dateRangeFilter", errorMessage);
}
var gamingGroupSummary = GetGamingGroupSummary(id, dateRangeFilter);
var viewModel = gamingGroupViewModelBuilder.Build(gamingGroupSummary, currentUser);
viewModel.PlayedGames.ShowSearchLinkInResultsHeader = true;
viewModel.DateRangeFilter = dateRangeFilter;
viewModel.UserCanEdit = currentUser.CurrentGamingGroupId == id;
ViewBag.RecentGamesSectionAnchorText = SECTION_ANCHOR_RECENT_GAMES;
ViewBag.PlayerSectionAnchorText = SECTION_ANCHOR_PLAYERS;
ViewBag.GameDefinitionSectionAnchorText = SECTION_ANCHOR_GAMEDEFINITIONS;
return(View(MVC.GamingGroup.Views.Details, viewModel));
}
public void It_Returns_The_Gaming_Group_Recent_Changes_Partial_View()
{
//--arrange
var gamingGroupId = 1;
var dateFilter = new BasicDateRangeFilter();
//--act
var viewResult = autoMocker.ClassUnderTest.GetRecentChanges(gamingGroupId, dateFilter) as PartialViewResult;
//--assert
viewResult.ViewName.ShouldBe(MVC.GamingGroup.Views._GamingGroupRecentChanges);
var viewModel = viewResult.Model as RecentGamingGroupChangesViewModel;
autoMocker.Get <IGamingGroupRetriever>().AssertWasCalled(mock => mock.GetRecentChanges(gamingGroupId, dateFilter));
//--paged lists suck to test... taking a shortcut
viewModel.RecentAchievements.ShouldNotBeNull();
var args = autoMocker.Get <INemesisHistoryRetriever>()
.GetArgumentsForCallsMadeOn(mock => mock.GetRecentNemesisChanges(Arg <GetRecentNemesisChangesRequest> .Is.Anything));
var actualRequest = args.AssertFirstCallIsType <GetRecentNemesisChangesRequest>();
actualRequest.NumberOfRecentChangesToRetrieve.ShouldBe(GamingGroupController
.NUMBER_OF_RECENT_NEMESIS_TO_SHOW);
actualRequest.GamingGroupId.ShouldBe(gamingGroupId);
viewModel.RecentNemesisChanges.ShouldBeSameAs(_expectedNemesisChangeViewModels);
var getRecentChampionArgs = autoMocker.Get <IRecentChampionRetriever>()
.GetArgumentsForCallsMadeOn(mock => mock.GetRecentChampionChanges(Arg <GetRecentChampionChangesFilter> .Is.Anything));
var actualFilter = getRecentChampionArgs.AssertFirstCallIsType <GetRecentChampionChangesFilter>();
actualFilter.NumberOfRecentChangesToShow.ShouldBe(GamingGroupController.NUMBER_OF_RECENT_CHAMPION_CHANGES_TO_SHOW);
actualFilter.GamingGroupId.ShouldBe(gamingGroupId);
viewModel.RecentChampionChanges.ShouldBeSameAs(_expectedChampionChangeViewModels);
}
public virtual List <GameDefinitionSummary> GetGameDefinitionSummaries(List <int> gameDefinitionIds)
{
var dateRangeFilter = new BasicDateRangeFilter();
var gameDefinitionSummaries = _dataContext.GetQueryable <GameDefinition>()
.Where(gameDefinition => gameDefinitionIds.Contains(gameDefinition.Id))
.Select(gameDefinition => new GameDefinitionSummary
{
Active = gameDefinition.Active,
BoardGameGeekGameDefinitionId = gameDefinition.BoardGameGeekGameDefinitionId,
Name = gameDefinition.Name,
Description = gameDefinition.Description,
GamingGroupId = gameDefinition.GamingGroupId,
Id = gameDefinition.Id,
PlayedGames = gameDefinition.PlayedGames.Where(
playedGame => playedGame.DatePlayed >= ((IDateRangeFilter)dateRangeFilter).FromDate &&
playedGame.DatePlayed <= ((IDateRangeFilter)dateRangeFilter).ToDate)
.ToList(),
Champion = gameDefinition.Champion,
ChampionId = gameDefinition.ChampionId,
PreviousChampion = gameDefinition.PreviousChampion,
PreviousChampionId = gameDefinition.PreviousChampionId,
DateCreated = gameDefinition.DateCreated,
BoardGameGeekGameDefinition = gameDefinition.BoardGameGeekGameDefinition
})
.ToList();
gameDefinitionSummaries.ForEach(x => x.BoardGameGeekInfo = x.BoardGameGeekGameDefinitionId.HasValue ?
_boardGameGeekGameDefinitionInfoRetriever.GetResults(x.BoardGameGeekGameDefinitionId.Value)
: null);
return(gameDefinitionSummaries);
}
public void It_Returns_The_Players_In_The_Specific_Gaming_Group_With_The_Specified_Date_Filter()
{
//--arrange
var gamingGroupId = 1;
var currentUser = new ApplicationUser();
var dateRangeFilter = new BasicDateRangeFilter();
var expectedResults = new List <PlayerWithNemesis>
{
new PlayerWithNemesis(),
new PlayerWithNemesis()
};
var expectedResult1 = new PlayerWithNemesisViewModel();
var expectedResult2 = new PlayerWithNemesisViewModel();
autoMocker.Get <IPlayerRetriever>().Expect(mock => mock.GetAllPlayersWithNemesisInfo(gamingGroupId, dateRangeFilter)).Return(expectedResults);
autoMocker.Get <IPlayerWithNemesisViewModelBuilder>().Expect(mock => mock.Build(expectedResults[0], currentUser)).Return(expectedResult1);
autoMocker.Get <IPlayerWithNemesisViewModelBuilder>().Expect(mock => mock.Build(expectedResults[1], currentUser)).Return(expectedResult2);
//--act
var result = autoMocker.ClassUnderTest.GetGamingGroupPlayers(gamingGroupId, currentUser, dateRangeFilter);
//--assert
var viewResult = result as PartialViewResult;
viewResult.ShouldNotBeNull();
viewResult.ViewName.ShouldBe(MVC.Player.Views._PlayersPartial);
var model = viewResult.Model as List <PlayerWithNemesisViewModel>;
model.ShouldNotBeNull();
model.Count.ShouldBe(2);
model[0].ShouldBeSameAs(expectedResult1);
model[1].ShouldBeSameAs(expectedResult2);
}
public void ItFiltersPlayedGamesThatHappenedAfterTheToDate()
{
var autoMocker = new RhinoAutoMocker <PlayerRetriever>();
autoMocker.PartialMockTheClassUnderTest();
var gamingGroupId = 1;
var toDate = new DateTime(2015, 1, 1);
var expectedNemePointsAwardedForEachGame = 50;
var queryable = new List <Player>
{
new Player
{
GamingGroupId = gamingGroupId,
PlayerGameResults = new List <PlayerGameResult>
{
new PlayerGameResult
{
GameRank = 2,
PlayedGame = new PlayedGame
{
DatePlayed = toDate.AddDays(-1)
},
NemeStatsPointsAwarded = expectedNemePointsAwardedForEachGame
},
new PlayerGameResult
{
GameRank = 1,
PlayedGame = new PlayedGame
{
DatePlayed = toDate.AddDays(1)
},
NemeStatsPointsAwarded = expectedNemePointsAwardedForEachGame
}
},
ChampionedGames = new List <Champion>()
}
}.AsQueryable();
autoMocker.Get <IDataContext>().Expect(mock => mock.GetQueryable <Player>())
.Return(queryable);
autoMocker.ClassUnderTest.Expect(mock => mock.PopulateNemePointsSummary(Arg <int> .Is.Anything, Arg <List <PlayerWithNemesis> > .Is.Anything, Arg <IDateRangeFilter> .Is.Anything));
var dateRangeFilter = new BasicDateRangeFilter
{
ToDate = toDate
};
var players = autoMocker.ClassUnderTest.GetAllPlayersWithNemesisInfo(gamingGroupId, dateRangeFilter);
Assert.That(players.Count, Is.EqualTo(1));
var player = players.First();
Assert.That(player.GamesLost, Is.EqualTo(1));
Assert.That(player.GamesWon, Is.EqualTo(0));
}
public void ItOnlyReturnsGamesPlayedWithinTheSpecifiedDateRangeFilter()
{
var expectedDateRangeFilter = new BasicDateRangeFilter
{
FromDate = new System.DateTime(2015, 1, 1),
ToDate = new System.DateTime(2015, 1, 1),
};
AssertResultsFilteredUsingThisDateRangeFilter(expectedDateRangeFilter, expectedDateRangeFilter);
}
public List <PlayerWithNemesis> GetAllPlayersWithNemesisInfo(int gamingGroupId, IDateRangeFilter dateRangeFilter = null)
{
if (dateRangeFilter == null)
{
dateRangeFilter = new BasicDateRangeFilter();
}
var playersWithNemesis = (from Player player in GetAllPlayersInGamingGroupQueryable(gamingGroupId)
.Include(player => player.PlayerGameResults)
select new PlayerWithNemesis
{
PlayerId = player.Id,
ApplicationUserId = player.ApplicationUserId,
PlayerName = player.Name,
PlayerActive = player.Active,
PlayerRegistered = !string.IsNullOrEmpty(player.ApplicationUserId),
NemesisPlayerId = player.Nemesis == null ? (int?)null : player.Nemesis.NemesisPlayerId,
NemesisPlayerName = player.Nemesis != null && player.Nemesis.NemesisPlayer != null
? player.Nemesis.NemesisPlayer.Name
: null,
PreviousNemesisPlayerId = player.PreviousNemesis == null ? (int?)null : player.PreviousNemesis.NemesisPlayerId,
PreviousNemesisPlayerName = player.PreviousNemesis != null && player.PreviousNemesis.NemesisPlayer != null
? player.PreviousNemesis.NemesisPlayer.Name
: null,
GamingGroupId = player.GamingGroupId,
GamesWon =
player.PlayerGameResults.Where(
x =>
x.PlayedGame.DatePlayed >= dateRangeFilter.FromDate &&
x.PlayedGame.DatePlayed <= dateRangeFilter.ToDate).Count(x => x.GameRank == 1),
GamesLost =
player.PlayerGameResults.Where(
x =>
x.PlayedGame.DatePlayed >= dateRangeFilter.FromDate &&
x.PlayedGame.DatePlayed <= dateRangeFilter.ToDate).Count(x => x.GameRank > 1),
//only get championed games where this player is the current champion
TotalChampionedGames =
player.ChampionedGames.Count(
champion =>
champion.GameDefinition.ChampionId != null &&
champion.GameDefinition.ChampionId.Value == champion.Id)
}
).ToList();
PopulateNemePointsSummary(gamingGroupId, playersWithNemesis, dateRangeFilter);
PopulateAchivements(playersWithNemesis);
return(playersWithNemesis//--deliberately ToList() first since Linq To Entities cannot support ordering by NemePointsSummary.TotalPoints
.OrderByDescending(x => x.PlayerActive)
.ThenByDescending(pwn => pwn.NemePointsSummary?.TotalPoints ?? 0)
.ThenByDescending(pwn => pwn.GamesWon)
.ThenBy(pwn => pwn.PlayerName)
.ToList());
}
public GamingGroupFilter(IDateRangeFilter dateRangeFilter = null)
{
if (dateRangeFilter == null)
{
DateRangeFilter = new BasicDateRangeFilter();
}
else
{
DateRangeFilter = dateRangeFilter;
}
}
public void ItUsesTheDefaultDateRangeIfNoneIsSpecified()
{
var expectedDateRange = new BasicDateRangeFilter();
autoMocker.ClassUnderTest.GetGamingGroupSummary(0);
autoMocker.Get <IGamingGroupRetriever>().AssertWasCalled(
mock => mock.GetGamingGroupDetails(
Arg <GamingGroupFilter> .Matches(x =>
x.DateRangeFilter.FromDate == expectedDateRange.FromDate &&
x.DateRangeFilter.ToDate == expectedDateRange.ToDate)));
}
public GamingGroupFilter(int gamingGroupId, IDateRangeFilter dateRangeFilter = null)
{
GamingGroupId = gamingGroupId;
if (dateRangeFilter == null)
{
DateRangeFilter = new BasicDateRangeFilter();
}
else
{
DateRangeFilter = dateRangeFilter;
}
}
public RecentGamingGroupChanges GetRecentChanges(int gamingGroupId, BasicDateRangeFilter dateFilter)
{
var recentGamingGroupChanges = new RecentGamingGroupChanges();
var query = new GetRecentPlayerAchievementsUnlockedQuery
{
GamingGroupId = gamingGroupId,
IncludeOnlyOnePage = true,
PageSize = 10
};
recentGamingGroupChanges.RecentAchievements = _recentPlayerAchievementsUnlockedRetriever.GetResults(query);
return(recentGamingGroupChanges);
}
internal virtual GamingGroupSummary GetGamingGroupSummary(int gamingGroupId, IDateRangeFilter dateRangeFilter = null)
{
if (dateRangeFilter == null)
{
dateRangeFilter = new BasicDateRangeFilter();
}
else
{
dateRangeFilter.FromDate = dateRangeFilter.FromDate;
dateRangeFilter.ToDate = dateRangeFilter.ToDate;
}
var filter = new GamingGroupFilter(gamingGroupId, dateRangeFilter);
return(_gamingGroupRetriever.GetGamingGroupDetails(filter));
}
public void It_Returns_The_Gaming_Group_Stats_Partial_View()
{
//--arrange
var gamingGroupId = 1;
var dateFilter = new BasicDateRangeFilter();
//--act
var viewResult = autoMocker.ClassUnderTest.GetGamingGroupStats(gamingGroupId, dateFilter) as PartialViewResult;
//--assert
viewResult.ViewName.ShouldBe(MVC.GamingGroup.Views._GamingGroupStatsPartial);
autoMocker.Get <IGamingGroupRetriever>().AssertWasCalled(mock => mock.GetGamingGroupStats(gamingGroupId, dateFilter));
var viewModel = viewResult.Model as GamingGroupStatsViewModel;
viewModel.ShouldNotBeNull();
viewModel.ShouldBeSameAs(_expectedStatsViewModel);
}
public GamingGroupStats GetGamingGroupStats(int gamingGroupId, BasicDateRangeFilter dateRangeFilter)
{
var playedGameTotals = _dataContext.GetQueryable <PlayedGame>()
.Where(x => x.GamingGroupId == gamingGroupId &&
x.DatePlayed >= dateRangeFilter.FromDate &&
x.DatePlayed <= dateRangeFilter.ToDate)
.GroupBy(x => x.GameDefinitionId)
.Select(g => new
{
Id = g.Key,
NumberOfGamesPlayed = g.Count()
}).ToList();
var totalPlayedGames = playedGameTotals.Sum(x => x.NumberOfGamesPlayed);
var totalNumberOfGamesWithPlays = playedGameTotals.Distinct().Count();
var numberOfGamesOwned = _dataContext.GetQueryable <GameDefinition>().Count(x => x.GamingGroupId == gamingGroupId);
var playerResults = _dataContext.GetQueryable <Player>()
.Where(x => x.GamingGroupId == gamingGroupId)
.GroupBy(x => x.PlayerGameResults.Any(y => y.PlayedGame.DatePlayed >= dateRangeFilter.FromDate &&
y.PlayedGame.DatePlayed <= dateRangeFilter.ToDate))
.Select(x => new
{
HasPlays = x.Key,
NumberOfRecords = x.Count()
}).ToList();
var totalNumberOfPlayersWithPlays = 0;
var resultForPlayersWithPlays = playerResults.SingleOrDefault(x => x.HasPlays);
if (resultForPlayersWithPlays != null)
{
totalNumberOfPlayersWithPlays = resultForPlayersWithPlays.NumberOfRecords;
}
var totalNumberOfPlayers = playerResults.Sum(x => x.NumberOfRecords);
return(new GamingGroupStats
{
TotalPlayedGames = totalPlayedGames,
TotalNumberOfGamesWithPlays = totalNumberOfGamesWithPlays,
TotalGamesOwned = numberOfGamesOwned,
TotalNumberOfPlayersWithPlays = totalNumberOfPlayersWithPlays,
TotalNumberOfPlayers = totalNumberOfPlayers
});
}
public void It_Returns_The_Specified_Number_Of_Played_Games_In_The_Specific_Gaming_Group_With_The_Specified_Date_Filter()
{
//--arrange
var gamingGroupId = 1;
var currentUser = new ApplicationUser();
var dateRangeFilter = new BasicDateRangeFilter();
var numberOfItems = 2;
var expectedPlayedGames = new List <PlayedGame>
{
new PlayedGame(),
new PlayedGame()
};
var expectedResult1 = new PlayedGameDetailsViewModel();
var expectedResult2 = new PlayedGameDetailsViewModel();
autoMocker.Get <IPlayedGameRetriever>()
.Expect(mock => mock.GetRecentGames(numberOfItems, gamingGroupId, dateRangeFilter))
.Return(expectedPlayedGames);
autoMocker.Get <IPlayedGameDetailsViewModelBuilder>()
.Expect(mock => mock.Build(expectedPlayedGames[0], currentUser))
.Return(expectedResult1);
autoMocker.Get <IPlayedGameDetailsViewModelBuilder>()
.Expect(mock => mock.Build(expectedPlayedGames[1], currentUser))
.Return(expectedResult2);
//--act
var result = autoMocker.ClassUnderTest.GetGamingGroupPlayedGames(gamingGroupId, currentUser, dateRangeFilter, numberOfItems);
//--assert
var viewResult = result as PartialViewResult;
viewResult.ShouldNotBeNull();
viewResult.ViewName.ShouldBe(MVC.PlayedGame.Views._PlayedGamesPartial);
var model = viewResult.Model as PlayedGamesViewModel;
model.ShouldNotBeNull();
model.GamingGroupId.ShouldBe(gamingGroupId);
model.ShowSearchLinkInResultsHeader.ShouldBeTrue();
model.UserCanEdit.ShouldBeFalse("UserCanEdit should only be true if the Gaming Group is the current user's Gaming Group.");
model.PlayedGameDetailsViewModels.ShouldNotBeNull();
model.PlayedGameDetailsViewModels.Count.ShouldBe(2);
model.PlayedGameDetailsViewModels[0].ShouldBeSameAs(expectedResult1);
model.PlayedGameDetailsViewModels[1].ShouldBeSameAs(expectedResult2);
}
public virtual IList <GameDefinitionSummary> GetAllGameDefinitions(int gamingGroupId, IDateRangeFilter dateRangeFilter = null)
{
if (dateRangeFilter == null)
{
dateRangeFilter = new BasicDateRangeFilter();
}
var returnValue = _dataContext.GetQueryable <GameDefinition>()
.Where(gameDefinition => gameDefinition.GamingGroupId == gamingGroupId && gameDefinition.Active)
.Select(gameDefinition => new GameDefinitionSummary
{
Active = gameDefinition.Active,
BoardGameGeekGameDefinitionId = gameDefinition.BoardGameGeekGameDefinitionId,
Name = gameDefinition.Name,
Description = gameDefinition.Description,
GamingGroupId = gameDefinition.GamingGroupId,
Id = gameDefinition.Id,
PlayedGames = gameDefinition.PlayedGames.Where(
playedGame => playedGame.DatePlayed >= dateRangeFilter.FromDate &&
playedGame.DatePlayed <= dateRangeFilter.ToDate)
.ToList(),
Champion = gameDefinition.Champion,
ChampionId = gameDefinition.ChampionId,
PreviousChampion = gameDefinition.PreviousChampion,
PreviousChampionId = gameDefinition.PreviousChampionId,
DateCreated = gameDefinition.DateCreated
})
.OrderBy(game => game.Name)
.ToList();
AddPlayersToChampionData(returnValue);
returnValue.ForEach(summary =>
{
summary.Champion = summary.Champion ?? new NullChampion();
summary.PreviousChampion = summary.PreviousChampion ?? new NullChampion();
summary.TotalNumberOfGamesPlayed = summary.PlayedGames.Count;
if (summary.BoardGameGeekGameDefinitionId.HasValue)
{
summary.BoardGameGeekInfo = _boardGameGeekGameDefinitionInfoRetriever.GetResults(summary.BoardGameGeekGameDefinitionId.Value);
}
});
return(returnValue);
}
public void ItReturnsGamesInDescendingOrderByDatePlayed()
{
using (var dataContext = new NemeStatsDataContext())
{
var dateRangeFilter = new BasicDateRangeFilter();
var five = 5;
List <PlayedGame> playedGames = _retriever.GetRecentGames(five, testUserWithDefaultGamingGroup.CurrentGamingGroupId.Value, dateRangeFilter);
var allPlayedGames = dataContext.GetQueryable <PlayedGame>()
.Where(game => game.GamingGroupId == testUserWithDefaultGamingGroup.CurrentGamingGroupId &&
game.DatePlayed <= dateRangeFilter.ToDate)
.ToList()
.OrderByDescending(playedGame => playedGame.DatePlayed)
.ToList();
for (var i = 0; i < five; i++)
{
Assert.AreEqual(allPlayedGames[i].Id, playedGames[i].Id);
}
}
}
public override void SetUp()
{
base.SetUp();
gamingGroupSummary = new GamingGroupSummary()
{
PlayedGames = new List <PlayedGame>()
};
_gamingGroupViewModel = new GamingGroupViewModel();
dateRangeFilter = new BasicDateRangeFilter();
autoMocker.ClassUnderTest.Expect(mock => mock.GetGamingGroupSummary(
Arg <int> .Is.Anything,
Arg <IDateRangeFilter> .Is.Anything))
.Repeat.Once()
.Return(gamingGroupSummary);
autoMocker.Get <IGamingGroupViewModelBuilder>().Expect(mock => mock.Build(gamingGroupSummary, currentUser))
.Return(_gamingGroupViewModel);
}
internal virtual GamingGroupSummary GetGamingGroupSummary(int gamingGroupId, IDateRangeFilter dateRangeFilter = null)
{
if (dateRangeFilter == null)
{
dateRangeFilter = new BasicDateRangeFilter();
}
else
{
dateRangeFilter.FromDate = dateRangeFilter.FromDate;
dateRangeFilter.ToDate = dateRangeFilter.ToDate;
}
var filter = new GamingGroupFilter(dateRangeFilter)
{
NumberOfRecentGamesToShow = MAX_NUMBER_OF_RECENT_GAMES,
GamingGroupId = gamingGroupId
};
return(gamingGroupRetriever.GetGamingGroupDetails(filter));
}
public override void SetUp()
{
base.SetUp();
_gamingGroupSummary = new GamingGroupSummary
{
Id = 1,
Name = "some gaming group name",
DateCreated = DateTime.MaxValue,
PublicDescription = "some public description",
PublicGamingGroupWebsite = "https://website.com"
};
_dateRangeFilter = new BasicDateRangeFilter();
autoMocker.ClassUnderTest.Expect(mock => mock.GetGamingGroupSummary(
Arg <int> .Is.Anything,
Arg <IDateRangeFilter> .Is.Anything))
.Repeat.Once()
.Return(_gamingGroupSummary);
}
private void AssertResultsFilteredUsingThisDateRangeFilter(BasicDateRangeFilter expectedDateRangeFilter, BasicDateRangeFilter actualFilterPassed = null)
{
int playedGameIdForTooOldGame = 1;
int expectedPlayedGameId = 2;
int playedGameIdForTooNewGame = 3;
var queryable = new List <GameDefinition>
{
new GameDefinition
{
GamingGroupId = gamingGroupId,
PlayedGames = new List <PlayedGame>
{
new PlayedGame
{
Id = playedGameIdForTooOldGame,
DatePlayed = expectedDateRangeFilter.FromDate.AddDays(-1)
},
new PlayedGame
{
Id = expectedPlayedGameId,
DatePlayed = expectedDateRangeFilter.FromDate
},
new PlayedGame
{
Id = playedGameIdForTooNewGame,
DatePlayed = expectedDateRangeFilter.ToDate.AddDays(1)
}
}
}
}.AsQueryable();
autoMocker.Get <IDataContext>().Expect(mock => mock.GetQueryable <GameDefinition>())
.Repeat.Once()
.Return(queryable);
var result = autoMocker.ClassUnderTest.GetAllGameDefinitions(currentUser.CurrentGamingGroupId.Value, actualFilterPassed)[0];
Assert.True(result.PlayedGames.All(playedGame => playedGame.Id == expectedPlayedGameId));
}
public void It_Returns_The_Game_Definitions_In_The_Specific_Gaming_Group_With_The_Specified_Date_Filter_Ordered_By_Total_Games_Played_Descending()
{
//--arrange
var gamingGroupId = 1;
var currentUser = new ApplicationUser();
var dateRangeFilter = new BasicDateRangeFilter();
var expectedResults = new List <GameDefinitionSummary>
{
new GameDefinitionSummary(),
new GameDefinitionSummary()
};
var expectedResult1 = new GameDefinitionSummaryViewModel
{
TotalNumberOfGamesPlayed = 1
};
var expectedResult2 = new GameDefinitionSummaryViewModel()
{
TotalNumberOfGamesPlayed = 2
};
autoMocker.Get <IGameDefinitionRetriever>().Expect(mock => mock.GetAllGameDefinitions(gamingGroupId, dateRangeFilter)).Return(expectedResults);
autoMocker.Get <IGameDefinitionSummaryViewModelBuilder>().Expect(mock => mock.Build(expectedResults[0], currentUser)).Return(expectedResult1);
autoMocker.Get <IGameDefinitionSummaryViewModelBuilder>().Expect(mock => mock.Build(expectedResults[1], currentUser)).Return(expectedResult2);
//--act
var result = autoMocker.ClassUnderTest.GetGamingGroupGameDefinitions(gamingGroupId, currentUser, dateRangeFilter);
//--assert
var viewResult = result as PartialViewResult;
viewResult.ShouldNotBeNull();
viewResult.ViewName.ShouldBe(MVC.GameDefinition.Views._GameDefinitionsPartial);
var model = viewResult.Model as List <GameDefinitionSummaryViewModel>;
model.ShouldNotBeNull();
model.Count.ShouldBe(2);
//--the second result is the one that has more total games and should be first
model[0].ShouldBeSameAs(expectedResult2);
model[1].ShouldBeSameAs(expectedResult1);
}
public void Users_Can_Edit_If_This_Is_Their_Gaming_Group()
{
//--arrange
var gamingGroupId = 1;
var currentUser = new ApplicationUser
{
CurrentGamingGroupId = gamingGroupId
};
var dateRangeFilter = new BasicDateRangeFilter();
autoMocker.Get <IPlayedGameRetriever>().Expect(mock => mock.GetRecentGames(0, 0, null)).IgnoreArguments().Return(new List <PlayedGame>());
//--act
var result = autoMocker.ClassUnderTest.GetGamingGroupPlayedGames(gamingGroupId, currentUser, dateRangeFilter, 0);
//--assert
var viewResult = result as PartialViewResult;
viewResult.ShouldNotBeNull();
var model = viewResult.Model as PlayedGamesViewModel;
model.ShouldNotBeNull();
model.UserCanEdit.ShouldBeTrue();
}
public override void SetUp()
{
base.SetUp();
_dateFilter = new BasicDateRangeFilter();
}
public void ItFiltersPlayedGamesThatHappenedBeforeTheFromDate()
{
var autoMocker = new RhinoAutoMocker <PlayerRetriever>();
autoMocker.PartialMockTheClassUnderTest();
var gamingGroupId = 1;
var fromDate = new DateTime(2015, 6, 1);
var expectedNemePointsAwardedForEachGame = 50;
var queryable = new List <Player>
{
new Player
{
GamingGroupId = gamingGroupId,
PlayerGameResults = new List <PlayerGameResult>
{
new PlayerGameResult
{
GameRank = 2,
PlayedGame = new PlayedGame
{
DatePlayed = fromDate.AddDays(-1)
},
NemeStatsPointsAwarded = expectedNemePointsAwardedForEachGame
},
new PlayerGameResult
{
GameRank = 1,
PlayedGame = new PlayedGame
{
DatePlayed = fromDate.AddDays(1)
},
NemeStatsPointsAwarded = expectedNemePointsAwardedForEachGame
},
new PlayerGameResult
{
GameRank = 1,
PlayedGame = new PlayedGame
{
DatePlayed = fromDate.AddDays(-1)
},
NemeStatsPointsAwarded = expectedNemePointsAwardedForEachGame
}
},
//--have to do this because entity framework can handle the null relationship, but pure LINQ cannot :(
Nemesis = new Nemesis
{
NemesisPlayer = new Player()
},
PreviousNemesis = new Nemesis
{
NemesisPlayer = new Player()
},
ChampionedGames = new List <Champion>()
}
}.AsQueryable();
autoMocker.Get <IDataContext>().Expect(mock => mock.GetQueryable <Player>())
.Return(queryable);
autoMocker.ClassUnderTest.Expect(mock => mock.PopulateNemePointsSummary(Arg <int> .Is.Anything, Arg <List <PlayerWithNemesis> > .Is.Anything, Arg <IDateRangeFilter> .Is.Anything));
var dateRangeFilter = new BasicDateRangeFilter
{
FromDate = fromDate
};
var players = autoMocker.ClassUnderTest.GetAllPlayersWithNemesisInfo(gamingGroupId, dateRangeFilter);
Assert.That(players.Count, Is.EqualTo(1));
var player = players.First();
Assert.That(player.GamesLost, Is.EqualTo(0));
Assert.That(player.GamesWon, Is.EqualTo(1));
}
