public async Task TestShouldSaveChatConnectionAndRetrieveFromRedis()
{
// arrange
var chatRoomConnection = TestingScenarioBuilder.BuildChatRoomConnectionPoolWithFourUsers();
var chatRoomId = Guid.NewGuid();
var redis = ServiceProvider.GetRequiredService <RedisContext>();
// act
await redis.SetKey(chatRoomId, chatRoomConnection, TimeSpan.FromMinutes(1));
// assert
var persistedChatRoomConnectionPool = await redis.GetKey <ChatRoomConnectionPool>(chatRoomId);
Assert.Equal(6, persistedChatRoomConnectionPool.ActiveConnectionsLimit);
Assert.Equal(4, persistedChatRoomConnectionPool.TotalActiveConnections);
Assert.Equal(2, persistedChatRoomConnectionPool.ServerInstances.Count());
// first server instance
Assert.Equal(chatRoomConnection.ServerInstances.ElementAt(0).ServerInstanceId.ToString(),
persistedChatRoomConnectionPool.ServerInstances.ElementAt(0).ServerInstanceId.ToString());
Assert.Equal(chatRoomConnection.ServerInstances.ElementAt(0).ConnectedUsers.First().UserId,
persistedChatRoomConnectionPool.ServerInstances.ElementAt(0).ConnectedUsers.First().UserId);
Assert.Equal("connection 1", chatRoomConnection.ServerInstances.ElementAt(0).ConnectedUsers.First().ConnectionId);
Assert.Equal("connection 2", chatRoomConnection.ServerInstances.ElementAt(0).ConnectedUsers.ElementAt(1).ConnectionId);
// second server instance hosting the chat room
Assert.Equal(chatRoomConnection.ServerInstances.ElementAt(1).ServerInstanceId.ToString(),
persistedChatRoomConnectionPool.ServerInstances.ElementAt(1).ServerInstanceId.ToString());
Assert.Equal(chatRoomConnection.ServerInstances.ElementAt(1).ConnectedUsers.First().UserId,
persistedChatRoomConnectionPool.ServerInstances.ElementAt(1).ConnectedUsers.First().UserId);
Assert.Equal("connection 3", chatRoomConnection.ServerInstances.ElementAt(1).ConnectedUsers.First().ConnectionId);
Assert.Equal("connection 4", chatRoomConnection.ServerInstances.ElementAt(1).ConnectedUsers.ElementAt(1).ConnectionId);
}
public async Task TestChatRoomShouldGetConnectionPoolOfChatRoomForFirstTime()
{
// arrange
var chatRoomService = ServiceProvider.GetRequiredService <IChatRoomService>();
var(chatRoom, _) = TestingScenarioBuilder.BuildScenarioWithChatRoomAndUser("Chat 1", 4, "IGP", DB);
// act
var chatActiveConnectionPool = await chatRoomService.GetChatRoomConnectionPool(chatRoom.Name);
// assert
Assert.Equal(chatRoom.Id, chatActiveConnectionPool.ChatRoomId);
Assert.Equal(4, chatRoom.ActiveConnectionsLimit);
Assert.Equal(0, chatActiveConnectionPool.TotalActiveConnections); // no connections for the first time
Assert.Empty(chatActiveConnectionPool.ServerInstances);
}
public void TestChatRoomLogicShouldAddNewUserToAChatRoomWithEmptyConnectionPool()
{
// arrange
var connectionId = "fakeId";
var chatRoomId = Guid.NewGuid();
var instanceId = Guid.NewGuid();
var firstUserId = Guid.NewGuid();
var emptyConnectionPool = TestingScenarioBuilder.BuildChatRoomConnectionPoolEmpty(chatRoomId);
// act: FIRST user wants to connect to the room
var updatedConnectionPool = ChatRoomLogic.IncrementChatRoomConnectionPool(firstUserId, instanceId, connectionId, emptyConnectionPool); // 0 connections
// assert
Assert.Equal(1, updatedConnectionPool.TotalActiveConnections); // 1 connection after
Assert.Equal(firstUserId, updatedConnectionPool.ServerInstances.ElementAt(0).ConnectedUsers.First().UserId); // user has been appended
Assert.Equal(connectionId, updatedConnectionPool.ServerInstances.ElementAt(0).ConnectedUsers.First().ConnectionId); // user has been appended
}
public async Task TestShouldMakeRequestToGameRoomAndGetHttp200(string url)
{
// arrange
var testingScenarioBuilder = new TestingScenarioBuilder(DbContext);
await testingScenarioBuilder.BuildScenarioWithThreeRooms();
// act
var response = await Client.GetAsync(url);
var responseAsString = await response.Content.ReadAsStringAsync();
var responseAsJson = JArray.Parse(responseAsString); // JObject if response is not an array
// assert
Assert.Equal(3, responseAsJson.Count);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
public async Task TestShouldRetunNullFromRedisWhenKeyIsNotFound()
{
// arrange
var chatRoomConnection = TestingScenarioBuilder.BuildChatRoomConnectionPoolWithFourUsers();
var redis = ServiceProvider.GetRequiredService <RedisContext>();
// act
await redis.SetKey("someKey", chatRoomConnection, null);
// assert
var nonExistentChatRoom = await redis.GetKey <ChatRoomConnectionPool>("anotherKey");
var existentChatRoom = await redis.GetKey <ChatRoomConnectionPool>("someKey");
Assert.Null(nonExistentChatRoom);
Assert.NotNull(existentChatRoom);
Assert.Equal(chatRoomConnection.ChatRoomId, existentChatRoom.ChatRoomId);
}
public void TestChatRoomLogicShouldRemoveUserFromAnExistingChatRoomConnectionPool()
{
// arrange
var chatRoomId = Guid.NewGuid();
var instanceId1 = Guid.NewGuid();
var instanceId2 = Guid.NewGuid();
var initialConnectionPool = TestingScenarioBuilder
.BuildChatRoomConnectionPoolTwoInstances(chatRoomId, 6, instanceId1, instanceId2);
// act: remove user with connection 1 from room -- starts with 4 users
var updatedConnectionPool = ChatRoomLogic.DecrementChatRoomConnectionPool(instanceId1, "connection 1", initialConnectionPool);
// assert
var remainingConnectedUser = updatedConnectionPool.ServerInstances.First().ConnectedUsers.First();
Assert.Equal(3, updatedConnectionPool.TotalActiveConnections); // 3 users after one is removed
Assert.Single(updatedConnectionPool.ServerInstances.First().ConnectedUsers); // only 1 connection on instanceId1
Assert.Equal("connection 2", remainingConnectedUser.ConnectionId);
}
public void TestChatRoomLogicShouldAddNewUserToExistingChatRoomConnectionPool()
{
// arrange
var connectionId = "fakeId";
var chatRoomId = Guid.NewGuid();
var instanceId1 = Guid.NewGuid();
var instanceId2 = Guid.NewGuid();
var newUserId = Guid.NewGuid();
var initialConnectionPool = TestingScenarioBuilder
.BuildChatRoomConnectionPoolTwoInstances(chatRoomId, 6, instanceId1, instanceId2);
// act: new user that wants to connect to the room being on instance 2
var updatedConnectionPool = ChatRoomLogic.IncrementChatRoomConnectionPool(newUserId, instanceId2, connectionId, initialConnectionPool); // 4 connections
// assert
Assert.Equal(5, updatedConnectionPool.TotalActiveConnections); // 5 connections after
Assert.Equal(newUserId, updatedConnectionPool.ServerInstances.ElementAt(1).ConnectedUsers.ElementAt(2).UserId); // user has been appended
Assert.Equal(connectionId, updatedConnectionPool.ServerInstances.ElementAt(1).ConnectedUsers.ElementAt(2).ConnectionId); // user has been appended
}
public async Task TestChatRoomShouldGetPreviousConnectionPoolOfChatRoom()
{
// arrange
var chatRoomService = ServiceProvider.GetRequiredService <IChatRoomService>();
var(chatRoom, _, chatActiveConnectionPool) = await TestingScenarioBuilder
.BuildScenarioWithChatRoomAndUserWithPreviousConnectionPool("Chat 1", 4, "IGP", DB, Redis);
// act
var createdChatActiveConnectionPool = await chatRoomService.GetChatRoomConnectionPool(chatRoom.Name);
// assert
Assert.Equal(chatRoom.Id, createdChatActiveConnectionPool.ChatRoomId);
Assert.Equal(4, chatRoom.ActiveConnectionsLimit);
Assert.Equal(4, createdChatActiveConnectionPool.TotalActiveConnections); // 4 active connections
Assert.Equal(2, createdChatActiveConnectionPool.ServerInstances.Count());
Assert.Equal(2, createdChatActiveConnectionPool.ServerInstances.ElementAt(1).ConnectedUsers.Count());
Assert.Equal(chatActiveConnectionPool.ServerInstances.ElementAt(1).ServerInstanceId,
createdChatActiveConnectionPool.ServerInstances.ElementAt(1).ServerInstanceId);
}
public async Task TestPlayerShouldLeaveRoom(string url)
{
// arrange
var testingScenarioBuilder = new TestingScenarioBuilder(DbContext);
var(gameRoom, player, _) = await testingScenarioBuilder.BuildScenarioWithAPlayerInRoom(isInRoom : true); // deconstruction
var gameRoomPlayer = await DbContext.GameRoomPlayers.FindAsync(gameRoom.Id, player.Id);
Assert.True(gameRoomPlayer.IsInRoom); // player IS in the room
var postData = JsonConvert.SerializeObject(new
{
PlayerId = player.Id
});
var payload = new StringContent(postData, Encoding.UTF8, "application/json");
// act
var gameRoomUrl = url + $"/{gameRoom.Id}/leave";
var postResponse = await Client.PostAsync(gameRoomUrl, payload);
// assert
var gameRoomPlayerFromDb = await DbContext.GameRoomPlayers.FirstAsync();
var postResponseAsJson = JObject.Parse(await postResponse.Content.ReadAsStringAsync());
// assert - response
Assert.Equal(HttpStatusCode.OK, postResponse.StatusCode);
Assert.Equal(gameRoom.Id.ToString(), postResponseAsJson["gameRoomId"]);
Assert.Equal(player.Id.ToString(), postResponseAsJson["playerId"]);
Assert.False((bool)postResponseAsJson["isInRoom"]);
// assert - database
Assert.Equal(1, await DbContext.GameRoomPlayers.CountAsync());
Assert.Equal(gameRoomPlayerFromDb.GameRoomId, gameRoom.Id);
Assert.Equal(gameRoomPlayerFromDb.PlayerId, player.Id);
Assert.False(gameRoomPlayerFromDb.IsHost);
Assert.False(gameRoomPlayerFromDb.IsBanned);
Assert.False(gameRoomPlayerFromDb.IsInRoom); // player IS NOT in the room anymore -- he has just left!
}
public async Task TestPlayerShouldJoinRoomWithoutBeingHost(string url)
{
// arrange
var testingScenarioBuilder = new TestingScenarioBuilder(DbContext);
var(rooms, players) = await testingScenarioBuilder.BuildScenarioWithThreeRoomsAndThreePlayers(); // deconstruction
var gameRoomOne = rooms[0];
var playerOne = players[0];
var postData = JsonConvert.SerializeObject(new
{
PlayerId = playerOne.Id
});
var payload = new StringContent(postData, Encoding.UTF8, "application/json");
// act
var gameRoomUrl = url + $"/{gameRoomOne.Id}/join";
var postResponse = await Client.PostAsync(gameRoomUrl, payload);
// assert
var gameRoomPlayer = await DbContext.GameRoomPlayers.FirstAsync();
var postResponseAsJson = JObject.Parse(await postResponse.Content.ReadAsStringAsync());
// assert - response
Assert.Equal(HttpStatusCode.OK, postResponse.StatusCode);
Assert.Equal(gameRoomOne.Id.ToString(), postResponseAsJson["gameRoomId"]);
Assert.Equal(playerOne.Id.ToString(), postResponseAsJson["playerId"]);
Assert.True((bool)postResponseAsJson["isInRoom"]);
// assert - database
Assert.Equal(1, await DbContext.GameRoomPlayers.CountAsync());
Assert.Equal(gameRoomPlayer.GameRoomId, gameRoomOne.Id);
Assert.Equal(gameRoomPlayer.PlayerId, playerOne.Id);
Assert.False(gameRoomPlayer.IsHost);
Assert.False(gameRoomPlayer.IsBanned);
Assert.True(gameRoomPlayer.IsInRoom); // in room, but not host
}
public void TestShouldSerializerConnectionObject()
{
// arrange
var chatRoomId = Guid.NewGuid();
var serverInstanceId1 = Guid.NewGuid();
var serverInstanceId2 = Guid.NewGuid();
var chatRoomConnectionPool = TestingScenarioBuilder
.BuildChatRoomConnectionPoolTwoInstances(chatRoomId, 6, serverInstanceId1, serverInstanceId2);
// act -- serializes a complex object using the app settings
var serializedChatRoomConnectionPoolStr = JsonConvert.SerializeObject(chatRoomConnectionPool);
// assert - guarantees camelCase and not PascalCase on the jsons
var jsonChatRoomConnection = JObject.Parse(serializedChatRoomConnectionPoolStr);
var serverInstances = (JArray)jsonChatRoomConnection["serverInstances"];
Assert.Equal(chatRoomId.ToString(), jsonChatRoomConnection["chatRoomId"]);
Assert.Equal(4, jsonChatRoomConnection["totalActiveConnections"].Value <int>());
Assert.Equal(2, serverInstances.Count);
Assert.Equal(serverInstanceId1.ToString(),
jsonChatRoomConnection["serverInstances"][0]["serverInstanceId"].Value <string>());
Assert.Equal(serverInstanceId2.ToString(),
jsonChatRoomConnection["serverInstances"][1]["serverInstanceId"].Value <string>());
}
