//TODO need to have validation logic here (or on PlayedGame similar to what is on NewlyCompletedGame)
public PlayedGame CreatePlayedGame(NewlyCompletedGame newlyCompletedGame, TransactionSource transactionSource, ApplicationUser currentUser)
{
GameDefinition gameDefinition = dataContext.FindById <GameDefinition>(newlyCompletedGame.GameDefinitionId);
securedEntityValidatorForGameDefinition.ValidateAccess(gameDefinition, currentUser, typeof(GameDefinition), newlyCompletedGame.GameDefinitionId);
this.ValidateAccessToPlayers(newlyCompletedGame, currentUser);
List <PlayerGameResult> playerGameResults = TransformNewlyCompletedGamePlayerRanksToPlayerGameResults(newlyCompletedGame);
PlayedGame playedGame = TransformNewlyCompletedGameIntoPlayedGame(
newlyCompletedGame,
currentUser.CurrentGamingGroupId,
currentUser.Id,
playerGameResults);
dataContext.Save(playedGame, currentUser);
playedGameTracker.TrackPlayedGame(currentUser, transactionSource);
foreach (PlayerGameResult result in playerGameResults)
{
nemesisRecalculator.RecalculateNemesis(result.PlayerId, currentUser);
}
championRecalculator.RecalculateChampion(playedGame.GameDefinitionId, currentUser);
return(playedGame);
}
private NewlyCompletedGame CreateValidNewlyCompletedGame()
{
List <PlayerRank> playerRanks;
var playerOneId = 3515;
var playerTwoId = 15151;
var playerOneRank = 1;
var playerTwoRank = 2;
var newlyCompletedGame = new NewlyCompletedGame
{
GameDefinitionId = _expectedGameDefinition.Id
};
playerRanks = new List <PlayerRank>();
playerRanks.Add(new PlayerRank
{
PlayerId = playerOneId, GameRank = playerOneRank
});
playerRanks.Add(new PlayerRank
{
PlayerId = playerTwoId, GameRank = playerTwoRank
});
newlyCompletedGame.PlayerRanks = playerRanks;
_autoMocker.Get <IPointsCalculator>()
.Expect(mock => mock.CalculatePoints(null, null))
.IgnoreArguments()
.Return(new Dictionary <int, PointsScorecard>
{
{ playerOneId, new PointsScorecard() },
{ playerTwoId, new PointsScorecard() }
});
return(newlyCompletedGame);
}
public void ItChecksSecurityOnThePlayerId()
{
var playerRanks = new List <PlayerRank>
{
new PlayerRank
{
PlayerId = existingPlayerWithMatchingGamingGroup.Id
}
};
var newlyCompletedGame = new NewlyCompletedGame
{
GameDefinitionId = gameDefinition.Id,
PlayerRanks = playerRanks
};
autoMocker.Get <IDataContext>().Expect(mock => mock.FindById <Player>(existingPlayerWithMatchingGamingGroup.Id))
.Return(existingPlayerWithMatchingGamingGroup);
autoMocker.Get <IPointsCalculator>()
.Expect(mock => mock.CalculatePoints(null, null))
.IgnoreArguments()
.Return(new Dictionary <int, PointsScorecard>
{
{ existingPlayerWithMatchingGamingGroup.Id, new PointsScorecard() }
});
autoMocker.ClassUnderTest.CreatePlayedGame(newlyCompletedGame, TransactionSource.WebApplication, currentUser);
autoMocker.Get <ISecuredEntityValidator>().AssertWasCalled(mock => mock.ValidateAccess(
existingPlayerWithMatchingGamingGroup,
currentUser));
}
private PlayedGame CreateTestPlayedGame(
int gameDefinitionId,
List <Player> players,
List <int> correspondingPlayerRanks,
ApplicationUser currentUser,
IPlayedGameCreator playedGameCreator)
{
List <PlayerRank> playerRanks = new List <PlayerRank>();
for (int i = 0; i < players.Count(); i++)
{
playerRanks.Add(new PlayerRank()
{
PlayerId = players[i].Id,
GameRank = correspondingPlayerRanks[i]
});
}
NewlyCompletedGame newlyCompletedGame = new NewlyCompletedGame()
{
GameDefinitionId = gameDefinitionId,
PlayerRanks = playerRanks,
};
return(playedGameCreator.CreatePlayedGame(newlyCompletedGame, TransactionSource.WebApplication, currentUser));
}
//TODO need to have validation logic here (or on PlayedGame similar to what is on NewlyCompletedGame)
public PlayedGame CreatePlayedGame(NewlyCompletedGame newlyCompletedGame, TransactionSource transactionSource, ApplicationUser currentUser)
{
if (newlyCompletedGame.GamingGroupId.HasValue && newlyCompletedGame.GamingGroupId != currentUser.CurrentGamingGroupId)
{
_securedEntityValidator.RetrieveAndValidateAccess<GamingGroup>(newlyCompletedGame.GamingGroupId.Value, currentUser);
}
var gameDefinition = _securedEntityValidator.RetrieveAndValidateAccess<GameDefinition>(newlyCompletedGame.GameDefinitionId, currentUser);
_linkedPlayedGameValidator.Validate(newlyCompletedGame);
var gamingGroupId = newlyCompletedGame.GamingGroupId ?? currentUser.CurrentGamingGroupId;
ValidateAccessToPlayers(newlyCompletedGame.PlayerRanks, gamingGroupId, currentUser);
var playerGameResults = MakePlayerGameResults(newlyCompletedGame, gameDefinition.BoardGameGeekGameDefinitionId);
var playedGame = TransformNewlyCompletedGameIntoPlayedGame(
newlyCompletedGame,
gamingGroupId,
currentUser.Id,
playerGameResults);
playedGame = _dataContext.Save(playedGame, currentUser);
CreateApplicationLinkages(newlyCompletedGame.ApplicationLinkages, playedGame.Id);
DoPostSaveStuff(transactionSource, currentUser, playedGame.Id, playedGame.GameDefinitionId, playerGameResults);
return playedGame;
}
public void ItSetsThePlayerRanks()
{
this.playedGameMessage.PlayerRanks = new List <PlayerRank>
{
new PlayerRank()
{
GameRank = 1, PlayerId = 100, PointsScored = 10
},
new PlayerRank()
{
GameRank = 2, PlayerId = 200, PointsScored = 8
}
};
this.autoMocker.ClassUnderTest.RecordPlayedGame(this.playedGameMessage, this.applicationUser.CurrentGamingGroupId);
IList <object[]> arguments = this.autoMocker.Get <IPlayedGameCreator>().GetArgumentsForCallsMadeOn(mock => mock.CreatePlayedGame(
Arg <NewlyCompletedGame> .Is.Anything,
Arg <TransactionSource> .Is.Anything,
Arg <ApplicationUser> .Is.Anything));
NewlyCompletedGame newlyCompletedGame = arguments[0][0] as NewlyCompletedGame;
Assert.That(newlyCompletedGame.PlayerRanks[0].GameRank, Is.EqualTo(this.playedGameMessage.PlayerRanks[0].GameRank));
Assert.That(newlyCompletedGame.PlayerRanks[0].PlayerId, Is.EqualTo(this.playedGameMessage.PlayerRanks[0].PlayerId));
Assert.That(newlyCompletedGame.PlayerRanks[0].PointsScored, Is.EqualTo(this.playedGameMessage.PlayerRanks[0].PointsScored));
Assert.That(newlyCompletedGame.PlayerRanks[1].GameRank, Is.EqualTo(this.playedGameMessage.PlayerRanks[1].GameRank));
Assert.That(newlyCompletedGame.PlayerRanks[1].PlayerId, Is.EqualTo(this.playedGameMessage.PlayerRanks[1].PlayerId));
Assert.That(newlyCompletedGame.PlayerRanks[1].PointsScored, Is.EqualTo(this.playedGameMessage.PlayerRanks[1].PointsScored));
}
public void ItSavesAPlayedGameIfThereIsAGameDefinition()
{
int playerOneId = 3515;
int playerTwoId = 15151;
int playerOneRank = 1;
int playerTwoRank = 2;
NewlyCompletedGame newlyCompletedGame = new NewlyCompletedGame()
{
GameDefinitionId = gameDefinition.Id
};
List <PlayerRank> playerRanks = new List <PlayerRank>();
playerRanks.Add(new PlayerRank()
{
PlayerId = playerOneId, GameRank = playerOneRank
});
playerRanks.Add(new PlayerRank()
{
PlayerId = playerTwoId, GameRank = playerTwoRank
});
newlyCompletedGame.PlayerRanks = playerRanks;
autoMocker.ClassUnderTest.CreatePlayedGame(newlyCompletedGame, TransactionSource.WebApplication, this.currentUser);
autoMocker.Get <IDataContext>().AssertWasCalled(mock => mock.Save(
Arg <PlayedGame> .Matches(game => game.GameDefinitionId == gameDefinition.Id &&
game.NumberOfPlayers == playerRanks.Count() &&
game.DatePlayed.Date.Equals(newlyCompletedGame.DatePlayed.Date)),
Arg <ApplicationUser> .Is.Same(currentUser)));
}
public void ItRecordsAGamePlayedEvent()
{
var playerRank = new PlayerRank
{
GameRank = 1,
PlayerId = 1
};
var newlyCompletedGame = new NewlyCompletedGame
{
GameDefinitionId = gameDefinition.Id,
PlayerRanks = new List <PlayerRank>
{
playerRank
}
};
var transactionSource = TransactionSource.RestApi;
autoMocker.Get <IPointsCalculator>()
.Expect(mock => mock.CalculatePoints(null, null))
.IgnoreArguments()
.Return(new Dictionary <int, PointsScorecard>
{
{ playerRank.PlayerId, new PointsScorecard() }
});
autoMocker.ClassUnderTest.CreatePlayedGame(newlyCompletedGame, transactionSource, currentUser);
autoMocker.Get <INemeStatsEventTracker>().AssertWasCalled(mock => mock.TrackPlayedGame(currentUser, transactionSource));
}
private void ValidateAccessToPlayers(NewlyCompletedGame newlyCompletedGame, ApplicationUser currentUser)
{
foreach (var playerRank in newlyCompletedGame.PlayerRanks)
{
Player player = this.dataContext.FindById <Player>(playerRank.PlayerId);
this.securedEntityValidatorForPlayer.ValidateAccess(player, currentUser, typeof(Player), player.Id);
}
}
private NewlyCompletedGame CreateNewlyCompletedGame()
{
var newlyCompletedGame = new NewlyCompletedGame
{
GamingGroupId = _expectedGamingGroupId
};
return(newlyCompletedGame);
}
public virtual ActionResult Create(NewlyCompletedGame newlyCompletedGame, ApplicationUser currentUser)
{
if (ModelState.IsValid)
{
playedGameCreator.CreatePlayedGame(newlyCompletedGame, TransactionSource.WebApplication, currentUser);
return(new RedirectResult(Url.Action(MVC.GamingGroup.ActionNames.Index, MVC.GamingGroup.Name)
+ "#" + GamingGroupController.SECTION_ANCHOR_RECENT_GAMES));
}
return(Create(currentUser));
}
public virtual ActionResult Edit(NewlyCompletedGame newlyCompletedGame, int previousGameId, ApplicationUser currentUser)
{
if (ModelState.IsValid)
{
this.playedGameDeleter.DeletePlayedGame(previousGameId, currentUser);
this.playedGameCreator.CreatePlayedGame(newlyCompletedGame, TransactionSource.WebApplication, currentUser);
return(new RedirectResult(Url.Action(MVC.GamingGroup.ActionNames.Index, MVC.GamingGroup.Name)
+ "#" + GamingGroupController.SECTION_ANCHOR_RECENT_GAMES));
}
return(RedirectToAction(MVC.PlayedGame.Edit(previousGameId, currentUser)));
}
public void ItRecalculatesTheChampionForTheGame()
{
List <PlayerRank> playerRanks = new List <PlayerRank>();
NewlyCompletedGame newlyCompletedGame = new NewlyCompletedGame()
{
GameDefinitionId = gameDefinition.Id,
PlayerRanks = playerRanks
};
autoMocker.ClassUnderTest.CreatePlayedGame(newlyCompletedGame, TransactionSource.WebApplication, this.currentUser);
autoMocker.Get <IChampionRecalculator>().AssertWasCalled(mock => mock.RecalculateChampion((int)newlyCompletedGame.GameDefinitionId, currentUser));
}
public void ItRecalculatesTheChampionForTheGameButDoesntClearTheExistingChampion()
{
var playerRanks = new List <PlayerRank>();
var newlyCompletedGame = new NewlyCompletedGame
{
GameDefinitionId = gameDefinition.Id,
PlayerRanks = playerRanks
};
autoMocker.ClassUnderTest.CreatePlayedGame(newlyCompletedGame, TransactionSource.WebApplication, currentUser);
autoMocker.Get <IChampionRecalculator>().AssertWasCalled(mock => mock.RecalculateChampion(newlyCompletedGame.GameDefinitionId, currentUser, false));
}
public void ItChecksSecurityOnTheGameDefinitionId()
{
var playerRanks = new List <PlayerRank>();
var newlyCompletedGame = new NewlyCompletedGame
{
GameDefinitionId = _expectedGameDefinition.Id,
PlayerRanks = playerRanks
};
_autoMocker.ClassUnderTest.Execute(newlyCompletedGame, _currentUser, _dataContext);
_autoMocker.Get <ISecuredEntityValidator>().AssertWasCalled(mock => mock.RetrieveAndValidateAccess <GameDefinition>(
_expectedGameDefinition.Id,
_currentUser));
}
public void ItChecksSecurityOnTheGameDefinitionId()
{
var playerRanks = new List <PlayerRank>();
var newlyCompletedGame = new NewlyCompletedGame
{
GameDefinitionId = gameDefinition.Id,
PlayerRanks = playerRanks
};
autoMocker.ClassUnderTest.CreatePlayedGame(newlyCompletedGame, TransactionSource.WebApplication, currentUser);
autoMocker.Get <ISecuredEntityValidator>().AssertWasCalled(mock => mock.RetrieveAndValidateAccess <GameDefinition>(
gameDefinition.Id,
currentUser));
}
public void ItMakesTheRequestForTheCurrentUser()
{
NewlyCompletedGame newlyCompletedGame = new NewlyCompletedGame()
{
GameDefinitionId = 1,
PlayerRanks = new List <PlayerRank>()
};
autoMocker.ClassUnderTest.Create(newlyCompletedGame, currentUser);
autoMocker.Get <IPlayedGameCreator>().AssertWasCalled(logic => logic.CreatePlayedGame(
Arg <NewlyCompletedGame> .Is.Anything,
Arg <TransactionSource> .Is.Anything,
Arg <ApplicationUser> .Is.Equal(this.currentUser)));
}
public void ItChecksSecurityOnTheGameDefinitionId()
{
List <PlayerRank> playerRanks = new List <PlayerRank>();
NewlyCompletedGame newlyCompletedGame = new NewlyCompletedGame()
{
GameDefinitionId = gameDefinition.Id,
PlayerRanks = playerRanks
};
autoMocker.ClassUnderTest.CreatePlayedGame(newlyCompletedGame, TransactionSource.WebApplication, this.currentUser);
autoMocker.Get <ISecuredEntityValidator <GameDefinition> >().AssertWasCalled(mock => mock.ValidateAccess(
gameDefinition,
currentUser, typeof(GameDefinition),
gameDefinition.Id));
}
public void ItRecalculatesTheNemesisOfEveryPlayerInTheGame()
{
var playerOneId = 1;
var playerTwoId = 2;
var playerThreeId = 3;
var playerRanks = new List <PlayerRank>
{
new PlayerRank
{
PlayerId = playerOneId,
GameRank = 1
},
new PlayerRank
{
PlayerId = playerTwoId,
GameRank = 2
},
new PlayerRank
{
PlayerId = playerThreeId,
GameRank = 3
}
};
var newlyCompletedGame = new NewlyCompletedGame
{
GameDefinitionId = gameDefinition.Id,
PlayerRanks = playerRanks
};
autoMocker.Get <IPointsCalculator>()
.Expect(mock => mock.CalculatePoints(null, null))
.IgnoreArguments()
.Return(new Dictionary <int, PointsScorecard>
{
{ playerOneId, new PointsScorecard() },
{ playerTwoId, new PointsScorecard() },
{ playerThreeId, new PointsScorecard() }
});
autoMocker.ClassUnderTest.CreatePlayedGame(newlyCompletedGame, TransactionSource.WebApplication, currentUser);
foreach (var playerRank in playerRanks)
{
autoMocker.Get <INemesisRecalculator>().AssertWasCalled(mock => mock.RecalculateNemesis(playerRank.PlayerId, currentUser));
}
}
public void ThatItSavesTheGame()
{
//--Arrange
var editedGame = new NewlyCompletedGame();
var viewModel = new PlayedGameEditViewModel();
Mapper.Map(viewModel, editedGame);
//--Act
autoMocker.ClassUnderTest.Edit(viewModel, 1234, currentUser);
//--Assert
autoMocker.Get <IPlayedGameCreator>().AssertWasCalled(mock => mock.CreatePlayedGame(
Arg <NewlyCompletedGame> .Is.Anything,
Arg <TransactionSource> .Is.Anything,
Arg <ApplicationUser> .Is.Anything));
}
public void ItSetsTheGamingGroupIdToThatOfTheUser()
{
var newlyCompletedPlayedGame = new NewlyCompletedGame
{
GameDefinitionId = _expectedGameDefinition.Id,
PlayerRanks = new List <PlayerRank>()
};
_autoMocker.Get <IPlayedGameSaver>().Expect(logic => logic.MakePlayerGameResults(null, null, null))
.IgnoreArguments()
.Return(new List <PlayerGameResult>());
_autoMocker.ClassUnderTest.Execute(newlyCompletedPlayedGame, _currentUser, _dataContext);
_dataContext.AssertWasCalled(mock => mock.Save(
Arg <PlayedGame> .Matches(game => game.GamingGroupId == _currentUser.CurrentGamingGroupId.Value),
Arg <ApplicationUser> .Is.Same(_currentUser)));
}
public void ItSetsTheGamingGroupIdToThatOfTheUser()
{
var newlyCompletedGame = new NewlyCompletedGame
{
GameDefinitionId = gameDefinition.Id,
PlayerRanks = new List <PlayerRank>()
};
autoMocker.ClassUnderTest.Expect(logic => logic.MakePlayerGameResults(null, null))
.IgnoreArguments()
.Return(new List <PlayerGameResult>());
autoMocker.ClassUnderTest.CreatePlayedGame(newlyCompletedGame, TransactionSource.WebApplication, currentUser);
autoMocker.Get <IDataContext>().AssertWasCalled(mock => mock.Save(
Arg <PlayedGame> .Matches(game => game.GamingGroupId == currentUser.CurrentGamingGroupId),
Arg <ApplicationUser> .Is.Same(currentUser)));
}
public void ItValidatesAccessToPlayers()
{
var playerRanks = new List <PlayerRank>();
var newlyCompletedGame = new NewlyCompletedGame
{
GameDefinitionId = _expectedGameDefinition.Id,
PlayerRanks = playerRanks,
GamingGroupId = 42
};
_autoMocker.ClassUnderTest.Execute(newlyCompletedGame, _currentUser, _dataContext);
_autoMocker.Get <IPlayedGameSaver>().AssertWasCalled(mock => mock.ValidateAccessToPlayers(
newlyCompletedGame.PlayerRanks,
newlyCompletedGame.GamingGroupId.Value,
_currentUser,
_dataContext));
}
public void ItSavesTheNewGame()
{
NewlyCompletedGame newlyCompletedGame = new NewlyCompletedGame()
{
GameDefinitionId = 1,
PlayerRanks = new List <PlayerRank>()
};
string baseUrl = "base url";
autoMocker.ClassUnderTest.Url.Expect(mock => mock.Action(MVC.GamingGroup.ActionNames.Index, MVC.GamingGroup.Name))
.Return(baseUrl);
autoMocker.ClassUnderTest.Create(newlyCompletedGame, null);
autoMocker.Get <IPlayedGameCreator>().AssertWasCalled(mock => mock.CreatePlayedGame(
Arg <NewlyCompletedGame> .Is.Equal(newlyCompletedGame),
Arg <TransactionSource> .Is.Anything,
Arg <ApplicationUser> .Is.Anything));
}
public void ItSetsnemeStatsPointsForEachPlayerGameResult()
{
int playerOneId = 1;
int playerTwoId = 2;
int playerOneGameRank = 1;
int playerTwoGameRank = 2;
List <PlayerRank> playerRanks = new List <PlayerRank>()
{
new PlayerRank()
{
PlayerId = playerOneId,
GameRank = playerOneGameRank
},
new PlayerRank()
{
PlayerId = playerTwoId,
GameRank = playerTwoGameRank
}
};
NewlyCompletedGame newlyCompletedGame = new NewlyCompletedGame()
{
GameDefinitionId = gameDefinition.Id,
PlayerRanks = playerRanks
};
var pointsDictionary = PointsCalculator.CalculatePoints(playerRanks);
int playerOneExpectednemeStatsPoints = pointsDictionary[playerOneId];
ApplicationUser user = new ApplicationUser();
PlayedGame playedGame = autoMocker.ClassUnderTest.CreatePlayedGame(newlyCompletedGame, TransactionSource.WebApplication, this.currentUser);
Assert.AreEqual(playerOneExpectednemeStatsPoints, playedGame.PlayerGameResults
.First(gameResult => gameResult.PlayerId == playerOneId)
.NemeStatsPointsAwarded);
int playerTwoExpectednemeStatsPoints = pointsDictionary[playerTwoId];
Assert.AreEqual(playerTwoExpectednemeStatsPoints, playedGame.PlayerGameResults
.First(gameResult => gameResult.PlayerId == playerTwoId)
.NemeStatsPointsAwarded);
}
private PlayedGame CreateTestPlayedGame(
int gameDefinitionId,
List <Player> players,
List <int> correspondingPlayerRanks,
ApplicationUser currentUser,
CreatePlayedGameComponent createdPlayedGameComponent,
IDataContext _dataContext,
bool waitForAllPostSaveEventHandlingToFinish = false,
DateTime?datePlayed = null)
{
List <PlayerRank> playerRanks = new List <PlayerRank>();
for (int i = 0; i < players.Count(); i++)
{
playerRanks.Add(new PlayerRank
{
PlayerId = players[i].Id,
GameRank = correspondingPlayerRanks[i]
});
}
NewlyCompletedGame newlyCompletedGame = new NewlyCompletedGame
{
GameDefinitionId = gameDefinitionId,
PlayerRanks = playerRanks,
TransactionSource = TransactionSource.WebApplication
};
if (datePlayed.HasValue)
{
newlyCompletedGame.DatePlayed = datePlayed.Value;
}
var playedGame = createdPlayedGameComponent.ExecuteTransaction(newlyCompletedGame, currentUser, _dataContext);
if (waitForAllPostSaveEventHandlingToFinish)
{
createdPlayedGameComponent.PostSaveTask.Wait();
}
return(playedGame);
}
public void Validate(NewlyCompletedGame newlyCompletedGame)
{
foreach (var applicationLinkage in newlyCompletedGame.ApplicationLinkages)
{
if (string.IsNullOrEmpty(applicationLinkage.ApplicationName) || string.IsNullOrEmpty(applicationLinkage.EntityId))
{
throw new InvalidSourceException(applicationLinkage.ApplicationName, applicationLinkage.EntityId);
}
var entityWithThisSynchKeyAlreadyExists = _dataContext.GetQueryable<PlayedGameApplicationLinkage>()
.Any(x => x.ApplicationName == applicationLinkage.ApplicationName
&& x.EntityId == applicationLinkage.EntityId
&& x.PlayedGame.GamingGroupId == newlyCompletedGame.GamingGroupId);
if (entityWithThisSynchKeyAlreadyExists)
{
throw new EntityAlreadySynchedException(applicationLinkage.ApplicationName, applicationLinkage.EntityId, newlyCompletedGame.GamingGroupId.Value);
}
}
}
public void Validate(NewlyCompletedGame newlyCompletedGame)
{
foreach (var applicationLinkage in newlyCompletedGame.ApplicationLinkages)
{
if (string.IsNullOrEmpty(applicationLinkage.ApplicationName) || string.IsNullOrEmpty(applicationLinkage.EntityId))
{
throw new InvalidSourceException(applicationLinkage.ApplicationName, applicationLinkage.EntityId);
}
var entityWithThisSynchKeyAlreadyExists = _dataContext.GetQueryable <PlayedGameApplicationLinkage>()
.Any(x => x.ApplicationName == applicationLinkage.ApplicationName &&
x.EntityId == applicationLinkage.EntityId &&
x.PlayedGame.GamingGroupId == newlyCompletedGame.GamingGroupId);
if (entityWithThisSynchKeyAlreadyExists)
{
throw new EntityAlreadySynchedException(applicationLinkage.ApplicationName, applicationLinkage.EntityId, newlyCompletedGame.GamingGroupId.Value);
}
}
}
//TODO this should be in its own class
internal virtual PlayedGame TransformNewlyCompletedGameIntoPlayedGame(
NewlyCompletedGame newlyCompletedGame,
int gamingGroupId,
string applicationUserId,
List <PlayerGameResult> playerGameResults)
{
int numberOfPlayers = newlyCompletedGame.PlayerRanks.Count();
PlayedGame playedGame = new PlayedGame()
{
GameDefinitionId = newlyCompletedGame.GameDefinitionId.Value,
NumberOfPlayers = numberOfPlayers,
PlayerGameResults = playerGameResults,
DatePlayed = newlyCompletedGame.DatePlayed,
GamingGroupId = gamingGroupId,
Notes = newlyCompletedGame.Notes,
CreatedByApplicationUserId = applicationUserId
};
return(playedGame);
}
public void ItRecordsAGamePlayedEvent()
{
PlayerRank playerRank = new PlayerRank()
{
GameRank = 1,
PlayerId = 1
};
NewlyCompletedGame newlyCompletedGame = new NewlyCompletedGame()
{
GameDefinitionId = gameDefinition.Id,
PlayerRanks = new List <PlayerRank>()
{
playerRank
}
};
TransactionSource transactionSource = TransactionSource.RestApi;
autoMocker.ClassUnderTest.CreatePlayedGame(newlyCompletedGame, transactionSource, this.currentUser);
autoMocker.Get <INemeStatsEventTracker>().AssertWasCalled(mock => mock.TrackPlayedGame(currentUser, transactionSource));
}
public void LocalSetUp()
{
_playedGameMessage = new PlayedGameMessage();
_expectedNewlyCompletedGame = new NewlyCompletedGame();
_autoMocker.Get <ITransformer>()
.Expect(mock => mock.Transform <NewlyCompletedGame>(_playedGameMessage))
.IgnoreArguments()
.Return(_expectedNewlyCompletedGame);
var expectedPlayedGame = new PlayedGame
{
Id = EXPECTED_PLAYED_GAME_ID,
GamingGroupId = EXPECTED_GAMING_GROUP_ID
};
_autoMocker.Get <ICreatePlayedGameComponent>().Expect(mock => mock.Execute(
Arg <NewlyCompletedGame> .Is.Anything,
Arg <ApplicationUser> .Is.Anything))
.Return(expectedPlayedGame);
}
private PlayedGame CreateTestPlayedGame(
int gameDefinitionId,
List<Player> players,
List<int> correspondingPlayerRanks,
ApplicationUser currentUser,
IPlayedGameSaver playedGameSaver)
{
List<PlayerRank> playerRanks = new List<PlayerRank>();
for (int i = 0; i < players.Count(); i++)
{
playerRanks.Add(new PlayerRank
{
PlayerId = players[i].Id,
GameRank = correspondingPlayerRanks[i]
});
}
NewlyCompletedGame newlyCompletedGame = new NewlyCompletedGame
{
GameDefinitionId = gameDefinitionId,
PlayerRanks = playerRanks,
};
return playedGameSaver.CreatePlayedGame(newlyCompletedGame, TransactionSource.WebApplication, currentUser);
}
private NewlyCompletedGame CreateValidNewlyCompletedGame()
{
List<PlayerRank> playerRanks;
var playerOneId = 3515;
var playerTwoId = 15151;
var playerOneRank = 1;
var playerTwoRank = 2;
var newlyCompletedGame = new NewlyCompletedGame
{ GameDefinitionId = gameDefinition.Id };
playerRanks = new List<PlayerRank>();
playerRanks.Add(new PlayerRank
{ PlayerId = playerOneId, GameRank = playerOneRank });
playerRanks.Add(new PlayerRank
{ PlayerId = playerTwoId, GameRank = playerTwoRank });
newlyCompletedGame.PlayerRanks = playerRanks;
autoMocker.Get<IPointsCalculator>()
.Expect(mock => mock.CalculatePoints(null, null))
.IgnoreArguments()
.Return(new Dictionary<int, PointsScorecard>
{
{playerOneId, new PointsScorecard()},
{playerTwoId, new PointsScorecard()}
});
return newlyCompletedGame;
}
private NewlyCompletedGame CreateNewlyCompletedGame()
{
var newlyCompletedGame = new NewlyCompletedGame
{
GamingGroupId = _expectedGamingGroupId
};
return newlyCompletedGame;
}
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 ItSetsTheGamingGroupIdToThatOfTheUser()
{
var newlyCompletedGame = new NewlyCompletedGame
{
GameDefinitionId = gameDefinition.Id,
PlayerRanks = new List<PlayerRank>()
};
autoMocker.ClassUnderTest.Expect(logic => logic.MakePlayerGameResults(null, null))
.IgnoreArguments()
.Return(new List<PlayerGameResult>());
autoMocker.ClassUnderTest.CreatePlayedGame(newlyCompletedGame, TransactionSource.WebApplication, currentUser);
autoMocker.Get<IDataContext>().AssertWasCalled(mock => mock.Save(
Arg<PlayedGame>.Matches(game => game.GamingGroupId == currentUser.CurrentGamingGroupId),
Arg<ApplicationUser>.Is.Same(currentUser)));
}
public void ItRecordsAGamePlayedEvent()
{
var playerRank = new PlayerRank
{
GameRank = 1,
PlayerId = 1
};
var newlyCompletedGame = new NewlyCompletedGame
{
GameDefinitionId = gameDefinition.Id,
PlayerRanks = new List<PlayerRank>
{ playerRank }
};
var transactionSource = TransactionSource.RestApi;
autoMocker.Get<IPointsCalculator>()
.Expect(mock => mock.CalculatePoints(null, null))
.IgnoreArguments()
.Return(new Dictionary<int, PointsScorecard>
{
{playerRank.PlayerId, new PointsScorecard()}
});
autoMocker.ClassUnderTest.CreatePlayedGame(newlyCompletedGame, transactionSource, currentUser);
autoMocker.Get<INemeStatsEventTracker>().AssertWasCalled(mock => mock.TrackPlayedGame(currentUser, transactionSource));
}
public void ItRecalculatesTheNemesisOfEveryPlayerInTheGame()
{
var playerOneId = 1;
var playerTwoId = 2;
var playerThreeId = 3;
var playerRanks = new List<PlayerRank>
{
new PlayerRank
{
PlayerId = playerOneId,
GameRank = 1
},
new PlayerRank
{
PlayerId = playerTwoId,
GameRank = 2
},
new PlayerRank
{
PlayerId = playerThreeId,
GameRank = 3
}
};
var newlyCompletedGame = new NewlyCompletedGame
{
GameDefinitionId = gameDefinition.Id,
PlayerRanks = playerRanks
};
autoMocker.Get<IPointsCalculator>()
.Expect(mock => mock.CalculatePoints(null, null))
.IgnoreArguments()
.Return(new Dictionary<int, PointsScorecard>
{
{playerOneId, new PointsScorecard()},
{playerTwoId, new PointsScorecard()},
{playerThreeId, new PointsScorecard()}
});
autoMocker.ClassUnderTest.CreatePlayedGame(newlyCompletedGame, TransactionSource.WebApplication, currentUser);
foreach (var playerRank in playerRanks)
{
autoMocker.Get<INemesisRecalculator>().AssertWasCalled(mock => mock.RecalculateNemesis(playerRank.PlayerId, currentUser));
}
}
public void ItRecalculatesTheChampionForTheGameButDoesntClearTheExistingChampion()
{
var playerRanks = new List<PlayerRank>();
var newlyCompletedGame = new NewlyCompletedGame
{
GameDefinitionId = gameDefinition.Id,
PlayerRanks = playerRanks
};
autoMocker.ClassUnderTest.CreatePlayedGame(newlyCompletedGame, TransactionSource.WebApplication, currentUser);
autoMocker.Get<IChampionRecalculator>().AssertWasCalled(mock => mock.RecalculateChampion(newlyCompletedGame.GameDefinitionId, currentUser, false));
}
public void ItChecksSecurityOnThePlayerId()
{
var playerRanks = new List<PlayerRank>
{
new PlayerRank
{
PlayerId = existingPlayerWithMatchingGamingGroup.Id
}
};
var newlyCompletedGame = new NewlyCompletedGame
{
GameDefinitionId = gameDefinition.Id,
PlayerRanks = playerRanks
};
autoMocker.Get<IDataContext>().Expect(mock => mock.FindById<Player>(existingPlayerWithMatchingGamingGroup.Id))
.Return(existingPlayerWithMatchingGamingGroup);
autoMocker.Get<IPointsCalculator>()
.Expect(mock => mock.CalculatePoints(null, null))
.IgnoreArguments()
.Return(new Dictionary<int, PointsScorecard>
{
{existingPlayerWithMatchingGamingGroup.Id, new PointsScorecard()}
});
autoMocker.ClassUnderTest.CreatePlayedGame(newlyCompletedGame, TransactionSource.WebApplication, currentUser);
autoMocker.Get<ISecuredEntityValidator>().AssertWasCalled(mock => mock.ValidateAccess(
existingPlayerWithMatchingGamingGroup,
currentUser));
}
public void ItChecksSecurityOnTheGameDefinitionId()
{
var playerRanks = new List<PlayerRank>();
var newlyCompletedGame = new NewlyCompletedGame
{
GameDefinitionId = gameDefinition.Id,
PlayerRanks = playerRanks
};
autoMocker.ClassUnderTest.CreatePlayedGame(newlyCompletedGame, TransactionSource.WebApplication, currentUser);
autoMocker.Get<ISecuredEntityValidator>().AssertWasCalled(mock => mock.RetrieveAndValidateAccess<GameDefinition>(
gameDefinition.Id,
currentUser));
}
