huahaofeng
/
aspnetcore
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

#22 - Update client tests to use Kestrel so they can run on Win7.

This commit is contained in:
Chris Ross 2014-12-15 14:18:58 -08:00
parent 2cdce758b1
commit 04fbb076b2
3 changed files with 370 additions and 426 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
test/Microsoft.AspNet.WebSockets.Client.Test/KestrelWebSocketHelpers.cs Normal file
View File

@ -0,0 +1,64 @@
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.Threading.Tasks;
using Microsoft.AspNet.Builder;
using Microsoft.AspNet.Hosting;
using Microsoft.AspNet.Http;
using Microsoft.Framework.ConfigurationModel;
using Microsoft.Framework.DependencyInjection;
using Microsoft.Framework.DependencyInjection.Fallback;
using Microsoft.Framework.Runtime.Infrastructure;
namespace Microsoft.AspNet.WebSockets.Client.Test
{
public class KestrelWebSocketHelpers
{
public static IDisposable CreateServer(Func<HttpContext, Task> app)
{
Action<IApplicationBuilder> startup = builder =>
{
builder.Use(async (ct, next) =>
{
try
{
// Kestrel does not return proper error responses:
// https://github.com/aspnet/KestrelHttpServer/issues/43
await next();
}
catch (Exception ex)
{
if (ct.Response.HeadersSent)
{
throw;
}
ct.Response.StatusCode = 500;
ct.Response.Headers.Clear();
await ct.Response.WriteAsync(ex.ToString());
}
});
builder.UseWebSockets();
builder.Run(c => app(c));
};
var config = new Configuration();
config.Add(new MemoryConfigurationSource());
config.Set("server.urls", "http://localhost:54321");
var services = HostingServices.Create(CallContextServiceLocator.Locator?.ServiceProvider, config)
.BuildServiceProvider();
var context = new HostingContext()
{
Services = services,
Configuration = config,
ServerName = "Kestrel",
ApplicationStartup = startup,
};
var engine = services.GetRequiredService<IHostingEngine>();
return engine.Start(context);
}
}
}

728
test/Microsoft.AspNet.WebSockets.Client.Test/WebSocketClientTests.cs
View File

