public async Task ClientCannotUseWrongProtolToConnectServer()
{
//Arrange
const string clientAddress = "ws://localhost:54222/ws";
const string serverAddress = "https://localhost:54222";
var config = NetCoreWebSocketHelper.CreateConfigWithUrl(serverAddress);
var clientTestPassed = false;
var serverAction = new Func <HttpContext, Task>(async httpContext =>
{
if (httpContext.Request.Path == "/ws")
{
throw new Exception("Should not be able to create web socket connection successfully");
}
});
var logger = new Logger(LogLevel.Debug, null, (logData, _) =>
{
var msg = logData.Message;
_testOutputHelper.WriteLine(msg);
if ("An exception has occurred while reading an HTTP request/response.".Equals(msg))
{
clientTestPassed = true;
}
});
//Act
using (var server = NetCoreWebSocketHelper.CreateTestServer(config, _testOutputHelper, serverAction, true))
{
await server.StartAsync();
using (var ws = new WebSocketSharp.WebSocket(clientAddress, logger))
{
var testCompleted = false;
ws.OnError += (sender, args) =>
{
testCompleted = true;
Assert.True(args.Exception != null);
};
ws.OnOpen += (sender, args) =>
{
testCompleted = true;
Assert.True(false, "The connection doesn't use wss url should failed!");
};
ws.Connect();
SpinWait.SpinUntil(() => testCompleted, new TimeSpan(0, 0, 5));
}
}
Assert.True(clientTestPassed);
}
public async Task ClientCanSendModifiedTextWhenReceivedFromServer()
{
//Arrange
const string clientAddress = "wss://localhost:54221/ws";
const string serverAddress = "https://localhost:54221";
var config = NetCoreWebSocketHelper.CreateConfigWithUrl(serverAddress);
const string textData = "Hello World";
bool serverTestPassed = false;
bool clientTestPassed;
var serverAction = new Func <HttpContext, Task>(async httpContext =>
{
if (httpContext.Request.Path == "/ws")
{
Assert.True(httpContext.WebSockets.IsWebSocketRequest);
var webSocket = await httpContext.WebSockets.AcceptWebSocketAsync();
var serverBuffer = new byte[1024 * 4];
await webSocket.SendAsync(new ArraySegment <byte>(Encoding.UTF8.GetBytes(textData)),
WebSocketMessageType.Text, true, CancellationToken.None);
var receiveResult =
await webSocket.ReceiveAsync(new ArraySegment <byte>(serverBuffer), CancellationToken.None);
Assert.True(receiveResult.EndOfMessage);
Assert.Equal(WebSocketMessageType.Text, receiveResult.MessageType);
var serverRecv = $"{textData} from Https client";
Assert.Equal(serverRecv, DataHelper.GetReadableString(serverBuffer));
while (!receiveResult.CloseStatus.HasValue)
{
receiveResult = await webSocket.ReceiveAsync(new ArraySegment <byte>(serverBuffer),
CancellationToken.None);
}
await webSocket.CloseAsync(receiveResult.CloseStatus.Value, receiveResult.CloseStatusDescription,
CancellationToken.None);
serverTestPassed = true;
}
});
var logger = new Logger(LogLevel.Debug, null, (logData, _) =>
{
_testOutputHelper.WriteLine(logData.Message);
});
//Act & Assert
using (var server = NetCoreWebSocketHelper.CreateTestServer(config, _testOutputHelper, serverAction, true))
{
await server.StartAsync();
using (var ws = new WebSocketSharp.WebSocket(clientAddress, logger))
{
var hasComplete = false;
ws.OnMessage += (sender, args) =>
{
Assert.True(args.IsText, "websocket should be text mode");
var data = args.Data;
Assert.Equal(textData, data);
var clientSend = $"{data} from Https client";
(sender as WebSocketSharp.WebSocket)?.Send(clientSend);
hasComplete = true;
};
ws.Connect();
SpinWait.SpinUntil(() => hasComplete, new TimeSpan(0, 0, 5));
Assert.True(hasComplete, "client timeout");
ws.Close();
clientTestPassed = true;
}
}
Assert.True(serverTestPassed);
Assert.True(clientTestPassed);
}
public async Task TestHttp302Redirect()
{
var originData = Encoding.UTF8.GetBytes("Hello World");
const string serverOrigin = "localhost:54399";
string serverOriginAddress = $"http://{serverOrigin}";
const string serverReal = "localhost:54400";
string serverRealAddress = $"http://{serverReal}";
string clientOriginAddress = $"ws://{serverOrigin}/ws";
string clientRealAddress = $"ws://{serverReal}/ws_new";
var serverTestComplte = false;
var configForOrigin = NetCoreWebSocketHelper.CreateConfigWithUrl(serverOriginAddress);
var configForReal = NetCoreWebSocketHelper.CreateConfigWithUrl(serverRealAddress);
var originServerAction = new Func <HttpContext, Task>(async context =>
{
if (context.Request.Path == "/ws")
{
Assert.True(context.WebSockets.IsWebSocketRequest);
context.Response.Redirect(clientRealAddress);
}
});
var realServerAction = new Func <HttpContext, Task>(async context =>
{
if (context.Request.Path == "/ws_new")
{
Assert.True(context.WebSockets.IsWebSocketRequest);
var webSocket = await context.WebSockets.AcceptWebSocketAsync().OrTimeout();
var serverBuffer = new byte[originData.Length];
var receiveResult =
await webSocket.ReceiveAsync(new ArraySegment <byte>(serverBuffer), CancellationToken.None)
.OrTimeout();
while (!receiveResult.CloseStatus.HasValue)
{
//Assert
Assert.True(receiveResult.EndOfMessage);
Assert.Equal(originData.Length, receiveResult.Count);
Assert.Equal(WebSocketMessageType.Binary, receiveResult.MessageType);
Assert.Equal(originData, serverBuffer);
receiveResult =
await webSocket.ReceiveAsync(new ArraySegment <byte>(serverBuffer),
CancellationToken.None).OrTimeout();
}
await webSocket.CloseAsync(receiveResult.CloseStatus.Value, receiveResult.CloseStatusDescription,
CancellationToken.None).OrTimeout();
serverTestComplte = true;
}
});
//Act
using (IWebHost originServer =
NetCoreWebSocketHelper.CreateTestServer(configForOrigin, _testOutputHelper, originServerAction),
realServer =
NetCoreWebSocketHelper.CreateTestServer(configForReal, _testOutputHelper, realServerAction))
{
await originServer.StartAsync().OrTimeout();
await realServer.StartAsync().OrTimeout();
using (var ws = new WebSocketSharp.WebSocket(clientOriginAddress, CreateWebSocketLogger()))
{
ws.EnableRedirection = true;
ws.Connect();
Assert.Equal(clientRealAddress, ws.Url.OriginalString);
ws.Send(originData);
ws.Close();
}
}
Assert.True(serverTestComplte, "server assertion fail");
}
