public void AddManyGameResultToGameResultsList()
{
//Arrange
_gameResultRepositoryMock.Setup(mock => mock.AddMany(It.IsAny <List <GameResult> >()));
_gameTableRepositoryMock.Setup(mock => mock.Get(1)).Returns(_testGameTable1);
_gameTableRepositoryMock.Setup(mock => mock.Get(2)).Returns(_testGameTable2);
_boardGameRepositoryMock.Setup(mock => mock.Get(It.IsAny <int>())).Returns(_testBoardGame);
var gameResultService = new GameResultService(_gameResultRepositoryMock.Object, _gamerRepositoryMock.Object,
_gameTableRepositoryMock.Object, _boardGameRepositoryMock.Object);
Mapper.Reset();
Mapper.Initialize(cfg => { cfg.AddServicesProfiles(); });
//Act
gameResultService.AddGameResults(_testGameResultDtoList, _testGamer1);
//Assert
_gameResultRepositoryMock.Verify(
mock => mock.AddMany(It.Is <List <GameResult> >(
x => x.Count == _testGameResultList.Count &&
x[0].BoardGameId ==
_testGameResultList[0].BoardGameId &&
x[0].BoardGame.Id ==
_testGameResultList[0].BoardGame.Id &&
x[0].GameTableId ==
_testGameResultList[0].GameTableId &&
x[0].GameTable.Id ==
_testGameResultList[0].GameTable.Id &&
x[0].GamerId == _testGameResultList[0].GamerId &&
x[0].Gamer.Id == _testGameResultList[0].Gamer.Id
)),
Times.Once());
}
public void AddGameResultToGameResultsList()
{
//Arrange
_gameResultRepositoryMock.Setup(mock => mock.Add(It.IsAny <GameResult>()));
_gameTableRepositoryMock.Setup(mock => mock.Get(It.IsAny <int>())).Returns(_testGameTable1);
_boardGameRepositoryMock.Setup(mock => mock.Get(It.IsAny <int>())).Returns(_testBoardGame);
var gameResultService = new GameResultService(_gameResultRepositoryMock.Object, _gamerRepositoryMock.Object,
_gameTableRepositoryMock.Object,
_boardGameRepositoryMock.Object
);
Mapper.Reset();
Mapper.Initialize(cfg => { cfg.AddServicesProfiles(); });
//Act
gameResultService.AddGameResult(_testGameResultDto, _testGamer1);
//Assert
_gameResultRepositoryMock.Verify(mock => mock.Add(It.Is <GameResult>(
x => x.GameTableId == _testGameResult.GameTableId &&
x.GameTable.Id == _testGameResult.GameTable.Id &&
x.GamerId == _testGameResult.GamerId &&
x.Gamer == _testGameResult.Gamer &&
x.Place == _testGameResult.Place &&
x.PlayersNumber == _testGameResult.PlayersNumber &&
x.BoardGameId == _testGameResult.BoardGameId &&
x.BoardGame.Id == _testGameResult.BoardGame.Id &&
x.Active == _testGameResult.Active
)),
Times.Once());
}
public void Should_return_player_one_win(GameData gameData, Result result)
{
var subject = new GameResultService();
var actual = subject.GetResult(gameData);
actual.Should().Be(result);
}
public void Should_return_null(GameData gameData)
{
var subject = new GameResultService();
var actual = subject.GetResult(gameData);
actual.Should().BeNull();
}
public void DeactivateGameResult()
{
//Arrange
_gameResultRepositoryMock.Setup(mock => mock.Deactivate(It.IsAny <int>()));
var gameResultService = new GameResultService(_gameResultRepositoryMock.Object, _gamerRepositoryMock.Object,
_gameTableRepositoryMock.Object, _boardGameRepositoryMock.Object);
//Act
gameResultService.DeactivateGameResult(_testGameResult.Id);
//Assert
_gameResultRepositoryMock.Verify(mock => mock.Deactivate(It.Is <int>(x => x.Equals(_testGameResult.Id))),
Times.Once());
}
public void game_result_service_can_set_a_vertical_winner_name_test()
{
//given
string[,] board = new string[3, 3];
board[0, 1] = "O";
board[1, 1] = "O";
board[2, 1] = "O";
//when
GameResultService service = new GameResultService();
var results = service.GameStatus(board);
//then
results.WinnerName.Should().Be("O");
}
public void game_result_service_can_set_vertical_winner_coordinates_test()
{
//given
string[,] board = new string[3, 3];
board[0, 2] = "O";
board[1, 2] = "O";
board[2, 2] = "O";
//when
GameResultService service = new GameResultService();
var results = service.GameStatus(board);
//then
results.WinningCoordinates.Should().Be("[0,2] [1,2] [2,2]");
}
public void game_result_service_can_set_horizontal_is_winner_test()
{
//given
string[,] board = new string[3, 3];
board[0, 0] = "X";
board[0, 1] = "X";
board[0, 2] = "X";
//when
GameResultService service = new GameResultService();
var results = service.GameStatus(board);
//then
results.Type.Should().Be(GameResultType.Winner);
}
public void game_result_service_can_determine_no_winner_test()
{
//given
string[,] board = new string[3, 3];
board[0, 0] = "X";
board[1, 0] = "O";
board[2, 0] = "X";
//when
GameResultService service = new GameResultService();
var results = service.GameStatus(board);
//then
results.Type.Should().Be(GameResultType.NoWinner);
}
public List <GamerView> DoRoundForAllGamerWithResult()
{
var gameService = new GameService();
var gameResult = new GameResultService();
foreach (Gamer player in StaticGamerList.StaticGamersList)
{
DoRoundForGamer(player, StaticCardList.StaticCardsList);
}
StaticGamerList.StaticGamersList = gameResult.GetFinishResult(StaticGamerList.StaticGamersList);
List <GamerView> gamerView = gameService.GetGamerViewList(StaticGamerList.StaticGamersList);
return(gamerView);
}
public void GetGameResult()
{
//Arrange
_gameResultRepositoryMock.Setup(mock => mock.Get(It.IsAny <int>())).Returns(new GameResult());
_gamerRepositoryMock.Setup(mock => mock.Get(It.IsAny <Guid>())).Returns(new Gamer());
_gameTableRepositoryMock.Setup(mock => mock.Get(It.IsAny <int>())).Returns(new GameTable());
var gameResultService = new GameResultService(_gameResultRepositoryMock.Object, _gamerRepositoryMock.Object,
_gameTableRepositoryMock.Object, _boardGameRepositoryMock.Object);
Mapper.Reset();
Mapper.Initialize(cfg => { cfg.AddServicesProfiles(); });
//Act
gameResultService.GetGameResult(_testGameResult.Id);
//Assert
_gameResultRepositoryMock.Verify(mock => mock.Get(It.Is <int>(x => x.Equals(_testGameResult.Id))),
Times.Once());
}
public void GetGameResultList()
{
//Arrange
_gameResultRepositoryMock.Setup(x => x.GetAll()).Returns(new List <GameResult> {
new GameResult()
});
var gameResultService = new GameResultService(_gameResultRepositoryMock.Object, _gamerRepositoryMock.Object,
_gameTableRepositoryMock.Object, _boardGameRepositoryMock.Object);
Mapper.Reset();
Mapper.Initialize(cfg => { cfg.AddServicesProfiles(); });
//Act
var gameResults = gameResultService.GetAllGameResults();
//Assert
Assert.AreEqual(1, gameResults.Count());
_gameResultRepositoryMock.Verify(mock => mock.GetAll(), Times.Once());
}
public void GetByTable()
{
//Arrange
_gameResultRepositoryMock.Setup(mock =>
mock.GetAllByTableId(It.IsAny <int>()))
.Returns(new List <GameResult> {
new GameResult()
});
var gameResultService = new GameResultService(_gameResultRepositoryMock.Object, _gamerRepositoryMock.Object,
_gameTableRepositoryMock.Object, _boardGameRepositoryMock.Object);
//Act
var gameResults = gameResultService.GetAllGameResultsByTableId(_testGameResult.GameTableId.Value);
//Assert
Assert.AreEqual(1, gameResults.Count());
_gameResultRepositoryMock.Verify(
mock => mock.GetAllByTableId(It.Is <int>(x => x.Equals(_testGameResult.GameTableId.Value))),
Times.Once());
}
public void game_result_service_can_set_deadlock_test()
{
//given
string[,] board = new string[3, 3];
board[0, 0] = "X";
board[0, 1] = "O";
board[0, 2] = "X";
board[1, 0] = "O";
board[1, 1] = "X";
board[1, 2] = "O";
board[2, 0] = "O";
board[2, 1] = "X";
board[2, 2] = "O";
//when
GameResultService service = new GameResultService();
var results = service.GameStatus(board);
//then
results.Type.Should().Be(GameResultType.Deadlock);
}
public void GetAllByNickname()
{
//Arrange
var nickname = "test";
_gameResultRepositoryMock.Setup(mock => mock.GetAllByGamerNickname(It.IsAny <string>()))
.Returns(new List <GameResult> {
new GameResult()
});
var gameResultService = new GameResultService(_gameResultRepositoryMock.Object, _gamerRepositoryMock.Object,
_gameTableRepositoryMock.Object, _boardGameRepositoryMock.Object);
Mapper.Reset();
Mapper.Initialize(cfg => { cfg.AddServicesProfiles(); });
//Act
var gameResults = gameResultService.GetAllByGamerNickname(nickname);
//Assert
Assert.AreEqual(1, gameResults.Count());
_gameResultRepositoryMock.Verify(mock => mock.GetAllByGamerNickname(It.Is <string>(x => x.Equals(nickname))),
Times.Once());
}
static void Main(string[] args)
{
GameResultService gameResultService = new GameResultService();
//example 1 winner
string[,] board1 = new string[3, 3];
board1[0, 0] = "X";
board1[1, 0] = "X";
board1[2, 0] = "X";
var results1 = gameResultService.GameStatus(board1);
Console.WriteLine(string.Format("Board 1 Status: {0}.", results1.Status));
//example 2 no winner
string[,] board2 = new string[3, 3];
board2[0, 0] = "X";
board2[1, 0] = "O";
board2[2, 0] = "X";
var results2 = gameResultService.GameStatus(board2);
Console.WriteLine(string.Format("Board 2 Status: {0}.", results2.Status));
//example 3 deadlock
string[,] board3 = new string[3, 3];
board3[0, 0] = "X";
board3[0, 1] = "O";
board3[0, 2] = "X";
board3[1, 0] = "O";
board3[1, 1] = "X";
board3[1, 2] = "O";
board3[2, 0] = "O";
board3[2, 1] = "X";
board3[2, 2] = "O";
var results3 = gameResultService.GameStatus(board3);
Console.WriteLine(string.Format("Board 3 Status: {0}.", results3.Status));
Console.Read();
}
public GameRankController(GameResultService service)
{
this.service = service;
}
// DI via constructor
public GameResultController(GameResultService service)
{
this._service = service;
}