@ -2,7 +2,6 @@
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System; using System;
using System.Net;
using System.Net.WebSockets; using System.Net.WebSockets;
using System.Text; using System.Text;
using System.Threading; using System.Threading;
@ -13,235 +12,180 @@ namespace Microsoft.AspNet.WebSockets.Client.Test
{ {
public class WebSocketClientTests public class WebSocketClientTests
{ {
private static string ClientAddress = "ws://localhost:8080/"; private static string ClientAddress = "ws://localhost:54321/";
private static string ServerAddress = "http://localhost:8080/";
[Fact] [Fact]
public async Task Connect_Success() public async Task Connect_Success()
{ {
using (HttpListener listener = new HttpListener()) using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
listener.Prefixes.Add(ServerAddress); Assert.True(context.IsWebSocketRequest);
listener.Start(); var webSocket = await context.AcceptWebSocketAsync();
Task<HttpListenerContext> serverAccept = listener.GetContextAsync(); }))
{
WebSocketClient client = new WebSocketClient(); var client = new WebSocketClient();
Task<WebSocket> clientConnect = client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); using (var clientSocket = await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None))
{
HttpListenerContext serverContext = await serverAccept; }
Assert.True(serverContext.Request.IsWebSocketRequest);
HttpListenerWebSocketContext serverWebSocketContext = await serverContext.AcceptWebSocketAsync(null);
WebSocket clientSocket = await clientConnect;
clientSocket.Dispose();
} }
} }
[Fact] [Fact]
public async Task NegotiateSubProtocol_Success() public async Task NegotiateSubProtocol_Success()
{ {
using (HttpListener listener = new HttpListener()) using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
listener.Prefixes.Add(ServerAddress); Assert.True(context.IsWebSocketRequest);
listener.Start(); Assert.Equal("alpha, bravo, charlie", context.Request.Headers["Sec-WebSocket-Protocol"]);
Task<HttpListenerContext> serverAccept = listener.GetContextAsync(); var webSocket = await context.AcceptWebSocketAsync("Bravo");
}))
WebSocketClient client = new WebSocketClient(); {
var client = new WebSocketClient();
client.SubProtocols.Add("alpha"); client.SubProtocols.Add("alpha");
client.SubProtocols.Add("bravo"); client.SubProtocols.Add("bravo");
client.SubProtocols.Add("charlie"); client.SubProtocols.Add("charlie");
Task<WebSocket> clientConnect = client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); using (var clientSocket = await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None))
{
HttpListenerContext serverContext = await serverAccept; Assert.Equal("Bravo", clientSocket.SubProtocol);
Assert.True(serverContext.Request.IsWebSocketRequest); }
Assert.Equal("alpha, bravo, charlie", serverContext.Request.Headers["Sec-WebSocket-Protocol"]);
HttpListenerWebSocketContext serverWebSocketContext = await serverContext.AcceptWebSocketAsync("Bravo");
WebSocket clientSocket = await clientConnect;
Assert.Equal("Bravo", clientSocket.SubProtocol);
clientSocket.Dispose();
} }
} }
[Fact] [Fact]
public async Task SendEmptyData_Success() public async Task SendEmptyData_Success()
{ {
using (HttpListener listener = new HttpListener()) using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
listener.Prefixes.Add(ServerAddress); Assert.True(context.IsWebSocketRequest);
listener.Start(); var webSocket = await context.AcceptWebSocketAsync();
Task<HttpListenerContext> serverAccept = listener.GetContextAsync();
WebSocketClient client = new WebSocketClient(); var serverBuffer = new byte[0];
Task<WebSocket> clientConnect = client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
HttpListenerContext serverContext = await serverAccept;
Assert.True(serverContext.Request.IsWebSocketRequest);
HttpListenerWebSocketContext serverWebSocketContext = await serverContext.AcceptWebSocketAsync(null);
WebSocket clientSocket = await clientConnect;
byte[] orriginalData = new byte[0];
await clientSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
byte[] serverBuffer = new byte[orriginalData.Length];
WebSocketReceiveResult result = await serverWebSocketContext.WebSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
Assert.True(result.EndOfMessage); Assert.True(result.EndOfMessage);
Assert.Equal(orriginalData.Length, result.Count); Assert.Equal(0, result.Count);
Assert.Equal(WebSocketMessageType.Binary, result.MessageType); Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
Assert.Equal(orriginalData, serverBuffer); }))
{
clientSocket.Dispose(); var client = new WebSocketClient();
using (var clientSocket = await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None))
{
var orriginalData = new byte[0];
await clientSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
}
} }
} }
[Fact] [Fact]
public async Task SendShortData_Success() public async Task SendShortData_Success()
{ {
using (HttpListener listener = new HttpListener()) var orriginalData = Encoding.UTF8.GetBytes("Hello World");
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
listener.Prefixes.Add(ServerAddress); Assert.True(context.IsWebSocketRequest);
listener.Start(); var webSocket = await context.AcceptWebSocketAsync();
Task<HttpListenerContext> serverAccept = listener.GetContextAsync();
WebSocketClient client = new WebSocketClient(); var serverBuffer = new byte[orriginalData.Length];
Task<WebSocket> clientConnect = client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
HttpListenerContext serverContext = await serverAccept;
Assert.True(serverContext.Request.IsWebSocketRequest);
HttpListenerWebSocketContext serverWebSocketContext = await serverContext.AcceptWebSocketAsync(null);
WebSocket clientSocket = await clientConnect;
byte[] orriginalData = Encoding.UTF8.GetBytes("Hello World");
await clientSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
byte[] serverBuffer = new byte[orriginalData.Length];
WebSocketReceiveResult result = await serverWebSocketContext.WebSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
Assert.True(result.EndOfMessage); Assert.True(result.EndOfMessage);
Assert.Equal(orriginalData.Length, result.Count); Assert.Equal(orriginalData.Length, result.Count);
Assert.Equal(WebSocketMessageType.Binary, result.MessageType); Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
Assert.Equal(orriginalData, serverBuffer); Assert.Equal(orriginalData, serverBuffer);
}))
clientSocket.Dispose(); {
var client = new WebSocketClient();
using (var clientSocket = await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None))
{
await clientSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
}
} }
} }
[Fact] [Fact]
public async Task SendMediumData_Success() public async Task SendMediumData_Success()
{ {
using (HttpListener listener = new HttpListener()) var orriginalData = Encoding.UTF8.GetBytes(new string('a', 130));
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
listener.Prefixes.Add(ServerAddress); Assert.True(context.IsWebSocketRequest);
listener.Start(); var webSocket = await context.AcceptWebSocketAsync();
Task<HttpListenerContext> serverAccept = listener.GetContextAsync();
WebSocketClient client = new WebSocketClient(); var serverBuffer = new byte[orriginalData.Length];
Task<WebSocket> clientConnect = client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
HttpListenerContext serverContext = await serverAccept;
Assert.True(serverContext.Request.IsWebSocketRequest);
HttpListenerWebSocketContext serverWebSocketContext = await serverContext.AcceptWebSocketAsync(null);
WebSocket clientSocket = await clientConnect;
byte[] orriginalData = Encoding.UTF8.GetBytes(new string('a', 130));
await clientSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Text, true, CancellationToken.None);
byte[] serverBuffer = new byte[orriginalData.Length];
WebSocketReceiveResult result = await serverWebSocketContext.WebSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
Assert.True(result.EndOfMessage); Assert.True(result.EndOfMessage);
Assert.Equal(orriginalData.Length, result.Count); Assert.Equal(orriginalData.Length, result.Count);
Assert.Equal(WebSocketMessageType.Text, result.MessageType); Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
Assert.Equal(orriginalData, serverBuffer); Assert.Equal(orriginalData, serverBuffer);
}))
clientSocket.Dispose(); {
var client = new WebSocketClient();
using (var clientSocket = await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None))
{
await clientSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
}
} }
} }
[Fact] [Fact]
public async Task SendLongData_Success() public async Task SendLongData_Success()
{ {
using (HttpListener listener = new HttpListener()) var orriginalData = Encoding.UTF8.GetBytes(new string('a', 0x1FFFF));
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
listener.Prefixes.Add(ServerAddress); Assert.True(context.IsWebSocketRequest);
listener.Start(); var webSocket = await context.AcceptWebSocketAsync();
Task<HttpListenerContext> serverAccept = listener.GetContextAsync();
WebSocketClient client = new WebSocketClient(); var serverBuffer = new byte[orriginalData.Length];
Task<WebSocket> clientConnect = client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
HttpListenerContext serverContext = await serverAccept;
Assert.True(serverContext.Request.IsWebSocketRequest);
HttpListenerWebSocketContext serverWebSocketContext = await serverContext.AcceptWebSocketAsync(null, 0xFFFF, TimeSpan.FromMinutes(100));
WebSocket clientSocket = await clientConnect;
byte[] orriginalData = Encoding.UTF8.GetBytes(new string('a', 0x1FFFF));
await clientSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Text, true, CancellationToken.None);
byte[] serverBuffer = new byte[orriginalData.Length];
WebSocketReceiveResult result = await serverWebSocketContext.WebSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
int intermediateCount = result.Count; int intermediateCount = result.Count;
Assert.False(result.EndOfMessage); Assert.False(result.EndOfMessage);
Assert.Equal(WebSocketMessageType.Text, result.MessageType); Assert.Equal(WebSocketMessageType.Text, result.MessageType);
result = await serverWebSocketContext.WebSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer, intermediateCount, orriginalData.Length - intermediateCount), CancellationToken.None); result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer, intermediateCount, orriginalData.Length - intermediateCount), CancellationToken.None);
intermediateCount += result.Count; intermediateCount += result.Count;
Assert.False(result.EndOfMessage); Assert.False(result.EndOfMessage);
Assert.Equal(WebSocketMessageType.Text, result.MessageType); Assert.Equal(WebSocketMessageType.Text, result.MessageType);
result = await serverWebSocketContext.WebSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer, intermediateCount, orriginalData.Length - intermediateCount), CancellationToken.None); result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer, intermediateCount, orriginalData.Length - intermediateCount), CancellationToken.None);
intermediateCount += result.Count; intermediateCount += result.Count;
Assert.True(result.EndOfMessage); Assert.True(result.EndOfMessage);
Assert.Equal(orriginalData.Length, intermediateCount); Assert.Equal(orriginalData.Length, intermediateCount);
Assert.Equal(WebSocketMessageType.Text, result.MessageType); Assert.Equal(WebSocketMessageType.Text, result.MessageType);
Assert.Equal(orriginalData, serverBuffer); Assert.Equal(orriginalData, serverBuffer);
}))
clientSocket.Dispose(); {
var client = new WebSocketClient();
using (var clientSocket = await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None))
{
await clientSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
}
} }
} }
[Fact] [Fact]
public async Task SendFragmentedData_Success() public async Task SendFragmentedData_Success()
{ {
using (HttpListener listener = new HttpListener()) var orriginalData = Encoding.UTF8.GetBytes("Hello World");
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
listener.Prefixes.Add(ServerAddress); Assert.True(context.IsWebSocketRequest);
listener.Start(); var webSocket = await context.AcceptWebSocketAsync();
Task<HttpListenerContext> serverAccept = listener.GetContextAsync();
WebSocketClient client = new WebSocketClient(); var serverBuffer = new byte[orriginalData.Length];
Task<WebSocket> clientConnect = client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
HttpListenerContext serverContext = await serverAccept;
Assert.True(serverContext.Request.IsWebSocketRequest);
HttpListenerWebSocketContext serverWebSocketContext = await serverContext.AcceptWebSocketAsync(null);
WebSocket serverSocket = serverWebSocketContext.WebSocket;
WebSocket clientSocket = await clientConnect;
byte[] orriginalData = Encoding.UTF8.GetBytes("Hello World");
await clientSocket.SendAsync(new ArraySegment<byte>(orriginalData, 0, 2), WebSocketMessageType.Binary, false, CancellationToken.None);
await clientSocket.SendAsync(new ArraySegment<byte>(orriginalData, 2, 2), WebSocketMessageType.Binary, false, CancellationToken.None);
await clientSocket.SendAsync(new ArraySegment<byte>(orriginalData, 4, 7), WebSocketMessageType.Binary, true, CancellationToken.None);
byte[] serverBuffer = new byte[orriginalData.Length];
WebSocketReceiveResult result = await serverSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
Assert.False(result.EndOfMessage); Assert.False(result.EndOfMessage);
Assert.Equal(2, result.Count); Assert.Equal(2, result.Count);
int totalReceived = result.Count; int totalReceived = result.Count;
Assert.Equal(WebSocketMessageType.Binary, result.MessageType); Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
result = await serverSocket.ReceiveAsync( result = await webSocket.ReceiveAsync(
new ArraySegment<byte>(serverBuffer, totalReceived, serverBuffer.Length - totalReceived), CancellationToken.None); new ArraySegment<byte>(serverBuffer, totalReceived, serverBuffer.Length - totalReceived), CancellationToken.None);
Assert.False(result.EndOfMessage); Assert.False(result.EndOfMessage);
Assert.Equal(2, result.Count); Assert.Equal(2, result.Count);
totalReceived += result.Count; totalReceived += result.Count;
Assert.Equal(WebSocketMessageType.Binary, result.MessageType); Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
result = await serverSocket.ReceiveAsync( result = await webSocket.ReceiveAsync(
new ArraySegment<byte>(serverBuffer, totalReceived, serverBuffer.Length - totalReceived), CancellationToken.None); new ArraySegment<byte>(serverBuffer, totalReceived, serverBuffer.Length - totalReceived), CancellationToken.None);
Assert.True(result.EndOfMessage); Assert.True(result.EndOfMessage);
Assert.Equal(7, result.Count); Assert.Equal(7, result.Count);
@ -249,414 +193,348 @@ namespace Microsoft.AspNet.WebSockets.Client.Test
Assert.Equal(WebSocketMessageType.Binary, result.MessageType); Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
Assert.Equal(orriginalData, serverBuffer); Assert.Equal(orriginalData, serverBuffer);
}))
clientSocket.Dispose(); {
var client = new WebSocketClient();
using (var clientSocket = await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None))
{
await clientSocket.SendAsync(new ArraySegment<byte>(orriginalData, 0, 2), WebSocketMessageType.Binary, false, CancellationToken.None);
await clientSocket.SendAsync(new ArraySegment<byte>(orriginalData, 2, 2), WebSocketMessageType.Binary, false, CancellationToken.None);
await clientSocket.SendAsync(new ArraySegment<byte>(orriginalData, 4, 7), WebSocketMessageType.Binary, true, CancellationToken.None);
}
} }
} }
[Fact] [Fact]
public async Task ReceiveEmptyData_Success() public async Task ReceiveEmptyData_Success()
{ {
using (HttpListener listener = new HttpListener()) var orriginalData = Encoding.UTF8.GetBytes("Hello World");
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
listener.Prefixes.Add(ServerAddress); Assert.True(context.IsWebSocketRequest);
listener.Start(); var webSocket = await context.AcceptWebSocketAsync();
Task<HttpListenerContext> serverAccept = listener.GetContextAsync();
WebSocketClient client = new WebSocketClient(); await webSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
Task<WebSocket> clientConnect = client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); }))
{
HttpListenerContext serverContext = await serverAccept; var client = new WebSocketClient();
Assert.True(serverContext.Request.IsWebSocketRequest); using (var clientSocket = await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None))
HttpListenerWebSocketContext serverWebSocketContext = await serverContext.AcceptWebSocketAsync(null); {
var clientBuffer = new byte[0];
WebSocket clientSocket = await clientConnect; var result = await clientSocket.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None);
Assert.False(result.EndOfMessage);
byte[] orriginalData = Encoding.UTF8.GetBytes("Hello World"); Assert.Equal(0, result.Count);
await serverWebSocketContext.WebSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None); Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
}
byte[] clientBuffer = new byte[0];
WebSocketReceiveResult result = await clientSocket.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None);
Assert.False(result.EndOfMessage);
Assert.Equal(0, result.Count);
Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
clientSocket.Dispose();
} }
} }
[Fact] [Fact]
public async Task ReceiveShortData_Success() public async Task ReceiveShortData_Success()
{ {
using (HttpListener listener = new HttpListener()) var orriginalData = Encoding.UTF8.GetBytes("Hello World");
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
listener.Prefixes.Add(ServerAddress); Assert.True(context.IsWebSocketRequest);
listener.Start(); var webSocket = await context.AcceptWebSocketAsync();
Task<HttpListenerContext> serverAccept = listener.GetContextAsync();
WebSocketClient client = new WebSocketClient(); await webSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
Task<WebSocket> clientConnect = client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); }))
{
HttpListenerContext serverContext = await serverAccept; var client = new WebSocketClient();
Assert.True(serverContext.Request.IsWebSocketRequest); using (var clientSocket = await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None))
HttpListenerWebSocketContext serverWebSocketContext = await serverContext.AcceptWebSocketAsync(null); {
var clientBuffer = new byte[orriginalData.Length];
WebSocket clientSocket = await clientConnect; var result = await clientSocket.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None);
Assert.True(result.EndOfMessage);
byte[] orriginalData = Encoding.UTF8.GetBytes("Hello World"); Assert.Equal(orriginalData.Length, result.Count);
await serverWebSocketContext.WebSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None); Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
Assert.Equal(orriginalData, clientBuffer);
byte[] clientBuffer = new byte[orriginalData.Length]; }
WebSocketReceiveResult result = await clientSocket.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None);
Assert.True(result.EndOfMessage);
Assert.Equal(orriginalData.Length, result.Count);
Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
Assert.Equal(orriginalData, clientBuffer);
clientSocket.Dispose();
} }
} }
[Fact] [Fact]
public async Task ReceiveMediumData_Success() public async Task ReceiveMediumData_Success()
{ {
using (HttpListener listener = new HttpListener()) var orriginalData = Encoding.UTF8.GetBytes(new string('a', 130));
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
listener.Prefixes.Add(ServerAddress); Assert.True(context.IsWebSocketRequest);
listener.Start(); var webSocket = await context.AcceptWebSocketAsync();
Task<HttpListenerContext> serverAccept = listener.GetContextAsync();
WebSocketClient client = new WebSocketClient(); await webSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
Task<WebSocket> clientConnect = client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); }))
{
HttpListenerContext serverContext = await serverAccept; var client = new WebSocketClient();
Assert.True(serverContext.Request.IsWebSocketRequest); using (var clientSocket = await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None))
HttpListenerWebSocketContext serverWebSocketContext = await serverContext.AcceptWebSocketAsync(null); {
var clientBuffer = new byte[orriginalData.Length];
WebSocket clientSocket = await clientConnect; var result = await clientSocket.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None);
Assert.True(result.EndOfMessage);
byte[] orriginalData = Encoding.UTF8.GetBytes(new string('a', 130)); Assert.Equal(orriginalData.Length, result.Count);
await serverWebSocketContext.WebSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None); Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
Assert.Equal(orriginalData, clientBuffer);
byte[] clientBuffer = new byte[orriginalData.Length]; }
WebSocketReceiveResult result = await clientSocket.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None);
Assert.True(result.EndOfMessage);
Assert.Equal(orriginalData.Length, result.Count);
Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
Assert.Equal(orriginalData, clientBuffer);
clientSocket.Dispose();
} }
} }
[Fact] [Fact]
public async Task ReceiveLongDataInSmallBuffer_Success() public async Task ReceiveLongDataInSmallBuffer_Success()
{ {
using (HttpListener listener = new HttpListener()) var orriginalData = Encoding.UTF8.GetBytes(new string('a', 0x1FFFF));
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
listener.Prefixes.Add(ServerAddress); Assert.True(context.IsWebSocketRequest);
listener.Start(); var webSocket = await context.AcceptWebSocketAsync();
Task<HttpListenerContext> serverAccept = listener.GetContextAsync();
WebSocketClient client = new WebSocketClient(); await webSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
Task<WebSocket> clientConnect = client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); }))
{
HttpListenerContext serverContext = await serverAccept; var client = new WebSocketClient();
Assert.True(serverContext.Request.IsWebSocketRequest); using (var clientSocket = await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None))
HttpListenerWebSocketContext serverWebSocketContext = await serverContext.AcceptWebSocketAsync(null);
WebSocket clientSocket = await clientConnect;
byte[] orriginalData = Encoding.UTF8.GetBytes(new string('a', 0x1FFFF));
await serverWebSocketContext.WebSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
byte[] clientBuffer = new byte[orriginalData.Length];
WebSocketReceiveResult result;
int receivedCount = 0;
do
{ {
result = await clientSocket.ReceiveAsync(new ArraySegment<byte>(clientBuffer, receivedCount, clientBuffer.Length - receivedCount), CancellationToken.None); var clientBuffer = new byte[orriginalData.Length];
receivedCount += result.Count; WebSocketReceiveResult result;
int receivedCount = 0;
do
{
result = await clientSocket.ReceiveAsync(new ArraySegment<byte>(clientBuffer, receivedCount, clientBuffer.Length - receivedCount), CancellationToken.None);
receivedCount += result.Count;
Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
}
while (!result.EndOfMessage);
Assert.Equal(orriginalData.Length, receivedCount);
Assert.Equal(WebSocketMessageType.Binary, result.MessageType); Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
Assert.Equal(orriginalData, clientBuffer);
} }
while (!result.EndOfMessage);
Assert.Equal(orriginalData.Length, receivedCount);
Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
Assert.Equal(orriginalData, clientBuffer);
clientSocket.Dispose();
} }
} }
[Fact] [Fact]
public async Task ReceiveLongDataInLargeBuffer_Success() public async Task ReceiveLongDataInLargeBuffer_Success()
{ {
using (HttpListener listener = new HttpListener()) var orriginalData = Encoding.UTF8.GetBytes(new string('a', 0x1FFFF));
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
listener.Prefixes.Add(ServerAddress); Assert.True(context.IsWebSocketRequest);
listener.Start(); var webSocket = await context.AcceptWebSocketAsync();
Task<HttpListenerContext> serverAccept = listener.GetContextAsync();
WebSocketClient client = new WebSocketClient() { ReceiveBufferSize = 0xFFFFFF }; await webSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
Task<WebSocket> clientConnect = client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); }))
{
HttpListenerContext serverContext = await serverAccept; var client = new WebSocketClient() { ReceiveBufferSize = 0xFFFFFF };
Assert.True(serverContext.Request.IsWebSocketRequest); using (var clientSocket = await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None))
HttpListenerWebSocketContext serverWebSocketContext = await serverContext.AcceptWebSocketAsync(null); {
var clientBuffer = new byte[orriginalData.Length];
WebSocket clientSocket = await clientConnect; var result = await clientSocket.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None);
Assert.True(result.EndOfMessage);
byte[] orriginalData = Encoding.UTF8.GetBytes(new string('a', 0x1FFFF)); Assert.Equal(orriginalData.Length, result.Count);
await serverWebSocketContext.WebSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None); Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
Assert.Equal(orriginalData, clientBuffer);
byte[] clientBuffer = new byte[orriginalData.Length]; }
WebSocketReceiveResult result = await clientSocket.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None);
Assert.True(result.EndOfMessage);
Assert.Equal(orriginalData.Length, result.Count);
Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
Assert.Equal(orriginalData, clientBuffer);
clientSocket.Dispose();
} }
} }
[Fact] [Fact]
public async Task ReceiveFragmentedData_Success() public async Task ReceiveFragmentedData_Success()
{ {
using (HttpListener listener = new HttpListener()) var orriginalData = Encoding.UTF8.GetBytes("Hello World");
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
listener.Prefixes.Add(ServerAddress); Assert.True(context.IsWebSocketRequest);
listener.Start(); var webSocket = await context.AcceptWebSocketAsync();
Task<HttpListenerContext> serverAccept = listener.GetContextAsync();
WebSocketClient client = new WebSocketClient(); await webSocket.SendAsync(new ArraySegment<byte>(orriginalData, 0, 2), WebSocketMessageType.Binary, false, CancellationToken.None);
Task<WebSocket> clientConnect = client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); await webSocket.SendAsync(new ArraySegment<byte>(orriginalData, 2, 2), WebSocketMessageType.Binary, false, CancellationToken.None);
await webSocket.SendAsync(new ArraySegment<byte>(orriginalData, 4, 7), WebSocketMessageType.Binary, true, CancellationToken.None);
}))
{
var client = new WebSocketClient();
using (var clientSocket = await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None))
{
var clientBuffer = new byte[orriginalData.Length];
var result = await clientSocket.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None);
Assert.False(result.EndOfMessage);
Assert.Equal(2, result.Count);
int totalReceived = result.Count;
Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
HttpListenerContext serverContext = await serverAccept; result = await clientSocket.ReceiveAsync(
Assert.True(serverContext.Request.IsWebSocketRequest); new ArraySegment<byte>(clientBuffer, totalReceived, clientBuffer.Length - totalReceived), CancellationToken.None);
HttpListenerWebSocketContext serverWebSocketContext = await serverContext.AcceptWebSocketAsync(null); Assert.False(result.EndOfMessage);
WebSocket serverSocket = serverWebSocketContext.WebSocket; Assert.Equal(2, result.Count);
totalReceived += result.Count;
Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
WebSocket clientSocket = await clientConnect; result = await clientSocket.ReceiveAsync(
new ArraySegment<byte>(clientBuffer, totalReceived, clientBuffer.Length - totalReceived), CancellationToken.None);
Assert.True(result.EndOfMessage);
Assert.Equal(7, result.Count);
totalReceived += result.Count;
Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
byte[] orriginalData = Encoding.UTF8.GetBytes("Hello World"); Assert.Equal(orriginalData, clientBuffer);
await serverSocket.SendAsync(new ArraySegment<byte>(orriginalData, 0, 2), WebSocketMessageType.Binary, false, CancellationToken.None); }
await serverSocket.SendAsync(new ArraySegment<byte>(orriginalData, 2, 2), WebSocketMessageType.Binary, false, CancellationToken.None);
await serverSocket.SendAsync(new ArraySegment<byte>(orriginalData, 4, 7), WebSocketMessageType.Binary, true, CancellationToken.None);
byte[] serverBuffer = new byte[orriginalData.Length];
WebSocketReceiveResult result = await clientSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
Assert.False(result.EndOfMessage);
Assert.Equal(2, result.Count);
int totalReceived = result.Count;
Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
result = await clientSocket.ReceiveAsync(
new ArraySegment<byte>(serverBuffer, totalReceived, serverBuffer.Length - totalReceived), CancellationToken.None);
Assert.False(result.EndOfMessage);
Assert.Equal(2, result.Count);
totalReceived += result.Count;
Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
result = await clientSocket.ReceiveAsync(
new ArraySegment<byte>(serverBuffer, totalReceived, serverBuffer.Length - totalReceived), CancellationToken.None);
Assert.True(result.EndOfMessage);
Assert.Equal(7, result.Count);
totalReceived += result.Count;
Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
Assert.Equal(orriginalData, serverBuffer);
clientSocket.Dispose();
} }
} }
[Fact] [Fact]
public async Task SendClose_Success() public async Task SendClose_Success()
{ {
using (HttpListener listener = new HttpListener()) string closeDescription = "Test Closed";
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
listener.Prefixes.Add(ServerAddress); Assert.True(context.IsWebSocketRequest);
listener.Start(); var webSocket = await context.AcceptWebSocketAsync();
Task<HttpListenerContext> serverAccept = listener.GetContextAsync();
WebSocketClient client = new WebSocketClient(); var serverBuffer = new byte[1024];
Task<WebSocket> clientConnect = client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
HttpListenerContext serverContext = await serverAccept;
Assert.True(serverContext.Request.IsWebSocketRequest);
HttpListenerWebSocketContext serverWebSocketContext = await serverContext.AcceptWebSocketAsync(null);
WebSocket clientSocket = await clientConnect;
string closeDescription = "Test Closed";
await clientSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
byte[] serverBuffer = new byte[1024];
WebSocketReceiveResult result = await serverWebSocketContext.WebSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
Assert.True(result.EndOfMessage); Assert.True(result.EndOfMessage);
Assert.Equal(0, result.Count); Assert.Equal(0, result.Count);
Assert.Equal(WebSocketMessageType.Close, result.MessageType); Assert.Equal(WebSocketMessageType.Close, result.MessageType);
Assert.Equal(WebSocketCloseStatus.NormalClosure, result.CloseStatus); Assert.Equal(WebSocketCloseStatus.NormalClosure, result.CloseStatus);
Assert.Equal(closeDescription, result.CloseStatusDescription); Assert.Equal(closeDescription, result.CloseStatusDescription);
}))
{
var client = new WebSocketClient();
using (var clientSocket = await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None))
{
await clientSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
Assert.Equal(WebSocketState.CloseSent, clientSocket.State); Assert.Equal(WebSocketState.CloseSent, clientSocket.State);
}
clientSocket.Dispose();
} }
} }
[Fact] [Fact]
public async Task ReceiveClose_Success() public async Task ReceiveClose_Success()
{ {
using (HttpListener listener = new HttpListener()) string closeDescription = "Test Closed";
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
listener.Prefixes.Add(ServerAddress); Assert.True(context.IsWebSocketRequest);
listener.Start(); var webSocket = await context.AcceptWebSocketAsync();
Task<HttpListenerContext> serverAccept = listener.GetContextAsync();
WebSocketClient client = new WebSocketClient(); await webSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
Task<WebSocket> clientConnect = client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); }))
{
var client = new WebSocketClient();
using (var clientSocket = await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None))
{
var clientBuffer = new byte[1024];
var result = await clientSocket.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None);
Assert.True(result.EndOfMessage);
Assert.Equal(0, result.Count);
Assert.Equal(WebSocketMessageType.Close, result.MessageType);
Assert.Equal(WebSocketCloseStatus.NormalClosure, result.CloseStatus);
Assert.Equal(closeDescription, result.CloseStatusDescription);
HttpListenerContext serverContext = await serverAccept; Assert.Equal(WebSocketState.CloseReceived, clientSocket.State);
Assert.True(serverContext.Request.IsWebSocketRequest); }
HttpListenerWebSocketContext serverWebSocketContext = await serverContext.AcceptWebSocketAsync(null);
WebSocket clientSocket = await clientConnect;
string closeDescription = "Test Closed";
await serverWebSocketContext.WebSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
byte[] serverBuffer = new byte[1024];
WebSocketReceiveResult result = await clientSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
Assert.True(result.EndOfMessage);
Assert.Equal(0, result.Count);
Assert.Equal(WebSocketMessageType.Close, result.MessageType);
Assert.Equal(WebSocketCloseStatus.NormalClosure, result.CloseStatus);
Assert.Equal(closeDescription, result.CloseStatusDescription);
Assert.Equal(WebSocketState.CloseReceived, clientSocket.State);
clientSocket.Dispose();
} }
} }
[Fact] [Fact]
public async Task CloseFromOpen_Success() public async Task CloseFromOpen_Success()
{ {
using (HttpListener listener = new HttpListener()) string closeDescription = "Test Closed";
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
listener.Prefixes.Add(ServerAddress); Assert.True(context.IsWebSocketRequest);
listener.Start(); var webSocket = await context.AcceptWebSocketAsync();
Task<HttpListenerContext> serverAccept = listener.GetContextAsync();
WebSocketClient client = new WebSocketClient(); var serverBuffer = new byte[1024];
Task<WebSocket> clientConnect = client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
HttpListenerContext serverContext = await serverAccept;
Assert.True(serverContext.Request.IsWebSocketRequest);
HttpListenerWebSocketContext serverWebSocketContext = await serverContext.AcceptWebSocketAsync(null);
WebSocket clientSocket = await clientConnect;
string closeDescription = "Test Closed";
Task closeTask = clientSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
byte[] serverBuffer = new byte[1024];
WebSocketReceiveResult result = await serverWebSocketContext.WebSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
Assert.True(result.EndOfMessage); Assert.True(result.EndOfMessage);
Assert.Equal(0, result.Count); Assert.Equal(0, result.Count);
Assert.Equal(WebSocketMessageType.Close, result.MessageType); Assert.Equal(WebSocketMessageType.Close, result.MessageType);
Assert.Equal(WebSocketCloseStatus.NormalClosure, result.CloseStatus); Assert.Equal(WebSocketCloseStatus.NormalClosure, result.CloseStatus);
Assert.Equal(closeDescription, result.CloseStatusDescription); Assert.Equal(closeDescription, result.CloseStatusDescription);
await serverWebSocketContext.WebSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None); await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
}))
{
var client = new WebSocketClient();
using (var clientSocket = await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None))
{
await clientSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
await closeTask; Assert.Equal(WebSocketState.Closed, clientSocket.State);
}
Assert.Equal(WebSocketState.Closed, clientSocket.State);
clientSocket.Dispose();
} }
} }
[Fact] [Fact]
public async Task CloseFromCloseSent_Success() public async Task CloseFromCloseSent_Success()
{ {
using (HttpListener listener = new HttpListener()) string closeDescription = "Test Closed";
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
listener.Prefixes.Add(ServerAddress); Assert.True(context.IsWebSocketRequest);
listener.Start(); var webSocket = await context.AcceptWebSocketAsync();
Task<HttpListenerContext> serverAccept = listener.GetContextAsync();
WebSocketClient client = new WebSocketClient(); var serverBuffer = new byte[1024];
Task<WebSocket> clientConnect = client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
HttpListenerContext serverContext = await serverAccept;
Assert.True(serverContext.Request.IsWebSocketRequest);
HttpListenerWebSocketContext serverWebSocketContext = await serverContext.AcceptWebSocketAsync(null);
WebSocket clientSocket = await clientConnect;
string closeDescription = "Test Closed";
await clientSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
Assert.Equal(WebSocketState.CloseSent, clientSocket.State);
byte[] serverBuffer = new byte[1024];
WebSocketReceiveResult result = await serverWebSocketContext.WebSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
Assert.True(result.EndOfMessage); Assert.True(result.EndOfMessage);
Assert.Equal(0, result.Count); Assert.Equal(0, result.Count);
Assert.Equal(WebSocketMessageType.Close, result.MessageType); Assert.Equal(WebSocketMessageType.Close, result.MessageType);
Assert.Equal(WebSocketCloseStatus.NormalClosure, result.CloseStatus); Assert.Equal(WebSocketCloseStatus.NormalClosure, result.CloseStatus);
Assert.Equal(closeDescription, result.CloseStatusDescription); Assert.Equal(closeDescription, result.CloseStatusDescription);
await serverWebSocketContext.WebSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None); await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
}))
{
var client = new WebSocketClient();
using (var clientSocket = await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None))
{
await clientSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
Assert.Equal(WebSocketState.CloseSent, clientSocket.State);
await clientSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None); await clientSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
Assert.Equal(WebSocketState.Closed, clientSocket.State);
Assert.Equal(WebSocketState.Closed, clientSocket.State); }
clientSocket.Dispose();
} }
} }
[Fact] [Fact]
public async Task CloseFromCloseReceived_Success() public async Task CloseFromCloseReceived_Success()
{ {
using (HttpListener listener = new HttpListener()) string closeDescription = "Test Closed";
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
listener.Prefixes.Add(ServerAddress); Assert.True(context.IsWebSocketRequest);
listener.Start(); var webSocket = await context.AcceptWebSocketAsync();
Task<HttpListenerContext> serverAccept = listener.GetContextAsync();
WebSocketClient client = new WebSocketClient(); await webSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
Task<WebSocket> clientConnect = client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
HttpListenerContext serverContext = await serverAccept; var serverBuffer = new byte[1024];
Assert.True(serverContext.Request.IsWebSocketRequest); var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
HttpListenerWebSocketContext serverWebSocketContext = await serverContext.AcceptWebSocketAsync(null);
WebSocket clientSocket = await clientConnect;
string closeDescription = "Test Closed";
await serverWebSocketContext.WebSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
byte[] serverBuffer = new byte[1024];
WebSocketReceiveResult result = await clientSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
Assert.True(result.EndOfMessage); Assert.True(result.EndOfMessage);
Assert.Equal(0, result.Count); Assert.Equal(0, result.Count);
Assert.Equal(WebSocketMessageType.Close, result.MessageType); Assert.Equal(WebSocketMessageType.Close, result.MessageType);
Assert.Equal(WebSocketCloseStatus.NormalClosure, result.CloseStatus); Assert.Equal(WebSocketCloseStatus.NormalClosure, result.CloseStatus);
Assert.Equal(closeDescription, result.CloseStatusDescription); Assert.Equal(closeDescription, result.CloseStatusDescription);
}))
{
var client = new WebSocketClient();
using (var clientSocket = await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None))
{
var clientBuffer = new byte[1024];
var result = await clientSocket.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None);
Assert.True(result.EndOfMessage);
Assert.Equal(0, result.Count);
Assert.Equal(WebSocketMessageType.Close, result.MessageType);
Assert.Equal(WebSocketCloseStatus.NormalClosure, result.CloseStatus);
Assert.Equal(closeDescription, result.CloseStatusDescription);
Assert.Equal(WebSocketState.CloseReceived, clientSocket.State); Assert.Equal(WebSocketState.CloseReceived, clientSocket.State);
await clientSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None); await clientSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
Assert.Equal(WebSocketState.Closed, clientSocket.State); Assert.Equal(WebSocketState.Closed, clientSocket.State);
}
clientSocket.Dispose();
} }
} }
} }

4
test/Microsoft.AspNet.WebSockets.Client.Test/project.json
View File

@ -2,7 +2,9 @@
"dependencies": { "dependencies": {
"Microsoft.AspNet.WebSockets.Protocol": "1.0.0-*", "Microsoft.AspNet.WebSockets.Protocol": "1.0.0-*",
"Microsoft.AspNet.WebSockets.Client": "1.0.0-*", "Microsoft.AspNet.WebSockets.Client": "1.0.0-*",
"Xunit.KRunner": "1.0.0-*" "Microsoft.AspNet.WebSockets.Server": "1.0.0-*",
"Xunit.KRunner": "1.0.0-*",
"Kestrel": "1.0.0-*"
}, },
"frameworks": { "frameworks": {
"aspnet50": { } "aspnet50": { }