public void ItAttachesToABoardGameGeekGameDefinitionIfItHasABoardGameGeekGameDefinitionId()
{
var createGameDefinitionRequest = new CreateGameDefinitionRequest
{
Name = "some new game name",
BoardGameGeekGameDefinitionId = 1
};
_dataContextMock.Expect(mock => mock.GetQueryable <GameDefinition>()).Return(new List <GameDefinition>().AsQueryable());
const int EXPECTED_BGG_ID = 2;
var expectedBoardGameGeekGameDefinition = new BoardGameGeekGameDefinition
{
Id = 2
};
_autoMocker.Get <IBoardGameGeekGameDefinitionCreator>().Expect(
mock => mock.CreateBoardGameGeekGameDefinition(createGameDefinitionRequest.BoardGameGeekGameDefinitionId.Value))
.Return(expectedBoardGameGeekGameDefinition);
_autoMocker.ClassUnderTest.Execute(createGameDefinitionRequest, _currentUser, _dataContextMock);
var args = _dataContextMock.GetArgumentsForCallsMadeOn(
dataContext => dataContext.Save(Arg <GameDefinition> .Is.Anything, Arg <ApplicationUser> .Is.Anything));
var actualGameDefinition = args[0][0] as GameDefinition;
Assert.That(actualGameDefinition, Is.Not.Null);
Assert.That(actualGameDefinition.BoardGameGeekGameDefinitionId, Is.EqualTo(EXPECTED_BGG_ID));
}
private void AssertBoardGameGeekGameDefinitionSaved(GameDetails expectedGameDetails)
{
var argumentsForCallsMadeOn = _autoMocker.Get <IDataContext>().GetArgumentsForCallsMadeOn(
mock => mock.Save(Arg <BoardGameGeekGameDefinition> .Is.Anything,
Arg <ApplicationUser> .Is.Anything));
Assert.That(argumentsForCallsMadeOn, Is.Not.Null);
BoardGameGeekGameDefinition actualBoardGameGeekGameDefinition = null;
foreach (var call in argumentsForCallsMadeOn)
{
actualBoardGameGeekGameDefinition = call[0] as BoardGameGeekGameDefinition;
Assert.That(actualBoardGameGeekGameDefinition, Is.Not.Null);
if (actualBoardGameGeekGameDefinition.Id == expectedGameDetails.GameId)
{
break;
}
}
Assert.That(actualBoardGameGeekGameDefinition, Is.Not.Null);
Assert.That(actualBoardGameGeekGameDefinition.AverageWeight, Is.EqualTo(expectedGameDetails.AverageWeight));
Assert.That(actualBoardGameGeekGameDefinition.Description, Is.EqualTo(expectedGameDetails.Description));
Assert.That(actualBoardGameGeekGameDefinition.MaxPlayTime, Is.EqualTo(expectedGameDetails.MaxPlayTime));
Assert.That(actualBoardGameGeekGameDefinition.MinPlayTime, Is.EqualTo(expectedGameDetails.MinPlayTime));
Assert.That(actualBoardGameGeekGameDefinition.MaxPlayers, Is.EqualTo(expectedGameDetails.MaxPlayers));
Assert.That(actualBoardGameGeekGameDefinition.MinPlayers, Is.EqualTo(expectedGameDetails.MinPlayers));
Assert.That(actualBoardGameGeekGameDefinition.Name, Is.EqualTo(expectedGameDetails.Name));
Assert.That(actualBoardGameGeekGameDefinition.Thumbnail, Is.EqualTo(expectedGameDetails.Thumbnail));
}
public virtual List <PlayerGameResult> MakePlayerGameResults(
SaveableGameBase savedGame,
int?boardGameGeekGameDefinitionId, IDataContext dataContext)
{
BoardGameGeekGameDefinition boardGameGeekGameDefinition = null;
if (boardGameGeekGameDefinitionId.HasValue)
{
boardGameGeekGameDefinition = dataContext.FindById <BoardGameGeekGameDefinition>(boardGameGeekGameDefinitionId.Value);
}
var pointsDictionary = _pointsCalculator.CalculatePoints(savedGame.PlayerRanks, boardGameGeekGameDefinition);
var playerGameResults = savedGame.PlayerRanks
.Select(playerRank =>
{
var pointsScorecard = pointsDictionary[playerRank.PlayerId];
return(new PlayerGameResult
{
PlayerId = playerRank.PlayerId,
GameRank = playerRank.GameRank,
NemeStatsPointsAwarded = pointsScorecard.BasePoints,
GameDurationBonusPoints = pointsScorecard.GameDurationBonusPoints,
GameWeightBonusPoints = pointsScorecard.GameWeightBonusPoints,
PointsScored = playerRank.PointsScored
});
})
.ToList();
return(playerGameResults);
}
public void ItReturnsNullIfNeitherMaxNorMinPlayTimeIsSet()
{
//--arrange
var boardGameGeekGameDefinition = new BoardGameGeekGameDefinition();
//--act/assert
Assert.That(boardGameGeekGameDefinition.AveragePlayTime, Is.Null);
}
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);
testBoardGameGeekGameDefinition = SaveBoardGameGeekGameDefinition(dataContext);
testGameDefinition = SaveGameDefinition(nemeStatsDbContext, testGamingGroup.Id, testGameName, testBoardGameGeekGameDefinition.Id);
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);
}
using (NemeStatsDataContext dataContext = new NemeStatsDataContext())
{
CreatePlayedGames(dataContext);
}
}
}
public void SetUp()
{
_autoMocker = new RhinoAutoMocker<UniversalGameRetriever>();
_gameWithNoPlays = new BoardGameGeekGameDefinition
{
Id = 2,
DateCreated = DateTime.UtcNow.AddYears(-5),
GameDefinitions = new List<GameDefinition>
{
new GameDefinition
{
}
}
};
_gameWithPlays = new BoardGameGeekGameDefinition
{
Id = 1,
GameDefinitions = new List<GameDefinition>
{
new GameDefinition
{
PlayedGames = new List<PlayedGame>
{
new PlayedGame
{
DatePlayed = _mostRecentPlayedGame.AddDays(-4)
}
}
},
new GameDefinition
{
PlayedGames = new List<PlayedGame>
{
new PlayedGame
{
DatePlayed = _mostRecentPlayedGame.AddDays(-3)
},
new PlayedGame
{
DatePlayed = _mostRecentPlayedGame
}
}
}
}
};
var queryable = new List<BoardGameGeekGameDefinition>
{
_gameWithNoPlays,
_gameWithPlays
}.AsQueryable();
_autoMocker.Get<IDataContext>().Expect(mock => mock.GetQueryable<BoardGameGeekGameDefinition>()).Return(queryable);
}
private void CleanUpBoardGameGeekGameDefinitions(BoardGameGeekGameDefinition boardGameGeekGameDefinition)
{
try
{
_nemeStatsDbContext.BoardGameGeekGameDefinitions.Remove(boardGameGeekGameDefinition);
}
catch (Exception)
{
}
}
public Dictionary<int, PointsScorecard> CalculatePoints(IList<PlayerRank> playerRanks, BoardGameGeekGameDefinition bggGameDefinition)
{
ValidatePlayerRanks(playerRanks);
var playerToPoints = AwardBasePoints(playerRanks);
_weightBonusCalculator.CalculateWeightBonus(playerToPoints, bggGameDefinition?.AverageWeight);
_gameDurationBonusCalculator.CalculateGameDurationBonus(playerToPoints, bggGameDefinition?.AveragePlayTime);
return playerToPoints;
}
public void SetUp()
{
_autoMocker = new RhinoAutoMocker <UniversalGameRetriever>();
_gameWithNoPlays = new BoardGameGeekGameDefinition
{
Id = 2,
DateCreated = DateTime.UtcNow.AddYears(-5),
GameDefinitions = new List <GameDefinition>
{
new GameDefinition
{
}
}
};
_gameWithPlays = new BoardGameGeekGameDefinition
{
Id = 1,
GameDefinitions = new List <GameDefinition>
{
new GameDefinition
{
PlayedGames = new List <PlayedGame>
{
new PlayedGame
{
DatePlayed = _mostRecentPlayedGame.AddDays(-4)
}
}
},
new GameDefinition
{
PlayedGames = new List <PlayedGame>
{
new PlayedGame
{
DatePlayed = _mostRecentPlayedGame.AddDays(-3)
},
new PlayedGame
{
DatePlayed = _mostRecentPlayedGame
}
}
}
}
};
var queryable = new List <BoardGameGeekGameDefinition>
{
_gameWithNoPlays,
_gameWithPlays
}.AsQueryable();
_autoMocker.Get <IDataContext>().Expect(mock => mock.GetQueryable <BoardGameGeekGameDefinition>()).Return(queryable);
}
public void ItReturnsTheMinPlayTimeIfMinPlayTimeIsSetButNotMaxPlayTime()
{
//--arrange
var boardGameGeekGameDefinition = new BoardGameGeekGameDefinition
{
MinPlayTime = 50
};
//--act/assert
Assert.That(boardGameGeekGameDefinition.AveragePlayTime, Is.EqualTo(boardGameGeekGameDefinition.MinPlayTime));
}
private BoardGameGeekGameDefinition CreateBoardGameGeekGameDefinition(int?boardGameGeekGameDefinitionId, ApplicationUser currentUser)
{
BoardGameGeekGameDefinition newBoardGameGeekGameDefinition = null;
if (boardGameGeekGameDefinitionId.HasValue)
{
newBoardGameGeekGameDefinition = _boardGameGeekGameDefinitionCreator.CreateBoardGameGeekGameDefinition(
boardGameGeekGameDefinitionId.Value);
}
return(newBoardGameGeekGameDefinition);
}
public void ItReturnsTheAverageOfMaxAndMinPlayTimeIfTheyAreBothSet()
{
//--arrange
var boardGameGeekGameDefinition = new BoardGameGeekGameDefinition
{
MinPlayTime = 100,
MaxPlayTime = 200
};
//--act/assert
Assert.That(boardGameGeekGameDefinition.AveragePlayTime, Is.EqualTo(150));
}
private BoardGameGeekGameDefinition CreateBoardGameGeekGameDefinition(int?boardGameGeekGameDefinitionId)
{
BoardGameGeekGameDefinition newBoardGameGeekGameDefinition = null;
if (boardGameGeekGameDefinitionId.HasValue)
{
newBoardGameGeekGameDefinition = _boardGameGeekGameDefinitionCreator.CreateBoardGameGeekGameDefinition(
boardGameGeekGameDefinitionId.Value);
}
return(newBoardGameGeekGameDefinition);
}
private static void UpdateBGGDefScalars(BoardGameGeekGameDefinition existingBoardGameGeekGameDefinition, GameDetails gameDetails)
{
existingBoardGameGeekGameDefinition.DateUpdated = DateTime.UtcNow;
existingBoardGameGeekGameDefinition.AverageWeight = gameDetails.AverageWeight;
existingBoardGameGeekGameDefinition.Description = gameDetails.Description;
existingBoardGameGeekGameDefinition.MaxPlayTime = gameDetails.MaxPlayTime;
existingBoardGameGeekGameDefinition.MinPlayTime = gameDetails.MinPlayTime;
existingBoardGameGeekGameDefinition.MaxPlayers = gameDetails.MaxPlayers;
existingBoardGameGeekGameDefinition.MinPlayers = gameDetails.MinPlayers;
existingBoardGameGeekGameDefinition.Name = gameDetails.Name;
existingBoardGameGeekGameDefinition.Thumbnail = gameDetails.Thumbnail;
existingBoardGameGeekGameDefinition.Image = gameDetails.Image;
existingBoardGameGeekGameDefinition.YearPublished = gameDetails.YearPublished;
}
public void ItAwardsPointsWithTheCorrectWeight()
{
//--arrange
var expectedPlayerRanks = new List <PlayerRank>();
var bggGameDefinition = new BoardGameGeekGameDefinition
{
AverageWeight = -1
};
//--act
_autoMocker.ClassUnderTest.CalculatePoints(expectedPlayerRanks, bggGameDefinition);
//--assert
_autoMocker.ClassUnderTest.AssertWasCalled(mock => mock.AwardBasePoints(expectedPlayerRanks));
}
public void ItAwardsBonusPointsForGameWeight()
{
//--arrange
var bggGameDefinition = new BoardGameGeekGameDefinition
{
AverageWeight = WeightTierCalculator.BOARD_GAME_GEEK_WEIGHT_INCLUSIVE_LOWER_BOUND_FOR_EASY - (decimal)0.01
};
//--act
_autoMocker.ClassUnderTest.CalculatePoints(new List <PlayerRank>(), bggGameDefinition);
//--assert
_autoMocker.Get <IWeightBonusCalculator>().AssertWasCalled(
mock =>
mock.CalculateWeightBonus(Arg <Dictionary <int, PointsScorecard> > .Is.Anything,
Arg <decimal?> .Is.Equal(bggGameDefinition.AverageWeight)));
}
public override GameDefinition Execute(CreateGameDefinitionRequest createGameDefinitionRequest, ApplicationUser currentUser, IDataContext dataContextWithTransaction)
{
ValidateNotNull(createGameDefinitionRequest);
ValidateGameDefinitionNameIsNotNullOrWhitespace(createGameDefinitionRequest.Name);
int gamingGroupId = createGameDefinitionRequest.GamingGroupId ?? currentUser.CurrentGamingGroupId;
BoardGameGeekGameDefinition boardGameGeekGameDefinition = null;
if (createGameDefinitionRequest.BoardGameGeekGameDefinitionId.HasValue)
{
boardGameGeekGameDefinition = _boardGameGeekGameDefinitionCreator.CreateBoardGameGeekGameDefinition(
createGameDefinitionRequest.BoardGameGeekGameDefinitionId.Value,
currentUser);
}
var existingGameDefinition = dataContextWithTransaction.GetQueryable <GameDefinition>()
.FirstOrDefault(game => game.GamingGroupId == gamingGroupId &&
game.Name == createGameDefinitionRequest.Name);
if (existingGameDefinition == null)
{
var newGameDefinition = new GameDefinition
{
Name = createGameDefinitionRequest.Name,
BoardGameGeekGameDefinitionId = boardGameGeekGameDefinition?.Id,
Description = createGameDefinitionRequest.Description,
GamingGroupId = gamingGroupId
};
new Task(() => _eventTracker.TrackGameDefinitionCreation(currentUser, createGameDefinitionRequest.Name)).Start();
return(dataContextWithTransaction.Save(newGameDefinition, currentUser));
}
ValidateNotADuplicateGameDefinition(existingGameDefinition);
existingGameDefinition.Active = true;
existingGameDefinition.BoardGameGeekGameDefinitionId = boardGameGeekGameDefinition?.Id;
if (!string.IsNullOrWhiteSpace(createGameDefinitionRequest.Description))
{
existingGameDefinition.Description = createGameDefinitionRequest.Description;
}
return(dataContextWithTransaction.Save(existingGameDefinition, currentUser));
}
public void ItAwardsBonusPointsForGameDuration()
{
//--arrange
var bggGameDefinition = new BoardGameGeekGameDefinition
{
MaxPlayTime = 120,
MinPlayTime = 100
};
//--act
_autoMocker.ClassUnderTest.CalculatePoints(new List <PlayerRank>(), bggGameDefinition);
//--assert
_autoMocker.Get <IGameDurationBonusCalculator>().AssertWasCalled(
mock =>
mock.CalculateGameDurationBonus(Arg <Dictionary <int, PointsScorecard> > .Is.Anything,
Arg <int?> .Is.Equal(bggGameDefinition.AveragePlayTime)));
}
private BoardGameGeekGameDefinition CreateBGGGame(GameDetails gameToAdd)
{
var newRecord = new BoardGameGeekGameDefinition
{
Id = gameToAdd.GameId,
Name = gameToAdd.Name,
Thumbnail = gameToAdd.Thumbnail,
Image = gameToAdd.Image,
MaxPlayers = gameToAdd.MaxPlayers,
MinPlayers = gameToAdd.MinPlayers,
MaxPlayTime = gameToAdd.MaxPlayTime,
MinPlayTime = gameToAdd.MinPlayTime,
AverageWeight = gameToAdd.AverageWeight,
Description = gameToAdd.Description
};
_dataContext.Save(newRecord, new ApplicationUser());
return(newRecord);
}
public void ItCreatesANewBoardGameGeekGameDefinitionAndLinksToItIfItWasSuccessfullyCreated()
{
var gameDefinitionUpdateRequest = new GameDefinitionUpdateRequest
{
BoardGameGeekGameDefinitionId = 200
};
var boardGameGeekGameDefinition = new BoardGameGeekGameDefinition
{
Id = gameDefinitionUpdateRequest.BoardGameGeekGameDefinitionId.Value
};
autoMocker.Get<IBoardGameGeekGameDefinitionCreator>().Expect(
mock => mock.CreateBoardGameGeekGameDefinition(gameDefinitionUpdateRequest.BoardGameGeekGameDefinitionId.Value, currentUser))
.Return(boardGameGeekGameDefinition);
autoMocker.ClassUnderTest.UpdateGameDefinition(gameDefinitionUpdateRequest, currentUser);
autoMocker.Get<IDataContext>().AssertWasCalled(dataContext => dataContext.Save(
Arg<GameDefinition>.Matches(gameDefinition => gameDefinition.BoardGameGeekGameDefinitionId == gameDefinitionUpdateRequest.BoardGameGeekGameDefinitionId),
Arg<ApplicationUser>.Is.Same(currentUser)));
}
public void SetUp()
{
_autoMocker = new RhinoAutoMocker<UniversalStatsRetriever>();
_expectedBoardGameGeekGameDefinition = new BoardGameGeekGameDefinition
{
Id = _boardGameGeekGameDefinitionId,
GameDefinitions = new List<GameDefinition>
{
new GameDefinition
{
GamingGroupId = 1,
PlayedGames = new List<PlayedGame>
{
new PlayedGame
{
NumberOfPlayers = 2
}
}
},
new GameDefinition
{
GamingGroupId = 2,
PlayedGames = new List<PlayedGame>
{
new PlayedGame
{
NumberOfPlayers = 3
}
}
}
}
};
var queryable = new List<BoardGameGeekGameDefinition>
{
_expectedBoardGameGeekGameDefinition
}.AsQueryable();
_autoMocker.Get<IDataContext>().Expect(mock => mock.GetQueryable<BoardGameGeekGameDefinition>()).Return(queryable);
}
public void SetUp()
{
_autoMocker = new RhinoAutoMocker <UniversalStatsRetriever>();
_expectedBoardGameGeekGameDefinition = new BoardGameGeekGameDefinition
{
Id = _boardGameGeekGameDefinitionId,
GameDefinitions = new List <GameDefinition>
{
new GameDefinition
{
GamingGroupId = 1,
PlayedGames = new List <PlayedGame>
{
new PlayedGame
{
NumberOfPlayers = 2
}
}
},
new GameDefinition
{
GamingGroupId = 2,
PlayedGames = new List <PlayedGame>
{
new PlayedGame
{
NumberOfPlayers = 3
}
}
}
}
};
var queryable = new List <BoardGameGeekGameDefinition>
{
_expectedBoardGameGeekGameDefinition
}.AsQueryable();
_autoMocker.Get <IDataContext>().Expect(mock => mock.GetQueryable <BoardGameGeekGameDefinition>()).Return(queryable);
}
public void ItCreatesANewBoardGameGeekGameDefinitionAndLinksToItIfItWasSuccessfullyCreated()
{
var gameDefinitionUpdateRequest = new GameDefinitionUpdateRequest
{
BoardGameGeekGameDefinitionId = 200
};
var boardGameGeekGameDefinition = new BoardGameGeekGameDefinition
{
Id = gameDefinitionUpdateRequest.BoardGameGeekGameDefinitionId.Value
};
autoMocker.Get <IBoardGameGeekGameDefinitionCreator>().Expect(
mock => mock.CreateBoardGameGeekGameDefinition(gameDefinitionUpdateRequest.BoardGameGeekGameDefinitionId.Value))
.Return(boardGameGeekGameDefinition);
autoMocker.ClassUnderTest.UpdateGameDefinition(gameDefinitionUpdateRequest, currentUser);
autoMocker.Get <IDataContext>().AssertWasCalled(dataContext => dataContext.Save(
Arg <GameDefinition> .Matches(gameDefinition => gameDefinition.BoardGameGeekGameDefinitionId == gameDefinitionUpdateRequest.BoardGameGeekGameDefinitionId),
Arg <ApplicationUser> .Is.Same(currentUser)));
}
public int?CreateBoardGameGeekGameDefinition(int boardGameGeekGameDefinitionId, ApplicationUser currentUser)
{
BoardGameGeekGameDefinition existingRecord = null;
try
{
existingRecord = dataContext.FindById <BoardGameGeekGameDefinition>(boardGameGeekGameDefinitionId);
if (existingRecord != null)
{
return(boardGameGeekGameDefinitionId);
}
}
catch (EntityDoesNotExistException)
{
//this is OK, just means we need to create a new one
}catch (Exception)
{
throw;
}
var gameDetails = boardGameGeekApiClient.GetGameDetails(boardGameGeekGameDefinitionId);
if (gameDetails == null)
{
return(null);
}
var newRecord = new BoardGameGeekGameDefinition
{
Id = boardGameGeekGameDefinitionId,
Name = gameDetails.Name,
Thumbnail = gameDetails.Thumbnail
};
dataContext.Save(newRecord, currentUser);
return(boardGameGeekGameDefinitionId);
}
private void CreateOrUpdateBGGGame(BoardGameGeekGameDefinition existingGame, string gameName, GameDefinition game, LinkOrphanGamesJobResult result)
{
var searchResult = _boardGameGeekApiClient.SearchBoardGames(gameName, true);
if (searchResult.Any())
{
var gameToAdd = GetGameToAddFromSearch(searchResult);
if (gameToAdd != null)
{
existingGame = GetExistingBGGGameById(gameToAdd);
if (existingGame != null)
{
UpdateGameDefinition(game, existingGame.Id, result);
}
else
{
var newRecord = CreateBGGGame(gameToAdd);
UpdateGameDefinition(game, newRecord.Id, result);
}
}
}
}
public void ItAwardsBonusPointsForGameWeight()
{
//--arrange
var bggGameDefinition = new BoardGameGeekGameDefinition
{
AverageWeight = WeightTierCalculator.BOARD_GAME_GEEK_WEIGHT_INCLUSIVE_LOWER_BOUND_FOR_EASY - (decimal)0.01
};
//--act
_autoMocker.ClassUnderTest.CalculatePoints(new List<PlayerRank>(), bggGameDefinition);
//--assert
_autoMocker.Get<IWeightBonusCalculator>().AssertWasCalled(
mock =>
mock.CalculateWeightBonus(Arg<Dictionary<int, PointsScorecard>>.Is.Anything,
Arg<decimal?>.Is.Equal(bggGameDefinition.AverageWeight)));
}
public void SetUp()
{
AutoMocker = new RhinoAutoMocker<BoardGameGeekGameDefinitionInfoRetriever>();
_expectedBoardGameGeekGameDefinition = new BoardGameGeekGameDefinition
{
AverageWeight = 100,
MinPlayTime = 1,
MaxPlayTime = 3,
Id = _boardGameGeekGameDefinitionId,
MaxPlayers = 200,
MinPlayers = 201,
Name = "some game name",
Description = "some game description",
Thumbnail = "some thumbnail url",
Image = "some image url",
YearPublished = 2099,
Mechanics = new List<BoardGameGeekGameMechanic>
{
new BoardGameGeekGameMechanic
{
MechanicName = _mechanic1
},
new BoardGameGeekGameMechanic
{
MechanicName = _mechanic2
}
},
Categories = new List<BoardGameGeekGameCategory>
{
new BoardGameGeekGameCategory
{
CategoryName = _category1
},
new BoardGameGeekGameCategory
{
CategoryName = _category2
}
},
GameDefinitions = new List<GameDefinition>
{
new GameDefinition
{
GamingGroupId = 1,
PlayedGames = new List<PlayedGame>
{
new PlayedGame
{
NumberOfPlayers = 2
}
}
},
new GameDefinition
{
GamingGroupId = 2,
PlayedGames = new List<PlayedGame>
{
new PlayedGame
{
NumberOfPlayers = 3
}
}
}
}
};
var queryable = new List<BoardGameGeekGameDefinition>
{
_expectedBoardGameGeekGameDefinition
}.ToList().AsQueryable();
AutoMocker.Get<IDataContext>().Expect(mock => mock.GetQueryable<BoardGameGeekGameDefinition>()).Return(queryable);
}
public void ItSetsNemePointsForEachPlayerGameResult()
{
var playerOneId = 1;
var playerTwoId = 2;
var playerOneGameRank = 1;
var playerTwoGameRank = 2;
var playerRanks = new List <PlayerRank>
{
new PlayerRank
{
PlayerId = playerOneId,
GameRank = playerOneGameRank
},
new PlayerRank
{
PlayerId = playerTwoId,
GameRank = playerTwoGameRank
}
};
gameDefinition.BoardGameGeekGameDefinitionId = 11;
var newlyCompletedGame = new NewlyCompletedGame
{
GameDefinitionId = gameDefinition.Id,
PlayerRanks = playerRanks
};
var expectedBoardGameGeekGameDefinition = new BoardGameGeekGameDefinition();
autoMocker.Get <IDataContext>()
.Expect(mock => mock.FindById <BoardGameGeekGameDefinition>(gameDefinition.BoardGameGeekGameDefinitionId))
.Return(expectedBoardGameGeekGameDefinition);
var playerOneScorecard = new PointsScorecard
{
BasePoints = 1,
GameDurationBonusPoints = 2,
GameWeightBonusPoints = 3
};
var playerTwoScorecard = new PointsScorecard
{
BasePoints = 4,
GameDurationBonusPoints = 5,
GameWeightBonusPoints = 6
};
var expectedPointsDictionary = new Dictionary <int, PointsScorecard>
{
{ playerOneId, playerOneScorecard },
{ playerTwoId, playerTwoScorecard }
};
autoMocker.Get <IPointsCalculator>().Expect(mock => mock.CalculatePoints(playerRanks, expectedBoardGameGeekGameDefinition))
.Return(expectedPointsDictionary);
//--Act
var playedGame = autoMocker.ClassUnderTest.CreatePlayedGame(newlyCompletedGame, TransactionSource.WebApplication, currentUser);
var playerOne = playedGame.PlayerGameResults.First(gameResult => gameResult.PlayerId == playerOneId);
Assert.That(playerOne.GameDurationBonusPoints, Is.EqualTo(playerOneScorecard.GameDurationBonusPoints));
Assert.That(playerOne.GameWeightBonusPoints, Is.EqualTo(playerOneScorecard.GameWeightBonusPoints));
Assert.That(playerOne.NemeStatsPointsAwarded, Is.EqualTo(playerOneScorecard.BasePoints));
var playerTwo = playedGame.PlayerGameResults.First(gameResult => gameResult.PlayerId == playerTwoId);
Assert.That(playerTwo.GameDurationBonusPoints, Is.EqualTo(playerTwoScorecard.GameDurationBonusPoints));
Assert.That(playerTwo.GameWeightBonusPoints, Is.EqualTo(playerTwoScorecard.GameWeightBonusPoints));
Assert.That(playerTwo.NemeStatsPointsAwarded, Is.EqualTo(playerTwoScorecard.BasePoints));
}
private void CleanUpBoardGameGeekGameDefinitions(NemeStatsDbContext nemeStatsDbContext, BoardGameGeekGameDefinition boardGameGeekGameDefinition)
{
try
{
nemeStatsDbContext.BoardGameGeekGameDefinitions.Remove(boardGameGeekGameDefinition);
}
catch (Exception)
{
}
}
private BoardGameGeekGameDefinition CreateBGGGame(GameDetails gameToAdd)
{
var newRecord = new BoardGameGeekGameDefinition
{
Id = gameToAdd.GameId,
Name = gameToAdd.Name,
Thumbnail = gameToAdd.Thumbnail,
Image = gameToAdd.Image,
MaxPlayers = gameToAdd.MaxPlayers,
MinPlayers = gameToAdd.MinPlayers,
MaxPlayTime = gameToAdd.MaxPlayTime,
MinPlayTime = gameToAdd.MinPlayTime,
AverageWeight = gameToAdd.AverageWeight,
Description = gameToAdd.Description
};
_dataContext.Save(newRecord, new ApplicationUser());
return newRecord;
}
public void ItAwardsPointsWithTheCorrectWeight()
{
//--arrange
var expectedPlayerRanks = new List<PlayerRank>();
var bggGameDefinition = new BoardGameGeekGameDefinition
{
AverageWeight = -1
};
//--act
_autoMocker.ClassUnderTest.CalculatePoints(expectedPlayerRanks, bggGameDefinition);
//--assert
_autoMocker.ClassUnderTest.AssertWasCalled(mock => mock.AwardBasePoints(expectedPlayerRanks));
}
private static bool CategoryDoesntExistInGamesCategoryList(BoardGameGeekGameDefinition gameDefinition, string category)
{
return(gameDefinition.Categories.All(
c => !c.CategoryName.Equals(category, StringComparison.InvariantCultureIgnoreCase)));
}
private static bool MechanicDoesntExistInGamesMechanicsList(BoardGameGeekGameDefinition existingBoardGameGeekGameDefinition, string mechanic)
{
return(existingBoardGameGeekGameDefinition.Mechanics.All(
c => !c.MechanicName.Equals(mechanic, StringComparison.InvariantCultureIgnoreCase)));
}
public void ItAttachesToABoardGameGeekGameDefinitionIfItHasABoardGameGeekGameDefinitionId()
{
var createGameDefinitionRequest = new CreateGameDefinitionRequest
{
Name = "some new game name",
BoardGameGeekGameDefinitionId = 1
};
autoMocker.Get<IDataContext>().Expect(mock => mock.GetQueryable<GameDefinition>()).Return(new List<GameDefinition>().AsQueryable());
const int EXPECTED_BGG_ID = 2;
var expectedBoardGameGeekGameDefinition = new BoardGameGeekGameDefinition
{
Id = 2
};
autoMocker.Get<IBoardGameGeekGameDefinitionCreator>().Expect(
mock => mock.CreateBoardGameGeekGameDefinition(createGameDefinitionRequest.BoardGameGeekGameDefinitionId.Value, currentUser))
.Return(expectedBoardGameGeekGameDefinition);
autoMocker.ClassUnderTest.CreateGameDefinition(createGameDefinitionRequest, currentUser);
var args = autoMocker.Get<IDataContext>().GetArgumentsForCallsMadeOn(
dataContext => dataContext.Save(Arg<GameDefinition>.Is.Anything, Arg<ApplicationUser>.Is.Anything));
var actualGameDefinition = args[0][0] as GameDefinition;
Assert.That(actualGameDefinition, Is.Not.Null);
Assert.That(actualGameDefinition.BoardGameGeekGameDefinitionId, Is.EqualTo(EXPECTED_BGG_ID));
}
public BoardGameGeekGameDefinition CreateBoardGameGeekGameDefinition(int boardGameGeekGameDefinitionId, ApplicationUser currentUser)
{
try
{
var existingRecord = _dataContext.FindById <BoardGameGeekGameDefinition>(boardGameGeekGameDefinitionId);
if (existingRecord != null)
{
return(existingRecord);
}
}
catch (EntityDoesNotExistException)
{
//this is OK, just means we need to create a new one
}
var gameDetails = _boardGameGeekApiClient.GetGameDetails(boardGameGeekGameDefinitionId);
if (gameDetails == null)
{
return(null);
}
var newRecord = new BoardGameGeekGameDefinition
{
Id = boardGameGeekGameDefinitionId,
Name = gameDetails.Name,
Thumbnail = gameDetails.Thumbnail,
Image = gameDetails.Image,
MaxPlayers = gameDetails.MaxPlayers,
MinPlayers = gameDetails.MinPlayers,
MaxPlayTime = gameDetails.MaxPlayTime,
MinPlayTime = gameDetails.MinPlayTime,
AverageWeight = gameDetails.AverageWeight,
Description = gameDetails.Description,
YearPublished = gameDetails.YearPublished,
IsExpansion = gameDetails.IsExpansion,
Rank = gameDetails.Rank
};
_dataContext.Save(newRecord, currentUser);
// Save categories to BGG definition
foreach (var category in gameDetails.Categories)
{
var existentCategory = _dataContext.GetQueryable <BoardGameGeekGameCategory>().FirstOrDefault(c => c.BoardGameGeekGameCategoryId == category.Id);
if (existentCategory == null)
{
existentCategory = new BoardGameGeekGameCategory()
{
BoardGameGeekGameCategoryId = category.Id,
CategoryName = category.Category
};
}
newRecord.Categories.Add(existentCategory);
}
foreach (var mechanic in gameDetails.Mechanics)
{
var existentMechanic = _dataContext.GetQueryable <BoardGameGeekGameMechanic>().FirstOrDefault(c => c.BoardGameGeekGameMechanicId == mechanic.Id);
if (existentMechanic == null)
{
existentMechanic = new BoardGameGeekGameMechanic()
{
BoardGameGeekGameMechanicId = mechanic.Id,
MechanicName = mechanic.Mechanic
};
}
newRecord.Mechanics.Add(existentMechanic);
}
return(newRecord);
}
public Dictionary <int, PointsScorecard> CalculatePoints(IList <PlayerRank> playerRanks, BoardGameGeekGameDefinition bggGameDefinition)
{
ValidatePlayerRanks(playerRanks);
var playerToPoints = AwardBasePoints(playerRanks);
_weightBonusCalculator.CalculateWeightBonus(playerToPoints, bggGameDefinition?.AverageWeight);
_gameDurationBonusCalculator.CalculateGameDurationBonus(playerToPoints, bggGameDefinition?.AveragePlayTime);
return(playerToPoints);
}
public BoardGameGeekGameDefinition CreateBoardGameGeekGameDefinition(int boardGameGeekGameDefinitionId, ApplicationUser currentUser)
{
try
{
var existingRecord = _dataContext.FindById<BoardGameGeekGameDefinition>(boardGameGeekGameDefinitionId);
if (existingRecord != null)
{
return existingRecord;
}
}
catch (EntityDoesNotExistException)
{
//this is OK, just means we need to create a new one
}
var gameDetails = _boardGameGeekApiClient.GetGameDetails(boardGameGeekGameDefinitionId);
if (gameDetails == null)
{
return null;
}
var newRecord = new BoardGameGeekGameDefinition
{
Id = boardGameGeekGameDefinitionId,
Name = gameDetails.Name,
Thumbnail = gameDetails.Thumbnail,
Image = gameDetails.Image,
MaxPlayers = gameDetails.MaxPlayers,
MinPlayers = gameDetails.MinPlayers,
MaxPlayTime = gameDetails.MaxPlayTime,
MinPlayTime = gameDetails.MinPlayTime,
AverageWeight = gameDetails.AverageWeight,
Description = gameDetails.Description,
YearPublished = gameDetails.YearPublished,
IsExpansion = gameDetails.IsExpansion,
Rank = gameDetails.Rank
};
_dataContext.Save(newRecord, currentUser);
// Save categories to BGG definition
foreach (var category in gameDetails.Categories)
{
var existentCategory = _dataContext.GetQueryable<BoardGameGeekGameCategory>().FirstOrDefault(c => c.BoardGameGeekGameCategoryId == category.Id);
if (existentCategory == null)
{
existentCategory = new BoardGameGeekGameCategory()
{
BoardGameGeekGameCategoryId = category.Id,
CategoryName = category.Category
};
}
newRecord.Categories.Add(existentCategory);
}
foreach (var mechanic in gameDetails.Mechanics)
{
var existentMechanic = _dataContext.GetQueryable<BoardGameGeekGameMechanic>().FirstOrDefault(c => c.BoardGameGeekGameMechanicId == mechanic.Id);
if (existentMechanic == null)
{
existentMechanic = new BoardGameGeekGameMechanic()
{
BoardGameGeekGameMechanicId = mechanic.Id,
MechanicName = mechanic.Mechanic
};
}
newRecord.Mechanics.Add(existentMechanic);
}
return newRecord;
}
public void ItAwardsBonusPointsForGameDuration()
{
//--arrange
var bggGameDefinition = new BoardGameGeekGameDefinition
{
MaxPlayTime = 120,
MinPlayTime = 100
};
//--act
_autoMocker.ClassUnderTest.CalculatePoints(new List<PlayerRank>(), bggGameDefinition);
//--assert
_autoMocker.Get<IGameDurationBonusCalculator>().AssertWasCalled(
mock =>
mock.CalculateGameDurationBonus(Arg<Dictionary<int, PointsScorecard>>.Is.Anything,
Arg<int?>.Is.Equal(bggGameDefinition.AveragePlayTime)));
}
public void ItSetsNemePointsForEachPlayerGameResult()
{
var playerOneId = 1;
var playerTwoId = 2;
var playerOneGameRank = 1;
var playerTwoGameRank = 2;
var playerRanks = new List<PlayerRank>
{
new PlayerRank
{
PlayerId = playerOneId,
GameRank = playerOneGameRank
},
new PlayerRank
{
PlayerId = playerTwoId,
GameRank = playerTwoGameRank
}
};
gameDefinition.BoardGameGeekGameDefinitionId = 11;
var newlyCompletedGame = new NewlyCompletedGame
{
GameDefinitionId = gameDefinition.Id,
PlayerRanks = playerRanks
};
var expectedBoardGameGeekGameDefinition = new BoardGameGeekGameDefinition();
autoMocker.Get<IDataContext>()
.Expect(mock => mock.FindById<BoardGameGeekGameDefinition>(gameDefinition.BoardGameGeekGameDefinitionId))
.Return(expectedBoardGameGeekGameDefinition);
var playerOneScorecard = new PointsScorecard
{
BasePoints = 1,
GameDurationBonusPoints = 2,
GameWeightBonusPoints = 3
};
var playerTwoScorecard = new PointsScorecard
{
BasePoints = 4,
GameDurationBonusPoints = 5,
GameWeightBonusPoints = 6
};
var expectedPointsDictionary = new Dictionary<int, PointsScorecard>
{
{playerOneId, playerOneScorecard},
{playerTwoId, playerTwoScorecard}
};
autoMocker.Get<IPointsCalculator>().Expect(mock => mock.CalculatePoints(playerRanks, expectedBoardGameGeekGameDefinition))
.Return(expectedPointsDictionary);
//--Act
var playedGame = autoMocker.ClassUnderTest.CreatePlayedGame(newlyCompletedGame, TransactionSource.WebApplication, currentUser);
var playerOne = playedGame.PlayerGameResults.First(gameResult => gameResult.PlayerId == playerOneId);
Assert.That(playerOne.GameDurationBonusPoints, Is.EqualTo(playerOneScorecard.GameDurationBonusPoints));
Assert.That(playerOne.GameWeightBonusPoints, Is.EqualTo(playerOneScorecard.GameWeightBonusPoints));
Assert.That(playerOne.NemeStatsPointsAwarded, Is.EqualTo(playerOneScorecard.BasePoints));
var playerTwo = playedGame.PlayerGameResults.First(gameResult => gameResult.PlayerId == playerTwoId);
Assert.That(playerTwo.GameDurationBonusPoints, Is.EqualTo(playerTwoScorecard.GameDurationBonusPoints));
Assert.That(playerTwo.GameWeightBonusPoints, Is.EqualTo(playerTwoScorecard.GameWeightBonusPoints));
Assert.That(playerTwo.NemeStatsPointsAwarded, Is.EqualTo(playerTwoScorecard.BasePoints));
}
public void SetUp()
{
AutoMocker = new RhinoAutoMocker <BoardGameGeekGameDefinitionInfoRetriever>();
_expectedBoardGameGeekGameDefinition = new BoardGameGeekGameDefinition
{
AverageWeight = 100,
MinPlayTime = 1,
MaxPlayTime = 3,
Id = _boardGameGeekGameDefinitionId,
MaxPlayers = 200,
MinPlayers = 201,
Name = "some game name",
Description = "some game description",
Thumbnail = "some thumbnail url",
Image = "some image url",
YearPublished = 2099,
Mechanics = new List <BoardGameGeekGameMechanic>
{
new BoardGameGeekGameMechanic
{
MechanicName = _mechanic1
},
new BoardGameGeekGameMechanic
{
MechanicName = _mechanic2
}
},
Categories = new List <BoardGameGeekGameCategory>
{
new BoardGameGeekGameCategory
{
CategoryName = _category1
},
new BoardGameGeekGameCategory
{
CategoryName = _category2
}
},
GameDefinitions = new List <GameDefinition>
{
new GameDefinition
{
GamingGroupId = 1,
PlayedGames = new List <PlayedGame>
{
new PlayedGame
{
NumberOfPlayers = 2
}
}
},
new GameDefinition
{
GamingGroupId = 2,
PlayedGames = new List <PlayedGame>
{
new PlayedGame
{
NumberOfPlayers = 3
}
}
}
}
};
var queryable = new List <BoardGameGeekGameDefinition>
{
_expectedBoardGameGeekGameDefinition
}.ToList().AsQueryable();
AutoMocker.Get <IDataContext>().Expect(mock => mock.GetQueryable <BoardGameGeekGameDefinition>()).Return(queryable);
}
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);
testBoardGameGeekGameDefinition = SaveBoardGameGeekGameDefinition(dataContext);
testGameDefinition = SaveGameDefinition(nemeStatsDbContext, testGamingGroup.Id, testGameName, testBoardGameGeekGameDefinition.Id);
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);
}
using(NemeStatsDataContext dataContext = new NemeStatsDataContext())
{
CreatePlayedGames(dataContext);
}
}
}
