public void ItReturnsThePlayers()
{
const int GAMING_GROUP_ID = 1;
var expectedPlayer = new Player
{
Id = 2,
Name = "player 1",
Active = false,
NemesisId = 300
};
var expectedPlayers = new List <Player>
{
expectedPlayer
};
autoMocker.Get <IPlayerRetriever>().Expect(mock => mock.GetAllPlayers(GAMING_GROUP_ID)).Return(expectedPlayers);
var actualResults = autoMocker.ClassUnderTest.GetPlayers(GAMING_GROUP_ID);
var actualData = AssertThatApiAction.ReturnsThisTypeWithThisStatusCode <PlayersSearchResultsMessage>(actualResults, HttpStatusCode.OK);
Assert.That(actualData.Players.Count, Is.EqualTo(1));
var player = actualData.Players[0];
Assert.That(player.PlayerId, Is.EqualTo(expectedPlayer.Id));
Assert.That(player.PlayerName, Is.EqualTo(expectedPlayer.Name));
Assert.That(player.Active, Is.EqualTo(expectedPlayer.Active));
Assert.That(player.CurrentNemesisPlayerId, Is.EqualTo(expectedPlayer.NemesisId));
}
public void ItReturnsAllTheGameDefinitionsForTheGivenGamingGroup()
{
const int GAMING_GROUP_ID = 1;
var expectedResults = new List <GameDefinitionSummary>
{
new GameDefinitionSummary
{
Id = 2,
Name = "some game definition name",
Active = false,
BoardGameGeekGameDefinitionId = 3
}
};
_autoMocker.Get <IGameDefinitionRetriever>().Expect(mock => mock.GetAllGameDefinitions(GAMING_GROUP_ID)).Return(expectedResults);
var actualResults = _autoMocker.ClassUnderTest.GetGameDefinitions(GAMING_GROUP_ID);
var actualData = AssertThatApiAction.ReturnsThisTypeWithThisStatusCode <GameDefinitionsSearchResultsMessage>(actualResults, HttpStatusCode.OK);
var firstActualGameDefinitionSearchResultMessage = actualData.GameDefinitions[0];
Assert.That(firstActualGameDefinitionSearchResultMessage.GameDefinitionId, Is.EqualTo(expectedResults[0].Id));
Assert.That(firstActualGameDefinitionSearchResultMessage.GameDefinitionName, Is.EqualTo(expectedResults[0].Name));
Assert.That(firstActualGameDefinitionSearchResultMessage.Active, Is.EqualTo(expectedResults[0].Active));
Assert.That(firstActualGameDefinitionSearchResultMessage.BoardGameGeekGameDefinitionId, Is.EqualTo(expectedResults[0].BoardGameGeekGameDefinitionId));
Assert.That(firstActualGameDefinitionSearchResultMessage.NemeStatsUrl,
Is.EqualTo(AbsoluteUrlBuilder.GetGameDefinitionUrl(firstActualGameDefinitionSearchResultMessage.GameDefinitionId)));
}
public void ItReturnsTheCorrectPlayedGames()
{
var expectedSingleResult = new PlayedGameSearchResult
{
BoardGameGeekGameDefinitionId = 1,
DateLastUpdated = DateTime.UtcNow.Date,
DatePlayed = DateTime.UtcNow.Date,
GameDefinitionId = 2,
GameDefinitionName = "some game definition name",
GamingGroupId = 3,
GamingGroupName = "some gaming group name",
Notes = "some notes",
PlayedGameId = 4,
PlayerGameResults = new List <PlayerResult>
{
new PlayerResult
{
GameRank = 1,
PlayerId = 2,
PointsScored = 3,
NemeStatsPointsAwarded = 4,
PlayerName = "some player name"
}
}
};
var expectedResults = new List <PlayedGameSearchResult>
{
expectedSingleResult
};
var filterMessage = new PlayedGameFilterMessage();
autoMocker.Get <IPlayedGameRetriever>().Expect(
mock => mock.SearchPlayedGames(
Arg <PlayedGameFilter> .Is.Anything))
.Return(expectedResults);
var actualResponse = autoMocker.ClassUnderTest.GetPlayedGames(filterMessage, 1);
var actualData = AssertThatApiAction.ReturnsThisTypeWithThisStatusCode <PlayedGameSearchResultsMessage>(actualResponse, HttpStatusCode.OK);
Assert.That(actualData.PlayedGames.Count, Is.EqualTo(1));
var actualSinglePlayedGame = actualData.PlayedGames[0];
Assert.That(actualSinglePlayedGame.BoardGameGeekGameDefinitionId, Is.EqualTo(expectedSingleResult.BoardGameGeekGameDefinitionId));
Assert.That(actualSinglePlayedGame.DateLastUpdated, Is.EqualTo(expectedSingleResult.DateLastUpdated.ToString("yyyy-MM-dd")));
Assert.That(actualSinglePlayedGame.DatePlayed, Is.EqualTo(expectedSingleResult.DatePlayed.ToString("yyyy-MM-dd")));
Assert.That(actualSinglePlayedGame.GameDefinitionId, Is.EqualTo(expectedSingleResult.GameDefinitionId));
Assert.That(actualSinglePlayedGame.GameDefinitionName, Is.EqualTo(expectedSingleResult.GameDefinitionName));
Assert.That(actualSinglePlayedGame.GamingGroupId, Is.EqualTo(expectedSingleResult.GamingGroupId));
Assert.That(actualSinglePlayedGame.GamingGroupName, Is.EqualTo(expectedSingleResult.GamingGroupName));
Assert.That(actualSinglePlayedGame.Notes, Is.EqualTo(expectedSingleResult.Notes));
Assert.That(actualSinglePlayedGame.PlayedGameId, Is.EqualTo(expectedSingleResult.PlayedGameId));
Assert.That(actualSinglePlayedGame.PlayerGameResults[0].GameRank, Is.EqualTo(expectedSingleResult.PlayerGameResults[0].GameRank));
Assert.That(actualSinglePlayedGame.PlayerGameResults[0].NemeStatsPointsAwarded, Is.EqualTo(expectedSingleResult.PlayerGameResults[0].NemeStatsPointsAwarded));
Assert.That(actualSinglePlayedGame.PlayerGameResults[0].PlayerId, Is.EqualTo(expectedSingleResult.PlayerGameResults[0].PlayerId));
Assert.That(actualSinglePlayedGame.PlayerGameResults[0].PlayerName, Is.EqualTo(expectedSingleResult.PlayerGameResults[0].PlayerName));
Assert.That(actualSinglePlayedGame.PlayerGameResults[0].PointsScored, Is.EqualTo(expectedSingleResult.PlayerGameResults[0].PointsScored));
}
public void ItReturnsANewlyCreatedGameDefinitionMessage()
{
var actualResults = autoMocker.ClassUnderTest.SaveNewGameDefinition(new NewGameDefinitionMessage(), 0);
var actualData = AssertThatApiAction.ReturnsThisTypeWithThisStatusCode <NewlyCreatedGameDefinitionMessage>(actualResults, HttpStatusCode.OK);
Assert.That(actualData.GameDefinitionId, Is.EqualTo(expectedGameDefinition.Id));
}
public void ItReturnsAPlayerStatisticsMessageForTheGivenPlayer()
{
var results = _autoMocker.ClassUnderTest.GetPlayerStats(0, PLAYER_ID);
var model = AssertThatApiAction.ReturnsThisTypeWithThisStatusCode <PlayerStatisticsMessage>(results, HttpStatusCode.OK);
Assert.That(model, Is.SameAs(expectedMessage));
}
public void ItReturnsANewlyCreatedGameDefinitionMessage()
{
var expectedUrl = AbsoluteUrlBuilder.GetGameDefinitionUrl(_expectedGameDefinition.Id);
var actualResults = _autoMocker.ClassUnderTest.SaveNewGameDefinition(new NewGameDefinitionMessage(), _expectedGamingGroupId);
var actualData = AssertThatApiAction.ReturnsThisTypeWithThisStatusCode <NewlyCreatedGameDefinitionMessage>(actualResults, HttpStatusCode.OK);
Assert.That(actualData.GameDefinitionId, Is.EqualTo(_expectedGameDefinition.Id));
Assert.That(actualData.GamingGroupId, Is.EqualTo(_expectedGamingGroupId));
Assert.That(actualData.NemeStatsUrl, Is.EqualTo(expectedUrl));
}
public void It_Returns_Gravatar_Urls_For_Registered_Users_The_User_Has_Access_To_See()
{
//--arrange
var expectedGravatarUrl = UIHelper.BuildGravatarUrl(_expectedEmail);
//--act
var actualResults = _autoMocker.ClassUnderTest.GetPlayers(GAMING_GROUP_ID);
//--assert
var actualData = AssertThatApiAction.ReturnsThisTypeWithThisStatusCode <PlayersSearchResultsMessage>(actualResults, HttpStatusCode.OK);
actualData.Players.ShouldContain(x =>
x.PlayerId == _expectedPlayer.Id && x.RegisteredUserGravatarUrl == expectedGravatarUrl);
}
public void ItReturnsAnEmptyListIfThereAreNoResults()
{
var filterMessage = new PlayedGameFilterMessage();
_autoMocker.Get <IPlayedGameRetriever>().Expect(
mock => mock.SearchPlayedGames(
Arg <PlayedGameFilter> .Is.Anything))
.Return(new List <PlayedGameSearchResult>());
var actualResponse = _autoMocker.ClassUnderTest.GetPlayedGames(filterMessage, 1);
var actualData = AssertThatApiAction.ReturnsThisTypeWithThisStatusCode <PlayedGameSearchResultsMessage>(actualResponse, HttpStatusCode.OK);
Assert.That(actualData.PlayedGames.Count, Is.EqualTo(0));
}
public void It_Returns_The_Players()
{
var actualResults = _autoMocker.ClassUnderTest.GetPlayers(GAMING_GROUP_ID);
var actualData = AssertThatApiAction.ReturnsThisTypeWithThisStatusCode <PlayersSearchResultsMessage>(actualResults, HttpStatusCode.OK);
Assert.That(actualData.Players.Count, Is.EqualTo(1));
var player = actualData.Players[0];
Assert.That(player.PlayerId, Is.EqualTo(_expectedPlayer.Id));
Assert.That(player.PlayerName, Is.EqualTo(_expectedPlayer.Name));
Assert.That(player.Active, Is.EqualTo(_expectedPlayer.Active));
Assert.That(player.CurrentNemesisPlayerId, Is.EqualTo(_expectedPlayer.NemesisId));
Assert.That(player.NemeStatsUrl, Is.EqualTo(AbsoluteUrlBuilder.GetPlayerDetailsUrl(player.PlayerId)));
}
public async Task ItReturnsAnHttp401NotAuthorizedResponseIfTheUsernameAndPasswordIsNotValid()
{
var credentialsMessage = new CredentialsMessage
{
UserName = "******",
Password = "******"
};
autoMocker.Get <ApplicationUserManager>().Expect(mock => mock.FindAsync(
Arg <string> .Matches(userName => userName == credentialsMessage.UserName),
Arg <string> .Matches(password => password == credentialsMessage.Password)))
.Return(Task.FromResult((ApplicationUser)null));
var actualResponse = await autoMocker.ClassUnderTest.Login(credentialsMessage);
AssertThatApiAction.HasThisError(actualResponse, HttpStatusCode.Unauthorized, "Invalid credentials provided.");
}
public void ItReturnsANoContentResponse()
{
var actualResults = _autoMocker.ClassUnderTest.DeletePlayedGame(0, 0);
AssertThatApiAction.ReturnsANoContentResponseWithNoContent(actualResults);
}
public void ItReturnsANoContentResponse()
{
var actualResults = _autoMocker.ClassUnderTest.UpdatePlayer(new UpdatePlayerMessage(), 0, 0);
AssertThatApiAction.ReturnsANoContentResponseWithNoContent(actualResults);
}
public void ItReturnsABadRequestIfTheMessageIsNull()
{
HttpResponseMessage actualResponse = _autoMocker.ClassUnderTest.UpdatePlayer(null, 1, 100);
AssertThatApiAction.HasThisError(actualResponse, HttpStatusCode.BadRequest, "You must pass at least one valid parameter.");
}
