public void ItReturnsTheNewNemesisIfItWasChanged()
{
//change the nemesis
NemesisData nemesisData = new NemesisData()
{
NemesisPlayerId = 19383
};
_playerRepositoryMock.Expect(mock => mock.GetNemesisData(_playerId))
.Return(nemesisData);
List <Nemesis> nemesisList = new List <Nemesis>();
Nemesis existingNemesis = new Nemesis()
{
Id = _existingNemesisId,
MinionPlayerId = _playerId
};
nemesisList.Add(existingNemesis);
_dataContextMock.Expect(mock => mock.GetQueryable <Nemesis>())
.Return(nemesisList.AsQueryable());
Nemesis actualNemesis = _nemesisRecalculator.RecalculateNemesis(_playerId, _currentUser);
Assert.AreSame(_savedNemesis, actualNemesis);
}
public void ItDoesntBotherSavingTheNemesisIfNothingHasChanged()
{
int nemesisPlayerId = 1;
int gamesLost = 1;
int lossPercentage = 1;
NemesisData nemesisData = new NemesisData()
{
NemesisPlayerId = nemesisPlayerId,
NumberOfGamesLost = gamesLost,
LossPercentage = lossPercentage
};
_playerRepositoryMock.Expect(mock => mock.GetNemesisData(_playerId))
.Return(nemesisData);
List <Nemesis> nemesisList = new List <Nemesis>();
nemesisList.Add(new Nemesis()
{
Id = _existingNemesisId,
NemesisPlayerId = nemesisPlayerId,
MinionPlayerId = _playerId,
NumberOfGamesLost = gamesLost,
LossPercentage = lossPercentage
});
_dataContextMock.Expect(mock => mock.GetQueryable <Nemesis>())
.Return(nemesisList.AsQueryable());
_nemesisRecalculator.RecalculateNemesis(_playerId, _currentUser);
_dataContextMock.AssertWasNotCalled(mock => mock.Save <Nemesis>(
Arg <Nemesis> .Is.Anything,
Arg <ApplicationUser> .Is.Anything));
}
public void ItReturnsTheUpdatedNemesisIfItWasUpdated()
{
int expectedLossPercentage = 15;
NemesisData nemesisData = new NemesisData()
{
LossPercentage = expectedLossPercentage
};
_playerRepositoryMock.Expect(mock => mock.GetNemesisData(_playerId))
.Return(nemesisData);
List <Nemesis> nemesisList = new List <Nemesis>();
Nemesis existingNemesis = new Nemesis()
{
Id = _existingNemesisId,
MinionPlayerId = _playerId
};
nemesisList.Add(existingNemesis);
_dataContextMock.Expect(mock => mock.GetQueryable <Nemesis>())
.Return(nemesisList.AsQueryable());
Nemesis actualNemesis = _nemesisRecalculator.RecalculateNemesis(_playerId, _currentUser);
Assert.AreSame(_savedNemesis, actualNemesis);
}
public void ItSetsThePreviousNemesisIfTheCurrentOneChanges()
{
NemesisData nemesisData = new NemesisData()
{
NemesisPlayerId = -1
};
_playerRepositoryMock.Expect(mock => mock.GetNemesisData(_playerId))
.Return(nemesisData);
_dataContextMock.Expect(mock => mock.GetQueryable <Nemesis>())
.Return(new List <Nemesis>().AsQueryable());
_nemesisRecalculator.RecalculateNemesis(_playerId, _currentUser);
_dataContextMock.AssertWasCalled(mock => mock.Save <Player>(
Arg <Player> .Matches(player => player.PreviousNemesisId == _existingNemesisId), Arg <ApplicationUser> .Is.Same(_currentUser)));
}
public virtual Nemesis RecalculateNemesis(int playerId, ApplicationUser currentUser)
{
Player minionPlayer = dataContext.FindById <Player>(playerId);
NemesisData nemesisData = playerRepository.GetNemesisData(playerId);
if (nemesisData is NullNemesisData)
{
ClearNemesisId(currentUser, minionPlayer);
return(new NullNemesis());
}
Nemesis existingNemesis = dataContext.GetQueryable <Nemesis>()
.Where(nemesis => nemesis.Id == minionPlayer.NemesisId)
.FirstOrDefault();
Nemesis newNemesis = new Nemesis()
{
LossPercentage = nemesisData.LossPercentage,
NumberOfGamesLost = nemesisData.NumberOfGamesLost,
NemesisPlayerId = nemesisData.NemesisPlayerId,
MinionPlayerId = playerId
};
Nemesis savedNemesis;
if (newNemesis.SameNemesis(existingNemesis))
{
savedNemesis = UpdateExistingNemesisIfNeeded(currentUser, existingNemesis, newNemesis);
}
else
{
savedNemesis = dataContext.Save <Nemesis>(newNemesis, currentUser);
dataContext.CommitAllChanges();
minionPlayer.PreviousNemesisId = minionPlayer.NemesisId;
minionPlayer.NemesisId = savedNemesis.Id;
dataContext.Save <Player>(minionPlayer, currentUser);
}
return(savedNemesis);
}
public void ItUpdatesTheExistingNemesisIfOnlyTheDataHasChanged()
{
int nemesisPlayerId = 1;
int gamesLost = 1;
int lossPercentage = 1;
NemesisData nemesisData = new NemesisData()
{
NemesisPlayerId = nemesisPlayerId,
NumberOfGamesLost = gamesLost,
LossPercentage = lossPercentage
};
_playerRepositoryMock.Expect(mock => mock.GetNemesisData(_playerId))
.Return(nemesisData);
List <Nemesis> nemesisList = new List <Nemesis>();
Nemesis existingNemesis = new Nemesis()
{
Id = _existingNemesisId,
NemesisPlayerId = nemesisPlayerId,
MinionPlayerId = _playerId,
//add 1 so the data is different
NumberOfGamesLost = gamesLost + 1,
LossPercentage = lossPercentage
};
nemesisList.Add(existingNemesis);
_dataContextMock.Expect(mock => mock.GetQueryable <Nemesis>())
.Return(nemesisList.AsQueryable());
_nemesisRecalculator.RecalculateNemesis(_playerId, _currentUser);
_dataContextMock.AssertWasCalled(mock => mock.Save <Nemesis>(
Arg <Nemesis> .Matches(nem => nem.Id == _existingNemesisId &&
nem.MinionPlayerId == _playerId &&
nem.NemesisPlayerId == nemesisPlayerId &&
nem.NumberOfGamesLost == nemesisData.NumberOfGamesLost &&
nem.LossPercentage == nemesisData.LossPercentage),
Arg <ApplicationUser> .Is.Anything));
}
public void ItReturnsTheExistingNemesisIfNothingChanged()
{
NemesisData nemesisData = new NemesisData();
playerRepositoryMock.Expect(mock => mock.GetNemesisData(playerId))
.Return(nemesisData);
List <Nemesis> nemesisList = new List <Nemesis>();
Nemesis existingNemesis = new Nemesis()
{
Id = existingNemesisId,
MinionPlayerId = playerId
};
nemesisList.Add(existingNemesis);
dataContextMock.Expect(mock => mock.GetQueryable <Nemesis>())
.Return(nemesisList.AsQueryable());
Nemesis actualNemesis = nemesisRecalculator.RecalculateNemesis(playerId, currentUser);
Assert.AreSame(existingNemesis, actualNemesis);
}
public void ItSetsTheNewNemesisIfItChanged()
{
NemesisData nemesisData = new NemesisData()
{
NemesisPlayerId = -1
};
_playerRepositoryMock.Expect(mock => mock.GetNemesisData(_playerId))
.Return(nemesisData);
_dataContextMock.Expect(mock => mock.GetQueryable <Nemesis>())
.Return(new List <Nemesis>().AsQueryable());
_nemesisRecalculator.RecalculateNemesis(_playerId, _currentUser);
_dataContextMock.AssertWasCalled(mock => mock.Save <Nemesis>(
Arg <Nemesis> .Matches(savedNemesis => savedNemesis.MinionPlayerId == _playerId &&
savedNemesis.NemesisPlayerId == nemesisData.NemesisPlayerId &&
savedNemesis.NumberOfGamesLost == nemesisData.NumberOfGamesLost &&
savedNemesis.LossPercentage == nemesisData.LossPercentage),
Arg <ApplicationUser> .Is.Same(_currentUser)));
_dataContextMock.AssertWasCalled(mock => mock.Save <Player>(
Arg <Player> .Matches(player => player.NemesisId == _newNemesisId), Arg <ApplicationUser> .Is.Same(_currentUser)));
}
public NemesisData GetNemesisData(int playerId)
{
DbRawSqlQuery <WinLossStatistics> data = dataContext.MakeRawSqlQuery <WinLossStatistics>(SQL_GET_WIN_LOSS_GAMES_COUNT,
new SqlParameter("PlayerId", playerId));
List <WinLossStatistics> winLossStatistics = data.ToList();
NemesisData nemesisData = (from x in winLossStatistics
where x.NumberOfGamesLost > x.NumberOfGamesWon &&
x.NumberOfGamesLost >= MINIMUM_NUMBER_OF_GAMES_TO_BE_A_NEMESIS
select new NemesisData
{
NumberOfGamesLost = x.NumberOfGamesLost,
LossPercentage = 100 * x.NumberOfGamesLost / (x.NumberOfGamesWon + x.NumberOfGamesLost),
NemesisPlayerId = x.VersusPlayerId
}).OrderByDescending(nemesisCandidates => nemesisCandidates.LossPercentage).FirstOrDefault();
if (nemesisData == null)
{
return(new NullNemesisData());
}
return(nemesisData);
}
