public void GeneralPropertyCheck()
{
var fakeSocket = new FakeWebSocket(
WebSocketState.Aborted,
WebSocketCloseStatus.EndpointUnavailable,
"close desc",
"sub proto");
var context = new DefaultHttpContext();
var provider = new Mock <IServiceProvider>().Object;
var user = new ClaimsPrincipal();
context.RequestServices = provider;
context.User = user;
var array = new ArraySegment <byte>(new byte[500]);
var client = new WebSocketClientConnection(fakeSocket, context);
Assert.AreEqual(ClientConnectionState.Aborted, client.State);
Assert.AreEqual(ClientConnectionCloseStatus.EndpointUnavailable, client.CloseStatus.Value);
Assert.AreEqual("close desc", client.CloseStatusDescription);
Assert.AreEqual(provider, client.ServiceProvider);
Assert.AreEqual(user, client.User);
}
public async Task SendItems()
{
var fakeSocket = new FakeWebSocket();
var socketConnection = new WebSocketConnection(fakeSocket);
await socketConnection.SendAsync("test", CancellationToken.None);
Assert.IsNotNull(fakeSocket.FakeSendItems.LastOrDefault());
Assert.AreEqual("test", fakeSocket.FakeSendItems.LastOrDefault());
}
public async Task SuccessfulCLose_HasSentToSocket()
{
var fakeSocket = new FakeWebSocket();
var array = new ArraySegment <byte>(new byte[500]);
var client = new WebSocketClientConnection(fakeSocket, new DefaultHttpContext());
await client.CloseAsync(ClientConnectionCloseStatus.Empty, string.Empty, default);
Assert.AreEqual(1, fakeSocket.TotalCloseCalls);
}
public async Task SuccessfulSend_HasSentToSocket()
{
var fakeSocket = new FakeWebSocket();
var array = new ArraySegment <byte>(new byte[500]);
var client = new WebSocketClientConnection(fakeSocket, new DefaultHttpContext());
await client.SendAsync(array, ClientMessageType.Binary, true, default);
Assert.AreEqual(1, fakeSocket.TotalCallsToSend);
}
public async Task SuccessfulRecieve_HasRecievedFromSocket()
{
var fakeSocket = new FakeWebSocket();
var array = new ArraySegment <byte>(new byte[500]);
var client = new WebSocketClientConnection(fakeSocket, new DefaultHttpContext());
var result = await client.ReceiveAsync(array, default);
Assert.AreEqual(1, fakeSocket.TotalCallsToReceive);
}
public async Task SendToAllAsync_Model_success()
{
var service = new WebSocketConnectionsService(new FakeIWebLogger());
var fakeSocket = new FakeWebSocket();
service.AddConnection(new WebSocketConnection(fakeSocket));
await service.SendToAllAsync(new ApiNotificationResponseModel <string>("test"), CancellationToken.None);
Assert.AreEqual("{\"data\":\"test\",\"type\":\"Unknown\"}", fakeSocket.FakeSendItems.LastOrDefault());
}
public async Task SendToAllAsync_success()
{
var service = new WebSocketConnectionsService(new FakeIWebLogger());
var fakeSocket = new FakeWebSocket();
service.AddConnection(new WebSocketConnection(fakeSocket));
await service.SendToAllAsync("test", CancellationToken.None);
Assert.IsTrue(fakeSocket.FakeSendItems.LastOrDefault().StartsWith("test"));
}
public async Task SendToAllAsync_ExceptionDueNoContent()
{
var logger = new FakeIWebLogger();
var service = new WebSocketConnectionsService(logger);
var fakeSocket = new FakeWebSocket();
service.AddConnection(new WebSocketConnection(fakeSocket));
await service.SendToAllAsync(null as string, CancellationToken.None);
Assert.AreEqual(1, logger.TrackedInformation.Count);
}
public async Task SendWritesToWebSocketOutputStream()
{
var fakeOutputStream = new FakeOutputStream();
var fakeWebSocket = new FakeWebSocket {
OutputStream = fakeOutputStream
};
await WebSocketTransport.Send(fakeWebSocket, "42.42");
var writeAsyncInvocations = fakeOutputStream.GetInvocations("WriteAsync").ToArray();
Assert.Equal(1, writeAsyncInvocations.Length);
Assert.Equal(5u, ((IBuffer)writeAsyncInvocations[0][0]).Length);
}
public void SetRequestHeadersSetsHeadersOnWebSockets()
{
var webSocket = new FakeWebSocket();
var webSocketRequest = new WebSocketRequest(webSocket);
webSocketRequest.SetRequestHeaders(
new Dictionary<string, string> { { "Header1", "Value1" }, { "Header2", "Value2" } });
webSocket.Verify(
"SetRequestHeader",
new List<object[]>
{
new object[] {"Header1", "Value1"},
new object[] {"Header2", "Value2"},
});
}
public async Task ReceiveMessagesUntilCloseAsync_And_Exit()
{
var fakeSocket = new FakeWebSocket();
var socketConnection = new WebSocketConnection(fakeSocket);
var message = "";
socketConnection.ReceiveText += (sender, s) =>
{
message = s;
};
// when this unit test keeps hanging the end signal has not passed correctly
await socketConnection.ReceiveMessagesUntilCloseAsync();
Assert.IsTrue(message.StartsWith("message"));
}
public async Task Receive_ThrowsGeneralException_ReturnsConnectionFailureResult()
{
var fakeSocket = new FakeWebSocket();
var exceptionThrown = new Exception("total failure");
fakeSocket.ThrowExceptionOnReceieve(exceptionThrown);
var array = new ArraySegment <byte>(new byte[500]);
var client = new WebSocketClientConnection(fakeSocket, new DefaultHttpContext());
var result = await client.ReceiveAsync(array, default);
var failureResult = result as ClientConnectionFailureResult;
Assert.IsNotNull(failureResult);
Assert.AreEqual(exceptionThrown, failureResult.Exception);
}
public void SetRequestHeadersSetsHeadersOnWebSockets()
{
var webSocket = new FakeWebSocket();
var webSocketRequest = new WebSocketRequest(webSocket);
webSocketRequest.SetRequestHeaders(
new Dictionary <string, string> {
{ "Header1", "Value1" }, { "Header2", "Value2" }
});
webSocket.Verify(
"SetRequestHeader",
new List <object[]>
{
new object[] { "Header1", "Value1" },
new object[] { "Header2", "Value2" },
});
}
public void BlockOnClientExceptionTest()
{
try
{
var pubKey = (RawPubKey)KeyPair.Random();
var webSocket = new FakeWebSocket();
var clientConnection = new AlphaWebSocketConnection(webSocket, "127.0.0.1")
{
ClientPubKey = pubKey
};
for (var i = 0; i < 1000; i++)
{
Global.ExtensionsManager.HandleMessageFailed(clientConnection, null, new ForbiddenException());
}
Assert.Fail("Client wasn't block after 1000 connections.");
}
catch (ConnectionCloseException exc)
{
Assert.AreEqual(WebSocketCloseStatus.PolicyViolation, exc.Status);
}
}
public void TooManyConnectionsFromDifferentIpTest()
{
try
{
var pubKey = (RawPubKey)KeyPair.Random();
for (var i = 0; i < 1000; i++)
{
var ip = "127.0.0." + i;
var webSocket = new FakeWebSocket();
Global.ExtensionsManager.BeforeNewConnection(webSocket, ip);
var clientConnection = new AlphaWebSocketConnection(webSocket, ip)
{
ClientPubKey = pubKey
};
Global.ExtensionsManager.ConnectionValidated(clientConnection);
}
Assert.Fail("Client wasn't block after 1000 connections.");
}
catch (ConnectionCloseException exc)
{
Assert.AreEqual(WebSocketCloseStatus.PolicyViolation, exc.Status);
}
}
public async Task SendWritesToWebSocketOutputStream()
{
var fakeOutputStream = new FakeOutputStream();
var fakeWebSocket = new FakeWebSocket { OutputStream = fakeOutputStream };
await WebSocketTransport.Send(fakeWebSocket, "42.42");
var writeAsyncInvocations = fakeOutputStream.GetInvocations("WriteAsync").ToArray();
Assert.Equal(1, writeAsyncInvocations.Length);
Assert.Equal(5u, ((IBuffer)writeAsyncInvocations[0][0]).Length);
}
