public async Task TestExecuteAsyncShouldSendGMMessages()
{
// Arrange
Message msg = null;
void SetMessage(Message posted)
{
msg = posted;
}
var managerMock = GetManagerMock(SetMessage);
var clientMock = GetGMClientMock();
IServiceCollection services = GetServices(managerMock.Object, clientMock.Object);
int msgCount = 10;
var msgID = MessageID.JoinTheGameAnswer;
var payload = new JoinAnswerPayload()
{
Accepted = true,
AgentID = 1
};
var queue = PrepareQueue(msgID, msgCount, payload);
services.AddSingleton(queue);
var serviceProvider = services.BuildServiceProvider();
var hostedService = serviceProvider.GetService <IHostedService>();
// Act
int delay = 1000;
await Task.Run(async() =>
{
await hostedService.StartAsync(CancellationToken.None);
await Task.Delay(delay);
await hostedService.StopAsync(CancellationToken.None);
});
// Assert
Assert.Equal(0, queue.Count);
Assert.NotNull(msg);
Assert.Equal(msgID, msg.MessageID);
managerMock.Verify(m => m.SendMessageAsync(It.IsAny <int>(), It.IsAny <Message>(),
It.IsAny <CancellationToken>()), Times.Exactly(msgCount),
$"Should send exactly {msgCount} messages to players");
clientMock.Verify(m => m.SendAsync(It.IsAny <Message>(), It.IsAny <CancellationToken>()),
Times.Never(),
"Should not send messages to GM");
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
await sync.SemaphoreSlim.WaitAsync();
logger.Information("Started CommunicationService");
gmClient = container.GMClient;
while (!stoppingToken.IsCancellationRequested)
{
Message message = await queue.ReceiveAsync(stoppingToken);
if (message == null)
{
logger.Information("Stopping CommunicationService");
return;
}
if (message.IsMessageToGM())
{
await gmClient.SendAsync(message, stoppingToken);
logger.Verbose(MessageLogger.Received(message) + ". Sent message to GM");
}
else
{
await manager.SendMessageAsync(message.AgentID.Value, message, stoppingToken);
logger.Verbose(MessageLogger.Received(message) + ". Sent message to Player");
await sync.SemaphoreSlim.WaitAsync();
if (!container.GameStarted)
{
if (message.MessageID == MessageID.JoinTheGameAnswer)
{
JoinAnswerPayload payload = (JoinAnswerPayload)message.Payload;
if (payload.Accepted)
{
ConfirmSocket(message);
}
}
else if (message.MessageID == MessageID.StartGame)
{
await CloseUnconfirmedSockets(stoppingToken);
container.GameStarted = true;
}
}
sync.SemaphoreSlim.Release(1);
}
}
}
public async Task TestAcceptMessageJoinTheGameShouldEndGame()
{
// Arrange
PlayerConfiguration configuration = GenerateSampleConfiguration();
BufferBlock <Message> inputBuffer = new BufferBlock <Message>();
ISocketClient <Message, Message> client = GenerateSocketClient();
var player = new Models.Player(configuration, inputBuffer, client, logger);
JoinAnswerPayload payload = new JoinAnswerPayload()
{
Accepted = false,
AgentID = 1,
};
Message messageStart = new Message(MessageID.JoinTheGameAnswer, agentID, payload);
// Act
inputBuffer.Post(messageStart);
await player.AcceptMessage(CancellationToken.None);
// Assert
bool isNowWorking = player.GetValue <Player.Models.Player, bool>("isWorking");
Assert.False(isNowWorking);
}
