public void TestStartGame()
{
// Arrange
var conf = new MockGameConfiguration();
var queue = new BufferBlock <Message>();
var lifetime = Mock.Of <IApplicationLifetime>();
var client = new TcpSocketClient <Message, Message>(logger);
var gameMaster = new GM(lifetime, conf, queue, client, logger);
var players = gameMaster.GetValue <GM, Dictionary <int, GMPlayer> >("players");
for (int idRed = 0; idRed < conf.NumberOfPlayersPerTeam; ++idRed)
{
var player = new GMPlayer(idRed, conf, client, Team.Red, logger);
players.Add(idRed, player);
int idBlue = idRed + conf.NumberOfPlayersPerTeam;
player = new GMPlayer(idBlue, conf, client, Team.Blue, logger);
players.Add(idBlue, player);
}
gameMaster.Invoke("InitGame");
// Act
var task = gameMaster.Invoke <GM, Task>("StartGame", CancellationToken.None);
task.Wait();
// Assert
Assert.True(gameMaster.WasGameStarted);
// TODO create mock of socket and check if GM sends messages
}
public void TestDiscoverShouldReturnNegativeNumbers()
{
// Arrange
var conf = new MockGameConfiguration();
var queue = new BufferBlock <Message>();
var lifetime = Mock.Of <IApplicationLifetime>();
var client = new TcpSocketClient <Message, Message>(logger);
var gameMaster = new GM(lifetime, conf, queue, client, logger);
gameMaster.Invoke("InitGame");
// Act
var distances = gameMaster.Invoke <GM, Dictionary <Direction, int?> >("Discover", new TaskField(0, 5));
var board = gameMaster.GetValue <GM, AbstractField[][]>("board");
int?expectedResult = null;
int?resultS = distances[Direction.S];
int?resultSE = distances[Direction.SE];
int?resultSW = distances[Direction.SW];
// Assert
Assert.Equal(expectedResult, resultS);
Assert.Equal(expectedResult, resultSE);
Assert.Equal(expectedResult, resultSW);
}
public async Task TestConfigurationShouldReturnBadRequestCode()
{
// Arrange
var inMemorySettings = new Dictionary <string, string>
{
{ "GameConfigPath", "gameConfig.json" },
};
IConfiguration config = new ConfigurationBuilder()
.AddInMemoryCollection(inMemorySettings)
.Build();
var gameConfig = new MockGameConfiguration();
var queue = new BufferBlock <Message>();
var lifetime = Mock.Of <IApplicationLifetime>();
var client = new TcpSocketClient <Message, Message>(logger);
var gameMaster = new GM(lifetime, gameConfig, queue, client, logger);
GameController gameController = new GameController(config, gameConfig, gameMaster, logger);
// Act
var result = await gameController.Configuration(null);
var createdResult = (BadRequestObjectResult)result.Result;
int expectedStatusCode = (int)HttpStatusCode.BadRequest;
string expectedValue = "Received empty configuration";
// Assert
Assert.Equal(expectedStatusCode, createdResult.StatusCode);
Assert.Equal(expectedValue, createdResult.Value);
}
public void TestValidateConf()
{
// Arrange
var conf = new MockGameConfiguration();
var gameMaster = ValidationConfGMHelper(conf);
// Act
gameMaster.Invoke("InitGame");
// Assert
Assert.True(gameMaster.WasGameInitialized);
}
public void DiscoverTest(TaskField field, int pieceCount)
{
var conf = new MockGameConfiguration();
var queue = new BufferBlock <Message>();
var lifetime = Mock.Of <IApplicationLifetime>();
var client = new TcpSocketClient <Message, Message>(logger);
var gameMaster = new GM(lifetime, conf, queue, client, logger);
gameMaster.Invoke("InitGame");
for (int i = 0; i < pieceCount; ++i)
{
gameMaster.Invoke("GeneratePiece");
}
// Act
var discoveryActionResult = gameMaster.Invoke <GM, Dictionary <Direction, int?> >("Discover", field);
// Assert
var board = gameMaster.GetValue <GM, AbstractField[][]>("board");
List <(AbstractField field, int dist, Direction dir)> neighbours = GetNeighbours(field, board, conf.Height, conf.Width);
for (int k = 0; k < neighbours.Count; k++)
{
for (int i = conf.GoalAreaHeight; i < conf.Height - conf.GoalAreaHeight; i++)
{
for (int j = 0; j < board[i].Length; j++)
{
int dist = ManhattanDistance(neighbours[k].field, board[i][j]);
if (dist < neighbours[k].dist)
{
neighbours[k] = (neighbours[k].field, dist, neighbours[k].dir);
}
}
}
if (discoveryActionResult[neighbours[k].dir] != neighbours[k].dist)
{
Assert.False(discoveryActionResult[neighbours[k].dir] == neighbours[k].dist,
$"Incorect value for distance: {discoveryActionResult[neighbours[k].dir]} != {neighbours[k].dist}");
}
}
int discoveredFields = 0;
foreach (var distance in discoveryActionResult)
{
if (distance.Value >= 0)
{
++discoveredFields;
}
}
Assert.Equal(neighbours.Count, discoveredFields);
}
public void TestValidateConfNumberOfPiecesOnBoard()
{
// Arrange
var conf = new MockGameConfiguration();
conf.NumberOfPiecesOnBoard = ((conf.Height - (conf.GoalAreaHeight * 2)) * conf.Width) + 1;
var gameMaster = ValidationConfGMHelper(conf);
// Act
gameMaster.Invoke("InitGame");
// Assert
Assert.False(gameMaster.WasGameInitialized);
}
public void TestValidateConfGoalAreaHeight()
{
// Arrange
var conf = new MockGameConfiguration();
conf.GoalAreaHeight = (conf.Height / 2) + 1;
var gameMaster = ValidationConfGMHelper(conf);
// Act
gameMaster.Invoke("InitGame");
// Assert
Assert.False(gameMaster.WasGameInitialized);
}
public void TestValidateConfNumberOfPlayersPerTeam()
{
// Arrange
var conf = new MockGameConfiguration();
conf.NumberOfGoals = (conf.Height * conf.Width) + 1;
var gameMaster = ValidationConfGMHelper(conf);
// Act
gameMaster.Invoke("InitGame");
// Assert
Assert.False(gameMaster.WasGameInitialized);
}
public void TestValidateConfShamPieceProbability()
{
// Arrange
var conf = new MockGameConfiguration()
{
ShamPieceProbability = 1
};
var gameMaster = ValidationConfGMHelper(conf);
// Act
gameMaster.Invoke("InitGame");
// Assert
Assert.False(gameMaster.WasGameInitialized);
}
public void TestValidatePenalty()
{
// Arrange
var conf = new MockGameConfiguration()
{
PickupPenalty = -1
};
var gameMaster = ValidationConfGMHelper(conf);
// Act
gameMaster.Invoke("InitGame");
// Assert
Assert.False(gameMaster.WasGameInitialized);
}
public void TestInitializePlayersPositions()
{
// Arrange
var conf = new MockGameConfiguration();
var queue = new BufferBlock <Message>();
var lifetime = Mock.Of <IApplicationLifetime>();
var client = new TcpSocketClient <Message, Message>(logger);
var gameMaster = new GM(lifetime, conf, queue, client, logger);
var players = gameMaster.GetValue <GM, Dictionary <int, GMPlayer> >("players");
for (int i = 0; i < conf.NumberOfPlayersPerTeam; ++i)
{
players.Add(i, new GMPlayer(i, conf, client, Team.Red, logger));
int j = i + conf.NumberOfPlayersPerTeam;
players.Add(j, new GMPlayer(j, conf, client, Team.Blue, logger));
}
gameMaster.Invoke("InitGame");
var board = gameMaster.GetValue <GM, AbstractField[][]>("board");
var initializer = new GMInitializer(conf, board);
// Act
initializer.InitializePlayersPoisitions(players);
// Assert
Assert.All(players.Values, p =>
{
Assert.False(p.GetPosition() == null, "All players have positions");
});
Func <int[], int[], bool> arePositionsTheSame =
(int[] posA, int[] posB) => posA[0] == posB[0] && posA[1] == posB[1];
for (int i = 0; i < players.Count; ++i)
{
var playerA = players[i];
var posA = playerA.GetPosition();
(int y1, int y2) = playerA.Team == Team.Blue ? (0, conf.Height - conf.GoalAreaHeight) :
(conf.GoalAreaHeight, conf.Height);
Assert.False(posA[0] < y1 || posA[0] >= y2, "No players are placed on GoalArea of enemy");
for (int j = i + 1; j < players.Count; ++j)
{
var playerB = players[j];
var posB = playerB.GetPosition();
Assert.False(arePositionsTheSame(posA, posB), "No 2 players share the same position");
}
}
}
public void TestGeneratePieceXTimes(int x)
{
// Arrange
var conf = new MockGameConfiguration
{
NumberOfPiecesOnBoard = 1
};
var queue = new BufferBlock <Message>();
var lifetime = Mock.Of <IApplicationLifetime>();
var client = new TcpSocketClient <Message, Message>(logger);
var gameMaster = new GM(lifetime, conf, queue, client, logger);
gameMaster.Invoke("InitGame");
// Act
for (int i = 0; i < x; ++i)
{
gameMaster.Invoke("GeneratePiece");
}
// Assert
int pieceCount = 0;
var board = gameMaster.GetValue <GM, AbstractField[][]>("board");
for (int i = 0; i < board.Length; ++i)
{
for (int j = 0; j < board[i].Length; ++j)
{
var field = board[i][j];
if (board[i][j] is TaskField taskField)
{
if (taskField.ContainsPieces())
{
pieceCount += GetPieceCount(taskField);
}
}
else
{
Assert.False(field.ContainsPieces(), "Pieces should not be generated on goal area");
}
}
}
Assert.Equal(x + 1, pieceCount);
}
public async Task TestExecuteAsyncShouldReadMessages()
{
// Arrange
IServiceCollection services = new ServiceCollection();
AddLogging(services);
var conf = new MockGameConfiguration();
services.AddSingleton(Mock.Of <IApplicationLifetime>());
services.AddSingleton <GameConfiguration>(conf);
services.AddSingleton <ISocketClient <Message, Message>, TcpSocketClient <Message, Message> >();
int messagesNum = 10;
var queue = new BufferBlock <Message>();
for (int i = 0; i < messagesNum; ++i)
{
queue.Post(new Message());
}
services.AddSingleton(queue);
AddLogging(services);
services.AddSingleton <GM>();
services.AddHostedService <GMService>();
var serviceProvider = services.BuildServiceProvider();
var hostedService = serviceProvider.GetService <IHostedService>();
var gameMaster = serviceProvider.GetService <GM>();
gameMaster.Invoke("InitGame");
// Act
int delay = 500;
await Task.Run(async() =>
{
await hostedService.StartAsync(CancellationToken.None);
await Task.Delay(delay);
await hostedService.StopAsync(CancellationToken.None);
});
// Assert
Assert.Equal(0, queue.Count);
}
public void TestParameterlessConfigurationShouldReturnValidConfiguration()
{
// Arrange
var inMemorySettings = new Dictionary <string, string>
{
{ "GameConfigPath", "gameConfig.json" },
};
IConfiguration config = new ConfigurationBuilder()
.AddInMemoryCollection(inMemorySettings)
.Build();
var gameConfig = new MockGameConfiguration();
var queue = new BufferBlock <Message>();
var lifetime = Mock.Of <IApplicationLifetime>();
var client = new TcpSocketClient <Message, Message>(logger);
var gameMaster = new GM(lifetime, gameConfig, queue, client, logger);
GameController gameController = new GameController(config, gameConfig, gameMaster, logger);
// Act
var result = gameController.Configuration();
// Assert
Assert.IsType <ActionResult <GameConfiguration> >(result);
Assert.Equal(gameConfig.AskPenalty, result.Value.AskPenalty);
Assert.Equal(gameConfig.CheckForShamPenalty, result.Value.CheckForShamPenalty);
Assert.Equal(gameConfig.DiscoveryPenalty, result.Value.DiscoveryPenalty);
Assert.Equal(gameConfig.MovePenalty, result.Value.MovePenalty);
Assert.Equal(gameConfig.PutPenalty, result.Value.PutPenalty);
Assert.Equal(gameConfig.ResponsePenalty, result.Value.ResponsePenalty);
Assert.Equal(gameConfig.CsIP, result.Value.CsIP);
Assert.Equal(gameConfig.CsPort, result.Value.CsPort);
Assert.Equal(gameConfig.GoalAreaHeight, result.Value.GoalAreaHeight);
Assert.Equal(gameConfig.Height, result.Value.Height);
Assert.Equal(gameConfig.NumberOfGoals, result.Value.NumberOfGoals);
Assert.Equal(gameConfig.NumberOfPiecesOnBoard, result.Value.NumberOfPiecesOnBoard);
Assert.Equal(gameConfig.NumberOfPlayersPerTeam, result.Value.NumberOfPlayersPerTeam);
Assert.Equal(gameConfig.ShamPieceProbability, result.Value.ShamPieceProbability);
}
public void TestWasGameStartedShouldReturnBool()
{
// Arrange
var inMemorySettings = new Dictionary <string, string>
{
{ "GameConfigPath", "gameConfig.json" },
};
IConfiguration config = new ConfigurationBuilder()
.AddInMemoryCollection(inMemorySettings)
.Build();
var gameConfig = new MockGameConfiguration();
var queue = new BufferBlock <Message>();
var lifetime = Mock.Of <IApplicationLifetime>();
gameConfig.NumberOfPlayersPerTeam = 0;
var client = new TcpSocketClient <Message, Message>(logger);
var gameMaster = new GM(lifetime, gameConfig, queue, client, logger);
GameController gameController = new GameController(config, gameConfig, gameMaster, logger);
CancellationToken cancellationToken = CancellationToken.None;
// Act
var result = gameController.WasGameStarted();
bool expectedResult = false;
gameMaster.Invoke("StartGame", cancellationToken);
gameController = new GameController(config, gameConfig, gameMaster, logger);
var result2 = gameController.WasGameStarted();
bool expectedResult2 = true;
// Assert
Assert.IsType <ActionResult <bool> >(result);
Assert.Equal(expectedResult, result.Value);
Assert.IsType <ActionResult <bool> >(result2);
Assert.Equal(expectedResult2, result2.Value);
}
public async Task TestConfigurationShouldReturnValidConfiguration()
{
// Arrange
var inMemorySettings = new Dictionary <string, string>
{
{ "GameConfigPath", "gameConfig.json" },
};
IConfiguration config = new ConfigurationBuilder()
.AddInMemoryCollection(inMemorySettings)
.Build();
var gameConfig = new MockGameConfiguration();
var queue = new BufferBlock <Message>();
var lifetime = Mock.Of <IApplicationLifetime>();
var client = new TcpSocketClient <Message, Message>(logger);
var gameMaster = new GM(lifetime, gameConfig, queue, client, logger);
GameController gameController = new GameController(config, gameConfig, gameMaster, logger);
// Act
GameConfiguration newGameConfig = new MockGameConfiguration
{
AskPenalty = 200,
Height = 10,
DestroyPenalty = 100,
PickupPenalty = 100
};
var result = await gameController.Configuration(newGameConfig);
var createdResult = (CreatedResult)result.Result;
GameConfiguration returnedGameConfig = (GameConfiguration)createdResult.Value;
// Assert
Assert.Equal((int)HttpStatusCode.Created, createdResult.StatusCode);
Assert.True(newGameConfig.Equals(returnedGameConfig), "Game config should be updated");
}
public void TestInitGameShouldReturnOkResult()
{
// Arrange
var inMemorySettings = new Dictionary <string, string>
{
{ "GameConfigPath", "gameConfig.json" },
};
IConfiguration config = new ConfigurationBuilder()
.AddInMemoryCollection(inMemorySettings)
.Build();
var gameConfig = new MockGameConfiguration();
var queue = new BufferBlock <Message>();
var lifetime = Mock.Of <IApplicationLifetime>();
var client = new TcpSocketClient <Message, Message>(logger);
var gameMaster = new GM(lifetime, gameConfig, queue, client, logger);
GameController gameController = new GameController(config, gameConfig, gameMaster, logger);
// Act
var result = gameController.InitGame();
// Assert
Assert.IsType <OkResult>(result);
}
public void TestInitGame()
{
// Arrange
var conf = new MockGameConfiguration();
var queue = new BufferBlock <Message>();
var lifetime = Mock.Of <IApplicationLifetime>();
var client = new TcpSocketClient <Message, Message>(logger);
var gameMaster = new GM(lifetime, conf, queue, client, logger);
// Act
gameMaster.Invoke("InitGame");
// Assert
Assert.True(gameMaster.WasGameInitialized);
int redGoalFieldsCount = 0;
int blueGoalFieldsCount = 0;
int taskFieldsCount = 0;
int piecesCount = 0;
var board = gameMaster.GetValue <GM, AbstractField[][]>("board");
for (int i = 0; i < board.Length; ++i)
{
for (int j = 0; j < board[i].Length; ++j)
{
AbstractField field = board[i][j];
if (field is GoalField)
{
if (i < conf.GoalAreaHeight)
{
++redGoalFieldsCount;
}
else if (i >= gameMaster.SecondGoalAreaStart)
{
++blueGoalFieldsCount;
}
else
{
Assert.True(false, "Goal field should be on correct position");
}
if (field.ContainsPieces())
{
Assert.True(false, "Goal field should not contain any pieces");
}
}
else if (field is TaskField taskField)
{
++taskFieldsCount;
if (field.ContainsPieces())
{
piecesCount += GetPieceCount(taskField);
}
}
}
}
Assert.True(conf.NumberOfGoals == redGoalFieldsCount,
$"Number of red goal fields should match configuration setting.\n" +
$"Have: {redGoalFieldsCount}\n" +
$"Expected: {conf.NumberOfGoals}");
Assert.True(conf.NumberOfGoals == blueGoalFieldsCount,
$"Number of red goal fields should match configuration setting.\n" +
$"Have: {blueGoalFieldsCount}\n" +
$"Expected: {conf.NumberOfGoals}");
int expectedTaskFieldsCount = (conf.Height - (2 * conf.GoalAreaHeight)) * conf.Width;
Assert.True(expectedTaskFieldsCount == taskFieldsCount,
"Task fields should cover all fields except goal areas.\n" +
$"Have: {taskFieldsCount}\n" +
$"Expected: {expectedTaskFieldsCount}");
Assert.True(conf.NumberOfPiecesOnBoard == piecesCount,
"GM should generate enough pieces.\n" +
$"Have: {piecesCount}\n" +
$"Expected: {conf.NumberOfPiecesOnBoard}");
}
