public void ReturnCreatedAtResult()
{
//arrange
var blockNumbers = new List <int> {
91, 92, 93, 94, 95
};
var battleShipBlocks = new BattleShipToBeCreatedRequest
{
BlockNumbers = blockNumbers
};
var expectedBattleShip = Helper.FakeBattleShipFactory(blockNumbers, 5);
var moqBattleShipService = new Mock <IBattleShipService>();
moqBattleShipService
.Setup(br => br.SaveBattleShip(It.IsAny <int>(), It.IsAny <List <BattleShipBlock> >()))
.Returns(expectedBattleShip);
var fakeBattleShipService = moqBattleShipService.Object;
var fakeBattleShipRepo = new Mock <IBattleShipRepo>().Object;
var fakeBlockRepo = new Mock <IBlockRepo>().Object;
//sut
var sut = new BattleShipController(
fakeBoardRepo, fakeBattleShipRepo,
fakeBlockRepo, fakeBattleShipService, fakeLogger);
//act
var response = sut.ApiBattleShipPost(Helper.FAKE_BOARD_ID, battleShipBlocks);
//assert
Assert.AreEqual((int)HttpStatusCode.Created, response.StatusCode);
}
public void TestAddShip_NotVerticalOrHorizontal_ErrorResponse()
{
// Arrange
var boardsManager = new GameBoardsManager();
var battleShipController = new BattleShipController(boardsManager);
var result = battleShipController.AddBoard() as JsonResult;
var boardId = (result.Value as BoardResponse).BoardId;
// Act
var addShipResult = battleShipController.AddShip(new AddShipRequest()
{
BoardId = boardId,
HeadPosition =
new BattleShipStateTracker.Request.Coordinate()
{
X = 5, Y = 6
},
TailPosition =
new BattleShipStateTracker.Request.Coordinate()
{
X = 7, Y = 8
}
}) as JsonResult;
// Assert
Assert.IsNotNull(addShipResult);
Assert.AreEqual(StatusCodes.Status400BadRequest, addShipResult.StatusCode);
var value = addShipResult.Value as ErrorResponse;
Assert.IsNotNull(value);
}
public async Task IncorrectCoordinatesShotTest()
{
object expected = new GameStateResponse(1234)
{
GameStatus = GameStatuses.SHOOTING, NextPlayer = 1
};
var mockCache = MockMemoryCacheService.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
mockConfig.Setup(config => config.Value).Returns(() => prepareConfig());
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
List <Coordinate> incorrectCoordinates = new List <Coordinate> {
new Coordinate(-1, 1),
new Coordinate(1, -2),
new Coordinate(0, 1),
new Coordinate(1, 0),
new Coordinate(15, 5),
new Coordinate(5, 15),
new Coordinate(15, 15)
};
foreach (Coordinate c in incorrectCoordinates)
{
ShotRequest request = new ShotRequest()
{
GameId = 1234, PlayerId = 1, Coordinate = c
};
var ex = Assert.Throws <InvalidCoordinatesException>(() => controller.Shot(request));
Assert.Equal("Invalid coordinates supplied, possible values: columns 1-10, rows 1-10", ex.Message);
}
}
public async Task CollidingShipsPlacingTest()
{
object expected = new GameStateResponse(1234); //status = placing
var mockCache = MockMemoryCacheService.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
mockConfig.Setup(config => config.Value).Returns(() => prepareConfig());
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
List <ShipPlacement> incorrectShips = new List <ShipPlacement> { // COLLISION!
new ShipPlacement {
Coordinates = new List <Coordinate> {
new Coordinate(1, 1), new Coordinate(1, 2)
}
},
new ShipPlacement {
Coordinates = new List <Coordinate> {
new Coordinate(1, 2), new Coordinate(2, 2)
}
}
};
ShipPlacementRequest request = new ShipPlacementRequest()
{
GameId = 1234, PlayerId = 1, Ships = incorrectShips
};
var ex = Assert.Throws <CollidingShipsLogError>(() => controller.PlaceShips(request));
Assert.Equal("Provided ships are colliding as they share coordinates", ex.Message);
}
public async Task InvalidShipIntegrityPlacingTest()
{
object expected = new GameStateResponse(1234); //status = placing
var mockCache = MockMemoryCacheService.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
mockConfig.Setup(config => config.Value).Returns(() => prepareConfig());
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
List <ShipPlacement> incorrectShips = prepareValidShipsWithoutOne2Fielded();
incorrectShips.Add(new ShipPlacement {
Coordinates = new List <Coordinate> {
new Coordinate(8, 8), new Coordinate(10, 8)
}
}); //desintegrated ship
ShipPlacementRequest request = new ShipPlacementRequest()
{
GameId = 1234, PlayerId = 1, Ships = incorrectShips
};
var ex = Assert.Throws <InvalidShipIntegrityException>(() => controller.PlaceShips(request));
Assert.Equal("Each ship needs to have connected coordinates", ex.Message);
}
public async Task ProperPlacementWaitingForSecondPlayerPlacingTest()
{
object expected = new GameStateResponse(1234); //status = placing
var mockCache = MockMemoryCacheServiceWithGetAndSet.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
mockConfig.Setup(config => config.Value).Returns(() => prepareConfig());
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
List <ShipPlacement> correctShips = prepareValidShipsWithoutOne2Fielded();
correctShips.Add(new ShipPlacement {
Coordinates = new List <Coordinate> {
new Coordinate(8, 8), new Coordinate(9, 8)
}
});
ShipPlacementRequest request = new ShipPlacementRequest()
{
GameId = 1234, PlayerId = 1, Ships = correctShips
};
var result = controller.PlaceShips(request);
var viewResult = Assert.IsType <ActionResult <GameStateResponse> >(result);
GameStateResponse expectedNewGame = new GameStateResponse(1234);
Assert.Equal(result.Value.NextPlayer, 0); //still waiting for second player to place ships
Assert.Equal(result.Value.GameStatus, GameStatuses.PLACING); //still waiting for second player to place ships
Assert.True(result.Value.Player1Ships.Count > 0); //ships placed by first player
}
public async Task IncorrectCoordinatesShipsPlacingTest()
{
object expected = new GameStateResponse(1234); //status = placing
var mockCache = MockMemoryCacheService.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
mockConfig.Setup(config => config.Value).Returns(() => prepareConfig());
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
List <ShipPlacement> incorrectShips = new List <ShipPlacement> { // INCORRECT COORDINATE 1,12
new ShipPlacement {
Coordinates = new List <Coordinate> {
new Coordinate(1, 12), new Coordinate(1, 2)
}
},
new ShipPlacement {
Coordinates = new List <Coordinate> {
new Coordinate(3, 2), new Coordinate(2, 2)
}
}
};
ShipPlacementRequest request = new ShipPlacementRequest()
{
GameId = 1234, PlayerId = 1, Ships = incorrectShips
};
var ex = Assert.Throws <InvalidCoordinatesException>(() => controller.PlaceShips(request));
Assert.Equal("Invalid coordinates supplied, possible values: columns 1-10, rows 1-10", ex.Message);
}
public async Task InvalidShipAmountPlacingTest()
{
object expected = new GameStateResponse(1234); //status = placing
var mockCache = MockMemoryCacheService.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
mockConfig.Setup(config => config.Value).Returns(() => prepareConfig());
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
List <ShipPlacement> incorrectShips = new List <ShipPlacement> { //ONLY 2 SHIPS
new ShipPlacement {
Coordinates = new List <Coordinate> {
new Coordinate(1, 1), new Coordinate(1, 2)
}
},
new ShipPlacement {
Coordinates = new List <Coordinate> {
new Coordinate(3, 2), new Coordinate(2, 2)
}
}
};
ShipPlacementRequest request = new ShipPlacementRequest()
{
GameId = 1234, PlayerId = 1, Ships = incorrectShips
};
var ex = Assert.Throws <InvalidShipAmountException>(() => controller.PlaceShips(request));
Assert.Equal("Provided ships do not conform to the configured amounts, which is: [{\"Size\":5,\"Amount\":1},{\"Size\":4,\"Amount\":2},{\"Size\":3,\"Amount\":3},{\"Size\":2,\"Amount\":4}]", ex.Message);
}
public void TestAddShip_BoardNotExist_ErrorResponse()
{
// Arrange
var boardsManager = new GameBoardsManager();
var battleShipController = new BattleShipController(boardsManager);
// Act
var addShipResult = battleShipController.AddShip(new AddShipRequest()
{
BoardId = "fake id",
HeadPosition =
new BattleShipStateTracker.Request.Coordinate()
{
X = 5, Y = 6
},
TailPosition =
new BattleShipStateTracker.Request.Coordinate()
{
X = 6, Y = 6
}
}) as JsonResult;
// Assert
Assert.IsNotNull(addShipResult);
Assert.AreEqual(StatusCodes.Status400BadRequest, addShipResult.StatusCode);
var value = addShipResult.Value as ErrorResponse;
Assert.IsNotNull(value);
}
public async Task CreateNewGameTest()
{
var mockRandom = new Moq.Mock <Random>();
mockRandom.Setup(rand => rand.Next(1, 10000)).Returns(() => 1234); //Random Number Generator returns 1234
var randomGenerator = new RandomGenerator(mockRandom.Object);
var mockCache = new Mock <IMemoryCache>();
mockCache.Setup
(cache =>
cache.CreateEntry(
It.IsAny <object>()
))
.Returns(Mock.Of <ICacheEntry>());
var mockConfig = new Mock <IOptions <BattleshipConfiguration> >();
var mockEngine = new Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache.Object, mockConfig.Object, mockEngine.Object, randomGenerator);
var result = controller.GetNewGame();
var viewResult = Assert.IsType <ActionResult <GameStateResponse> >(result);
Assert.True(compareObjectJsons(new GameStateResponse(1234), result.Value));
}
public void TestAddShip_Success()
{
// Arrange
var boardsManager = new GameBoardsManager();
var battleShipController = new BattleShipController(boardsManager);
var result = battleShipController.AddBoard() as JsonResult;
var boardId = (result.Value as BoardResponse).BoardId;
// Act
var addShipResult = battleShipController.AddShip(new AddShipRequest()
{
BoardId = boardId, HeadPosition =
new BattleShipStateTracker.Request.Coordinate()
{
X = 5, Y = 6
},
TailPosition =
new BattleShipStateTracker.Request.Coordinate()
{
X = 6, Y = 6
}
}) as JsonResult;
// Assert
Assert.IsNotNull(addShipResult);
Assert.AreEqual(StatusCodes.Status201Created, addShipResult.StatusCode);
var value = addShipResult.Value as SuccessResponse;
Assert.IsNotNull(value);
}
public async Task MissedShotTest()
{
object expected = new GameStateResponse(1234)
{
GameStatus = GameStatuses.SHOOTING, NextPlayer = 1, Player2Ships = prepareTwoShipsWithOneDamage()
};
var mockCache = MockMemoryCacheServiceWithGetAndSet.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
mockConfig.Setup(config => config.Value).Returns(() => prepareConfig());
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
ShotRequest request = new ShotRequest()
{
GameId = 1234, PlayerId = 1, Coordinate = new Coordinate(5, 5)
};
var result = controller.Shot(request);
var viewResult = Assert.IsType <ActionResult <GameStateResponse> >(result);
Assert.Equal(result.Value.NextPlayer, 2); //swapped players
Assert.Equal(result.Value.GameStatus, GameStatuses.SHOOTING); //game still going
Assert.Equal(result.Value.Message, "Missed!"); //message
}
public async Task ProperEndingShotShipDestroyedGameEndTest()
{
object expected = new GameStateResponse(1234)
{
GameStatus = GameStatuses.SHOOTING, NextPlayer = 1, Player2Ships = prepareTwoShipsWithOneMissingDamage()
};
var mockCache = MockMemoryCacheServiceWithGetAndSet.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
mockConfig.Setup(config => config.Value).Returns(() => prepareConfig());
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
ShotRequest request = new ShotRequest()
{
GameId = 1234, PlayerId = 1, Coordinate = new Coordinate(2, 2)
};
var result = controller.Shot(request);
var viewResult = Assert.IsType <ActionResult <GameStateResponse> >(result);
Assert.Equal(result.Value.NextPlayer, 0); //no more moves
Assert.Equal(result.Value.GameStatus, GameStatuses.FINISHED); //Game finished
Assert.Equal(result.Value.WinnerPlayer, 1); //winner
Assert.Equal(result.Value.Message, "Game finished, player 1 has won the game"); //message
}
void Start()
{
Model = transform.GetChild(0).gameObject;
BSC = GetComponent <BattleShipController>();
Hull = BSC.ShipInfo.Hull;
Shields = BSC.ShipInfo.Shields;
Energy = BSC.ShipInfo.Energy;
}
public void TestAttack_WasAttacked_ErrorResponse()
{
// Arrange
var boardsManager = new GameBoardsManager();
var battleShipController = new BattleShipController(boardsManager);
var result = battleShipController.AddBoard() as JsonResult;
var boardId = (result.Value as BoardResponse).BoardId;
battleShipController.AddShip(new AddShipRequest()
{
BoardId = boardId,
HeadPosition =
new BattleShipStateTracker.Request.Coordinate()
{
X = 5, Y = 6
},
TailPosition =
new BattleShipStateTracker.Request.Coordinate()
{
X = 6, Y = 6
}
});
battleShipController.Attack(new AttackRequest()
{
BoardId = boardId,
Position = new BattleShipStateTracker.Request.Coordinate()
{
X = 5, Y = 6
}
});
// Act
var attackResult = battleShipController.Attack(new AttackRequest()
{
BoardId = boardId,
Position = new BattleShipStateTracker.Request.Coordinate()
{
X = 5, Y = 6
}
}) as JsonResult;
// Assert
Assert.IsNotNull(attackResult);
Assert.AreEqual(StatusCodes.Status400BadRequest, attackResult.StatusCode);
var value = attackResult.Value as ErrorResponse;
Assert.IsNotNull(value);
Assert.AreEqual("The position (5,6) has been attacked before.", value.ErrorMessages[0]);
}
public void TestGetBoards_Success()
{
// Arrange
var boardsManager = new GameBoardsManager();
var battleShipController = new BattleShipController(boardsManager);
// Act
var result = battleShipController.GetBoards() as JsonResult;
// Arrange
Assert.IsNotNull(result);
Assert.AreEqual(StatusCodes.Status200OK, result.StatusCode);
var value = result.Value as BoardResponse[];
Assert.IsNotNull(value);
Assert.AreEqual(0, value.Length);
}
public void TestAddBoard_Success()
{
// Arrange
var boardsManager = new GameBoardsManager();
var battleShipController = new BattleShipController(boardsManager);
// Act
var result = battleShipController.AddBoard() as JsonResult;
// Arrange
Assert.IsNotNull(result);
Assert.AreEqual(StatusCodes.Status201Created, result.StatusCode);
var value = result.Value as BoardResponse;
Assert.IsNotNull(value);
Assert.IsTrue(Guid.TryParse(value.BoardId, out _));
}
public async Task InvalidGameShotTest()
{
object expected = null; //game not found
var mockCache = MockMemoryCacheService.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
ShotRequest request = new ShotRequest()
{
GameId = 1234, PlayerId = 1, Coordinate = new Coordinate(1, 1)
};
var ex = Assert.Throws <InvalidGameIdException>(() => controller.Shot(request));
Assert.Equal("Invalid game Id 1234, no valid game with the given id exists.", ex.Message);
}
public async Task InvalidPlayerIdPlacingTest()
{
object expected = new GameStateResponse(1234); //status = placing
var mockCache = MockMemoryCacheService.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
ShipPlacementRequest request = new ShipPlacementRequest()
{
GameId = 1234, PlayerId = 15
};
var ex = Assert.Throws <InvalidPlayerIdException>(() => controller.PlaceShips(request));
Assert.Equal("Invalid Player Id. Only Players with Id 1 and 2 are permited", ex.Message);
}
public async Task PlacingGameShotTest()
{
object expected = new GameStateResponse(1234); //status = placing
var mockCache = MockMemoryCacheService.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
ShotRequest request = new ShotRequest()
{
GameId = 1234, PlayerId = 1, Coordinate = new Coordinate(1, 1)
};
var ex = Assert.Throws <InvalidGameStatusShootingException>(() => controller.Shot(request));
Assert.Equal("Game is not in the Shooting mode, current mode: PLACING", ex.Message);
}
public async Task NoShipsPlacingTest()
{
object expected = new GameStateResponse(1234); //status = placing
var mockCache = MockMemoryCacheService.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
mockConfig.Setup(config => config.Value).Returns(() => prepareConfig());
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
ShipPlacementRequest request = new ShipPlacementRequest()
{
GameId = 1234, PlayerId = 1
};
var ex = Assert.Throws <NoShipsProvidedException>(() => controller.PlaceShips(request));
Assert.Equal("No ships provided in placement", ex.Message);
}
public void TestAttack_HitResponse()
{
// Arrange
var boardsManager = new GameBoardsManager();
var battleShipController = new BattleShipController(boardsManager);
var result = battleShipController.AddBoard() as JsonResult;
var boardId = (result.Value as BoardResponse).BoardId;
battleShipController.AddShip(new AddShipRequest()
{
BoardId = boardId,
HeadPosition =
new BattleShipStateTracker.Request.Coordinate()
{
X = 5, Y = 6
},
TailPosition =
new BattleShipStateTracker.Request.Coordinate()
{
X = 6, Y = 6
}
});
// Act
var attackResult = battleShipController.Attack(new AttackRequest()
{
BoardId = boardId,
Position = new BattleShipStateTracker.Request.Coordinate()
{
X = 5, Y = 6
}
}) as JsonResult;
// Assert
Assert.IsNotNull(attackResult);
Assert.AreEqual(StatusCodes.Status200OK, attackResult.StatusCode);
var value = attackResult.Value as HitResponse;
Assert.IsNotNull(value);
Assert.IsTrue(value.Hit);
}
public void TestDeleteBoard_Success()
{
// Arrange
var boardsManager = new GameBoardsManager();
var battleShipController = new BattleShipController(boardsManager);
var result = battleShipController.AddBoard() as JsonResult;
var boardId = (result.Value as BoardResponse).BoardId;
// Act
var deleteBoardResult = battleShipController.DeleteBoard(new BoardRequest()
{
BoardId = boardId,
}) as JsonResult;
// Arrange
Assert.IsNotNull(deleteBoardResult);
Assert.AreEqual(StatusCodes.Status200OK, deleteBoardResult.StatusCode);
var value = deleteBoardResult.Value as SuccessResponse;
Assert.IsNotNull(value);
}
public async Task FinishedGamePlacingTest()
{
object expected = new GameStateResponse(1234)
{
GameStatus = GameStatuses.FINISHED
};
var mockCache = MockMemoryCacheService.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
ShipPlacementRequest request = new ShipPlacementRequest()
{
GameId = 1234, PlayerId = 1
};
var ex = Assert.Throws <InvalidGameStatusPlacingException>(() => controller.PlaceShips(request));
Assert.Equal("Game already started thus it's no longer possible to place ships, current mode: FINISHED", ex.Message);
}
public void TestDeleteBoard_BoardNotExist_ErrorResponse()
{
// Arrange
var boardsManager = new GameBoardsManager();
var battleShipController = new BattleShipController(boardsManager);
battleShipController.AddBoard();
// Act
var deleteBoardResult = battleShipController.DeleteBoard(new BoardRequest()
{
BoardId = "fake id",
}) as JsonResult;
// Arrange
Assert.IsNotNull(deleteBoardResult);
Assert.AreEqual(StatusCodes.Status400BadRequest, deleteBoardResult.StatusCode);
var value = deleteBoardResult.Value as ErrorResponse;
Assert.IsNotNull(value);
}
public async Task IncorrectPlayerGameShotTest()
{
object expected = new GameStateResponse(1234)
{
GameStatus = GameStatuses.SHOOTING, NextPlayer = 1
};
var mockCache = MockMemoryCacheService.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
ShotRequest request = new ShotRequest()
{
GameId = 1234, PlayerId = 2, Coordinate = new Coordinate(1, 1)
};
var ex = Assert.Throws <InvalidTurnPlayerException>(() => controller.Shot(request));
Assert.Equal("Not your turn! Wait for player 1 to shot next", ex.Message);
}
