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 virtual HttpResponseMessage GetPlayers([FromUri] int gamingGroupId)
{
var results = _playerRetriever.GetAllPlayers(gamingGroupId);
var playerIds = results.Select(x => x.Id).ToList();
//--include the current player so we can attempt to get their email address as well
var playerIdToRegisteredUserEmailAddressDictionary =
_playerRetriever.GetRegisteredUserEmailAddresses(playerIds, CurrentUser);
var playerSearchResultsMessage = new PlayersSearchResultsMessage();
foreach (var player in results)
{
var playerSearchResultMessage = new PlayerSearchResultMessage
{
Active = player.Active,
PlayerId = player.Id,
CurrentNemesisPlayerId = player.NemesisId,
PlayerName = player.Name,
NemeStatsUrl = AbsoluteUrlBuilder.GetPlayerDetailsUrl(player.Id)
};
if (playerIdToRegisteredUserEmailAddressDictionary.ContainsKey(player.Id))
{
playerSearchResultMessage.RegisteredUserGravatarUrl = UIHelper.BuildGravatarUrl(playerIdToRegisteredUserEmailAddressDictionary[player.Id]);
}
playerSearchResultsMessage.Players.Add(playerSearchResultMessage);
}
return(Request.CreateResponse(HttpStatusCode.OK, playerSearchResultsMessage));
}
public virtual HttpResponseMessage SaveNewPlayer([FromBody] NewPlayerMessage newPlayerMessage, [FromUri] int gamingGroupId)
{
var requestedPlayer = new CreatePlayerRequest
{
Name = newPlayerMessage.PlayerName,
GamingGroupId = newPlayerMessage.GamingGroupId,
PlayerEmailAddress = newPlayerMessage.PlayerEmailAddress
};
Player newPlayer;
try
{
newPlayer = _playerSaver.CreatePlayer(requestedPlayer, CurrentUser);
}
catch (PlayerAlreadyExistsException exception)
{
exception.ErrorSubCode = 1;
throw;
}
catch (PlayerWithThisEmailAlreadyExistsException exception)
{
exception.ErrorSubCode = 2;
throw;
}
var newlyCreatedPlayerMessage = new NewlyCreatedPlayerMessage
{
PlayerId = newPlayer.Id,
GamingGroupId = newPlayer.GamingGroupId,
NemeStatsUrl = AbsoluteUrlBuilder.GetPlayerDetailsUrl(newPlayer.Id)
};
return(Request.CreateResponse(HttpStatusCode.OK, newlyCreatedPlayerMessage));
}
public void Get_Returns_User_Information_For_The_Given_User()
{
var expectedUserInformation = new UserInformation();
_autoMocker.Get <IUserRetriever>().Expect(mock => mock.RetrieveUserInformation(_applicationUser))
.Return(expectedUserInformation);
UserInformationMessage expectedUserInformationMessage = new UserInformationMessage
{
GamingGroups = new List <GamingGroupInfoForUserMessage>
{
new GamingGroupInfoForUserMessage
{
GamingGroupId = 1
},
new GamingGroupInfoForUserMessage
{
GamingGroupId = 2
}
},
Players = new List <PlayerInfoForUserMessage>
{
new PlayerInfoForUserMessage
{
PlayerId = 10
},
new PlayerInfoForUserMessage
{
PlayerId = 20
}
}
};
_autoMocker.Get <ITransformer>().Expect(mock => mock.Transform <UserInformationMessage>(expectedUserInformation))
.Return(expectedUserInformationMessage);
_autoMocker.ClassUnderTest.CurrentUser = _applicationUser;
var actualResponse = _autoMocker.ClassUnderTest.GetUserInformation(_applicationUser.Id);
Assert.That(actualResponse.Content, Is.TypeOf(typeof(ObjectContent <UserInformationMessage>)));
var content = actualResponse.Content as ObjectContent <UserInformationMessage>;
var actualUserInformationMessage = content.Value as UserInformationMessage;
Assert.That(actualUserInformationMessage, Is.SameAs(expectedUserInformationMessage));
Assert.That(actualUserInformationMessage.GamingGroups[0].NemeStatsUrl,
Is.EqualTo(AbsoluteUrlBuilder.GetGamingGroupDetailsUrl(actualUserInformationMessage.GamingGroups[0]
.GamingGroupId)));
Assert.That(actualUserInformationMessage.GamingGroups[1].NemeStatsUrl,
Is.EqualTo(AbsoluteUrlBuilder.GetGamingGroupDetailsUrl(actualUserInformationMessage.GamingGroups[1]
.GamingGroupId)));
Assert.That(actualUserInformationMessage.Players[0].NemeStatsUrl,
Is.EqualTo(AbsoluteUrlBuilder.GetPlayerDetailsUrl(actualUserInformationMessage.Players[0]
.PlayerId)));
Assert.That(actualUserInformationMessage.Players[1].NemeStatsUrl,
Is.EqualTo(AbsoluteUrlBuilder.GetPlayerDetailsUrl(actualUserInformationMessage.Players[1]
.PlayerId)));
}
public virtual HttpResponseMessage GetUserInformation(string userId)
{
var userInformation = _userRetriever.RetrieveUserInformation(CurrentUser);
var userInformationMessage = _transformer.Transform <UserInformationMessage>(userInformation);
userInformationMessage.GamingGroups.ForEach(x => x.NemeStatsUrl = AbsoluteUrlBuilder.GetGamingGroupDetailsUrl(x.GamingGroupId));
userInformationMessage.Players.ForEach(x => x.NemeStatsUrl = AbsoluteUrlBuilder.GetPlayerDetailsUrl(x.PlayerId));
return(Request.CreateResponse(HttpStatusCode.OK, userInformationMessage));
}
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 ItReturnsThePlayedGameIdAndGamingGroupIdOfTheNewlyCreatedPlayedGame()
{
var expectedNemeStatsUrl = AbsoluteUrlBuilder.GetPlayedGameDetailsUrl(EXPECTED_PLAYED_GAME_ID);
var actualResponse = _autoMocker.ClassUnderTest.RecordPlayedGame(_playedGameMessage, EXPECTED_GAMING_GROUP_ID);
Assert.That(actualResponse.Content, Is.TypeOf(typeof(ObjectContent <NewlyRecordedPlayedGameMessage>)));
var content = actualResponse.Content as ObjectContent <NewlyRecordedPlayedGameMessage>;
var newlyRecordedPlayedGameMessage = content.Value as NewlyRecordedPlayedGameMessage;
Assert.That(newlyRecordedPlayedGameMessage.PlayedGameId, Is.EqualTo(EXPECTED_PLAYED_GAME_ID));
Assert.That(newlyRecordedPlayedGameMessage.GamingGroupId, Is.EqualTo(EXPECTED_GAMING_GROUP_ID));
Assert.That(newlyRecordedPlayedGameMessage.NemeStatsUrl, Is.EqualTo(expectedNemeStatsUrl));
}
public void ItReturnsThePlayerIdAndGamingGroupOfTheNewlyCreatedPlayer()
{
var expectedNemeStatsUrl = AbsoluteUrlBuilder.GetPlayerDetailsUrl(_expectedPlayer.Id);
var actualResponse = _autoMocker.ClassUnderTest.SaveNewPlayer(new NewPlayerMessage(), _expectedGamingGroupId);
Assert.That(actualResponse.Content, Is.TypeOf(typeof(ObjectContent <NewlyCreatedPlayerMessage>)));
var content = actualResponse.Content as ObjectContent <NewlyCreatedPlayerMessage>;
var newlyCreatedPlayerMessage = content.Value as NewlyCreatedPlayerMessage;
Assert.That(newlyCreatedPlayerMessage.PlayerId, Is.EqualTo(_expectedPlayer.Id));
Assert.That(newlyCreatedPlayerMessage.GamingGroupId, Is.EqualTo(_expectedGamingGroupId));
Assert.That(newlyCreatedPlayerMessage.NemeStatsUrl, Is.EqualTo(expectedNemeStatsUrl));
}
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)));
}
internal virtual HttpResponseMessage GetPlayedGameSearchResults(PlayedGameFilterMessage playedGameFilterMessage)
{
var filter = _transformer.Transform <PlayedGameFilter>(playedGameFilterMessage);
var searchResults = _playedGameRetriever.SearchPlayedGames(filter);
var playedGamesSearchResultMessage = new PlayedGameSearchResultsMessage
{
PlayedGames = searchResults.Select(Mapper.Map <PlayedGameSearchResultMessage>).ToList()
};
playedGamesSearchResultMessage.PlayedGames.ForEach(x => x.NemeStatsUrl = AbsoluteUrlBuilder.GetPlayedGameDetailsUrl(x.PlayedGameId));
return(Request.CreateResponse(HttpStatusCode.OK, playedGamesSearchResultMessage));
}
public HttpResponseMessage RecordPlayedGame([FromBody] PlayedGameMessage playedGameMessage, [FromUri] int gamingGroupId)
{
var newlyCompletedGame = _transformer.Transform <NewlyCompletedGame>(playedGameMessage);
newlyCompletedGame.TransactionSource = TransactionSource.RestApi;
var playedGame = _createPlayedGameComponent.Execute(newlyCompletedGame, CurrentUser);
var newlyRecordedPlayedGameMessage = new NewlyRecordedPlayedGameMessage
{
PlayedGameId = playedGame.Id,
GamingGroupId = playedGame.GamingGroupId,
NemeStatsUrl = AbsoluteUrlBuilder.GetPlayedGameDetailsUrl(playedGame.Id)
};
return(Request.CreateResponse(HttpStatusCode.OK, newlyRecordedPlayedGameMessage));
}
public virtual HttpResponseMessage GetGameDefinitions([FromUri] int gamingGroupId)
{
var results = _gameDefinitionRetriever.GetAllGameDefinitions(gamingGroupId);
var gameDefinitionsSearchResultsMessage = new GameDefinitionsSearchResultsMessage
{
GameDefinitions = results.Select(result => new GameDefinitionSearchResultMessage
{
Active = result.Active,
BoardGameGeekGameDefinitionId = result.BoardGameGeekGameDefinitionId,
GameDefinitionId = result.Id,
GameDefinitionName = result.Name,
NemeStatsUrl = AbsoluteUrlBuilder.GetGameDefinitionUrl(result.Id)
}).ToList()
};
return(Request.CreateResponse(HttpStatusCode.OK, gameDefinitionsSearchResultsMessage));
}
public virtual HttpResponseMessage SaveNewGameDefinition([FromBody] NewGameDefinitionMessage newGameDefinitionMessage, [FromUri] int gamingGroupId)
{
var createGameDefinitionRequest = new CreateGameDefinitionRequest
{
BoardGameGeekGameDefinitionId = newGameDefinitionMessage.BoardGameGeekObjectId,
Name = newGameDefinitionMessage.GameDefinitionName,
GamingGroupId = newGameDefinitionMessage.GamingGroupId
};
var newGameDefinition = _createGameDefinitionComponent.Execute(createGameDefinitionRequest, CurrentUser);
var newlyCreatedGameDefinitionMessage = new NewlyCreatedGameDefinitionMessage
{
GameDefinitionId = newGameDefinition.Id,
GamingGroupId = newGameDefinition.GamingGroupId,
NemeStatsUrl = AbsoluteUrlBuilder.GetGameDefinitionUrl(newGameDefinition.Id)
};
return(Request.CreateResponse(HttpStatusCode.OK, newlyCreatedGameDefinitionMessage));
}
