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

fix Kestrel version to fix build (#227)

This commit is contained in:
Andrew Stanton-Nurse 2018-01-26 12:27:41 -08:00 committed by GitHub
parent 202cec7ea0
commit a6fc4776da
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 403 additions and 343 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
build/dependencies.props
View File

@ -3,23 +3,24 @@
<MSBuildAllProjects>$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects> <MSBuildAllProjects>$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>
</PropertyGroup> </PropertyGroup>
<PropertyGroup Label="Package Versions"> <PropertyGroup Label="Package Versions">
<InternalAspNetCoreSdkPackageVersion>2.1.0-preview1-15651</InternalAspNetCoreSdkPackageVersion> <InternalAspNetCoreSdkPackageVersion>2.1.0-preview2-15684</InternalAspNetCoreSdkPackageVersion>
<MicrosoftAspNetCoreAspNetCoreModulePackageVersion>2.1.0-preview1-27965</MicrosoftAspNetCoreAspNetCoreModulePackageVersion> <MicrosoftAspNetCoreAspNetCoreModulePackageVersion>2.1.0-preview2-28183</MicrosoftAspNetCoreAspNetCoreModulePackageVersion>
<MicrosoftAspNetCoreDiagnosticsPackageVersion>2.1.0-preview1-27965</MicrosoftAspNetCoreDiagnosticsPackageVersion> <MicrosoftAspNetCoreDiagnosticsPackageVersion>2.1.0-preview2-28183</MicrosoftAspNetCoreDiagnosticsPackageVersion>
<MicrosoftAspNetCoreHttpExtensionsPackageVersion>2.1.0-preview1-27965</MicrosoftAspNetCoreHttpExtensionsPackageVersion> <MicrosoftAspNetCoreHttpExtensionsPackageVersion>2.1.0-preview2-28183</MicrosoftAspNetCoreHttpExtensionsPackageVersion>
<MicrosoftAspNetCoreServerHttpSysPackageVersion>2.1.0-preview1-27965</MicrosoftAspNetCoreServerHttpSysPackageVersion> <MicrosoftAspNetCoreServerHttpSysPackageVersion>2.1.0-preview2-28183</MicrosoftAspNetCoreServerHttpSysPackageVersion>
<MicrosoftAspNetCoreServerIISIntegrationPackageVersion>2.1.0-preview1-27965</MicrosoftAspNetCoreServerIISIntegrationPackageVersion> <MicrosoftAspNetCoreServerIISIntegrationPackageVersion>2.1.0-preview2-28183</MicrosoftAspNetCoreServerIISIntegrationPackageVersion>
<MicrosoftAspNetCoreServerIntegrationTestingPackageVersion>0.5.0-preview1-27965</MicrosoftAspNetCoreServerIntegrationTestingPackageVersion> <MicrosoftAspNetCoreServerIntegrationTestingPackageVersion>0.5.0-preview2-28183</MicrosoftAspNetCoreServerIntegrationTestingPackageVersion>
<MicrosoftAspNetCoreServerKestrelHttpsPackageVersion>2.1.0-preview1-27965</MicrosoftAspNetCoreServerKestrelHttpsPackageVersion> <MicrosoftAspNetCoreServerKestrelHttpsPackageVersion>2.1.0-preview2-28183</MicrosoftAspNetCoreServerKestrelHttpsPackageVersion>
<MicrosoftAspNetCoreServerKestrelPackageVersion>2.1.0-preview1-27965</MicrosoftAspNetCoreServerKestrelPackageVersion> <MicrosoftAspNetCoreServerKestrelPackageVersion>2.1.0-preview2-28183</MicrosoftAspNetCoreServerKestrelPackageVersion>
<MicrosoftAspNetCoreStaticFilesPackageVersion>2.1.0-preview1-27965</MicrosoftAspNetCoreStaticFilesPackageVersion> <MicrosoftAspNetCoreStaticFilesPackageVersion>2.1.0-preview2-28183</MicrosoftAspNetCoreStaticFilesPackageVersion>
<MicrosoftAspNetCoreTestingPackageVersion>2.1.0-preview1-27965</MicrosoftAspNetCoreTestingPackageVersion> <MicrosoftAspNetCoreTestingPackageVersion>2.1.0-preview2-28183</MicrosoftAspNetCoreTestingPackageVersion>
<MicrosoftExtensionsConfigurationCommandLinePackageVersion>2.1.0-preview1-27965</MicrosoftExtensionsConfigurationCommandLinePackageVersion> <MicrosoftExtensionsConfigurationCommandLinePackageVersion>2.1.0-preview2-28183</MicrosoftExtensionsConfigurationCommandLinePackageVersion>
<MicrosoftExtensionsLoggingConsolePackageVersion>2.1.0-preview1-27965</MicrosoftExtensionsLoggingConsolePackageVersion> <MicrosoftExtensionsLoggingConsolePackageVersion>2.1.0-preview2-28183</MicrosoftExtensionsLoggingConsolePackageVersion>
<MicrosoftExtensionsLoggingPackageVersion>2.1.0-preview1-27965</MicrosoftExtensionsLoggingPackageVersion> <MicrosoftExtensionsLoggingPackageVersion>2.1.0-preview2-28183</MicrosoftExtensionsLoggingPackageVersion>
<MicrosoftExtensionsOptionsPackageVersion>2.1.0-preview1-27965</MicrosoftExtensionsOptionsPackageVersion> <MicrosoftExtensionsLoggingTestingPackageVersion>2.1.0-preview2-28183</MicrosoftExtensionsLoggingTestingPackageVersion>
<MicrosoftExtensionsOptionsPackageVersion>2.1.0-preview2-28183</MicrosoftExtensionsOptionsPackageVersion>
<MicrosoftNETCoreApp20PackageVersion>2.0.0</MicrosoftNETCoreApp20PackageVersion> <MicrosoftNETCoreApp20PackageVersion>2.0.0</MicrosoftNETCoreApp20PackageVersion>
<MicrosoftNETCoreApp21PackageVersion>2.1.0-preview1-26016-05</MicrosoftNETCoreApp21PackageVersion> <MicrosoftNETCoreApp21PackageVersion>2.1.0-preview1-26122-01</MicrosoftNETCoreApp21PackageVersion>
<MicrosoftNETTestSdkPackageVersion>15.3.0</MicrosoftNETTestSdkPackageVersion> <MicrosoftNETTestSdkPackageVersion>15.3.0</MicrosoftNETTestSdkPackageVersion>
<SystemNetWebSocketsWebSocketProtocolPackageVersion>4.5.0-preview1-26119-06</SystemNetWebSocketsWebSocketProtocolPackageVersion> <SystemNetWebSocketsWebSocketProtocolPackageVersion>4.5.0-preview1-26119-06</SystemNetWebSocketsWebSocketProtocolPackageVersion>
<XunitPackageVersion>2.3.1</XunitPackageVersion> <XunitPackageVersion>2.3.1</XunitPackageVersion>

4
korebuild-lock.txt
View File

@ -1,2 +1,2 @@
version:2.1.0-preview1-15661 version:2.1.0-preview2-15684
commithash:c9349d4c8a495d3085d9b879214d80f2f45e2193 commithash:308af8e3279892aad7f189ffbddd3ff9a60970d3

2
samples/EchoApp/Properties/launchSettings.json
View File

@ -3,7 +3,7 @@
"windowsAuthentication": false, "windowsAuthentication": false,
"anonymousAuthentication": true, "anonymousAuthentication": true,
"iisExpress": { "iisExpress": {
"applicationUrl": "http://localhost:3159/", "applicationUrl": "http://localhost:62225/",
"sslPort": 0 "sslPort": 0
} }
}, },

1
src/Microsoft.AspNetCore.WebSockets/WebSocketMiddleware.cs
View File

@ -116,6 +116,7 @@ namespace Microsoft.AspNetCore.WebSockets
{ {
_context.Response.Headers[headerPair.Key] = headerPair.Value; _context.Response.Headers[headerPair.Key] = headerPair.Value;
} }
Stream opaqueTransport = await _upgradeFeature.UpgradeAsync(); // Sets status code to 101 Stream opaqueTransport = await _upgradeFeature.UpgradeAsync(); // Sets status code to 101
return WebSocketProtocol.CreateFromStream(opaqueTransport, isServer: true, subProtocol: subProtocol, keepAliveInterval: keepAliveInterval); return WebSocketProtocol.CreateFromStream(opaqueTransport, isServer: true, subProtocol: subProtocol, keepAliveInterval: keepAliveInterval);

5
test/Microsoft.AspNetCore.WebSockets.Test/KestrelWebSocketHelpers.cs
View File

@ -7,12 +7,14 @@ using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Configuration; using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.DependencyInjection;
namespace Microsoft.AspNetCore.WebSockets.Test namespace Microsoft.AspNetCore.WebSockets.Test
{ {
public class KestrelWebSocketHelpers public class KestrelWebSocketHelpers
{ {
public static IDisposable CreateServer(Func<HttpContext, Task> app) public static IDisposable CreateServer(ILoggerFactory loggerFactory, Func<HttpContext, Task> app)
{ {
Action<IApplicationBuilder> startup = builder => Action<IApplicationBuilder> startup = builder =>
{ {
@ -46,6 +48,7 @@ namespace Microsoft.AspNetCore.WebSockets.Test
config["server.urls"] = "http://localhost:54321"; config["server.urls"] = "http://localhost:54321";
var host = new WebHostBuilder() var host = new WebHostBuilder()
.ConfigureServices(s => s.AddSingleton(loggerFactory))
.UseConfiguration(config) .UseConfiguration(config)
.UseKestrel() .UseKestrel()
.Configure(startup) .Configure(startup)

1
test/Microsoft.AspNetCore.WebSockets.Test/Microsoft.AspNetCore.WebSockets.Test.csproj
View File

@ -9,6 +9,7 @@
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<PackageReference Include="Microsoft.Extensions.Logging.Testing" Version="$(MicrosoftExtensionsLoggingTestingPackageVersion)" />
<PackageReference Include="Microsoft.AspNetCore.Server.Kestrel" Version="$(MicrosoftAspNetCoreServerKestrelPackageVersion)" /> <PackageReference Include="Microsoft.AspNetCore.Server.Kestrel" Version="$(MicrosoftAspNetCoreServerKestrelPackageVersion)" />
<PackageReference Include="Microsoft.AspNetCore.Testing" Version="$(MicrosoftAspNetCoreTestingPackageVersion)" /> <PackageReference Include="Microsoft.AspNetCore.Testing" Version="$(MicrosoftAspNetCoreTestingPackageVersion)" />
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="$(MicrosoftNETTestSdkPackageVersion)" /> <PackageReference Include="Microsoft.NET.Test.Sdk" Version="$(MicrosoftNETTestSdkPackageVersion)" />

700
test/Microsoft.AspNetCore.WebSockets.Test/WebSocketMiddlewareTests.cs
View File

@ -7,27 +7,36 @@ using System.Text;
using System.Threading; using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
using Microsoft.AspNetCore.Testing.xunit; using Microsoft.AspNetCore.Testing.xunit;
using Microsoft.Extensions.Logging.Testing;
using Xunit; using Xunit;
using Xunit.Abstractions;
namespace Microsoft.AspNetCore.WebSockets.Test namespace Microsoft.AspNetCore.WebSockets.Test
{ {
public class WebSocketMiddlewareTests public class WebSocketMiddlewareTests : LoggedTest
{ {
private static string ClientAddress = "ws://localhost:54321/"; private static string ClientAddress = "ws://localhost:54321/";
public WebSocketMiddlewareTests(ITestOutputHelper output) : base(output)
{
}
[ConditionalFact] [ConditionalFact]
[OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")] [OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")]
public async Task Connect_Success() public async Task Connect_Success()
{ {
using (var server = KestrelWebSocketHelpers.CreateServer(async context => using (StartLog(out var loggerFactory))
{ {
Assert.True(context.WebSockets.IsWebSocketRequest); using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context =>
var webSocket = await context.WebSockets.AcceptWebSocketAsync();
}))
{
using (var client = new ClientWebSocket())
{ {
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); Assert.True(context.WebSockets.IsWebSocketRequest);
var webSocket = await context.WebSockets.AcceptWebSocketAsync();
}))
{
using (var client = new ClientWebSocket())
{
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
}
} }
} }
} }
@ -36,27 +45,30 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")] [OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")]
public async Task NegotiateSubProtocol_Success() public async Task NegotiateSubProtocol_Success()
{ {
using (var server = KestrelWebSocketHelpers.CreateServer(async context => using (StartLog(out var loggerFactory))
{ {
Assert.True(context.WebSockets.IsWebSocketRequest); using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context =>
Assert.Equal("alpha, bravo, charlie", context.Request.Headers["Sec-WebSocket-Protocol"]);
var webSocket = await context.WebSockets.AcceptWebSocketAsync("Bravo");
}))
{
using (var client = new ClientWebSocket())
{ {
client.Options.AddSubProtocol("alpha"); Assert.True(context.WebSockets.IsWebSocketRequest);
client.Options.AddSubProtocol("bravo"); Assert.Equal("alpha, bravo, charlie", context.Request.Headers["Sec-WebSocket-Protocol"]);
client.Options.AddSubProtocol("charlie"); var webSocket = await context.WebSockets.AcceptWebSocketAsync("Bravo");
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); }))
{
// The Windows version of ClientWebSocket uses the casing from the header (Bravo) using (var client = new ClientWebSocket())
// However, the Managed version seems match the header against the list generated by {
// the AddSubProtocol calls (case-insensitively) and then use the version from client.Options.AddSubProtocol("alpha");
// that list as the value for SubProtocol. This is fine, but means we need to ignore case here. client.Options.AddSubProtocol("bravo");
// We could update our AddSubProtocols above to the same case but I think it's better to client.Options.AddSubProtocol("charlie");
// ensure this behavior is codified by this test. await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
Assert.Equal("Bravo", client.SubProtocol, ignoreCase: true);
// The Windows version of ClientWebSocket uses the casing from the header (Bravo)
// However, the Managed version seems match the header against the list generated by
// the AddSubProtocol calls (case-insensitively) and then use the version from
// that list as the value for SubProtocol. This is fine, but means we need to ignore case here.
// We could update our AddSubProtocols above to the same case but I think it's better to
// ensure this behavior is codified by this test.
Assert.Equal("Bravo", client.SubProtocol, ignoreCase: true);
}
} }
} }
} }
@ -65,23 +77,26 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")] [OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")]
public async Task SendEmptyData_Success() public async Task SendEmptyData_Success()
{ {
using (var server = KestrelWebSocketHelpers.CreateServer(async context => using (StartLog(out var loggerFactory))
{ {
Assert.True(context.WebSockets.IsWebSocketRequest); using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context =>
var webSocket = await context.WebSockets.AcceptWebSocketAsync();
var serverBuffer = new byte[0];
var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
Assert.True(result.EndOfMessage);
Assert.Equal(0, result.Count);
Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
}))
{
using (var client = new ClientWebSocket())
{ {
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); Assert.True(context.WebSockets.IsWebSocketRequest);
var orriginalData = new byte[0]; var webSocket = await context.WebSockets.AcceptWebSocketAsync();
await client.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
var serverBuffer = new byte[0];
var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
Assert.True(result.EndOfMessage);
Assert.Equal(0, result.Count);
Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
}))
{
using (var client = new ClientWebSocket())
{
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
var orriginalData = new byte[0];
await client.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
}
} }
} }
} }
@ -90,24 +105,27 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")] [OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")]
public async Task SendShortData_Success() public async Task SendShortData_Success()
{ {
var orriginalData = Encoding.UTF8.GetBytes("Hello World"); using (StartLog(out var loggerFactory))
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
Assert.True(context.WebSockets.IsWebSocketRequest); var orriginalData = Encoding.UTF8.GetBytes("Hello World");
var webSocket = await context.WebSockets.AcceptWebSocketAsync(); using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context =>
var serverBuffer = new byte[orriginalData.Length];
var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
Assert.True(result.EndOfMessage);
Assert.Equal(orriginalData.Length, result.Count);
Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
Assert.Equal(orriginalData, serverBuffer);
}))
{
using (var client = new ClientWebSocket())
{ {
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); Assert.True(context.WebSockets.IsWebSocketRequest);
await client.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None); var webSocket = await context.WebSockets.AcceptWebSocketAsync();
var serverBuffer = new byte[orriginalData.Length];
var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
Assert.True(result.EndOfMessage);
Assert.Equal(orriginalData.Length, result.Count);
Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
Assert.Equal(orriginalData, serverBuffer);
}))
{
using (var client = new ClientWebSocket())
{
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
await client.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
}
} }
} }
} }
@ -116,24 +134,27 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")] [OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")]
public async Task SendMediumData_Success() public async Task SendMediumData_Success()
{ {
var orriginalData = Encoding.UTF8.GetBytes(new string('a', 130)); using (StartLog(out var loggerFactory))
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
Assert.True(context.WebSockets.IsWebSocketRequest); var orriginalData = Encoding.UTF8.GetBytes(new string('a', 130));
var webSocket = await context.WebSockets.AcceptWebSocketAsync(); using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context =>
var serverBuffer = new byte[orriginalData.Length];
var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
Assert.True(result.EndOfMessage);
Assert.Equal(orriginalData.Length, result.Count);
Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
Assert.Equal(orriginalData, serverBuffer);
}))
{
using (var client = new ClientWebSocket())
{ {
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); Assert.True(context.WebSockets.IsWebSocketRequest);
await client.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None); var webSocket = await context.WebSockets.AcceptWebSocketAsync();
var serverBuffer = new byte[orriginalData.Length];
var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
Assert.True(result.EndOfMessage);
Assert.Equal(orriginalData.Length, result.Count);
Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
Assert.Equal(orriginalData, serverBuffer);
}))
{
using (var client = new ClientWebSocket())
{
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
await client.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
}
} }
} }
} }
@ -142,36 +163,39 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")] [OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")]
public async Task SendLongData_Success() public async Task SendLongData_Success()
{ {
var orriginalData = Encoding.UTF8.GetBytes(new string('a', 0x1FFFF)); using (StartLog(out var loggerFactory))
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
Assert.True(context.WebSockets.IsWebSocketRequest); var orriginalData = Encoding.UTF8.GetBytes(new string('a', 0x1FFFF));
var webSocket = await context.WebSockets.AcceptWebSocketAsync(); using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context =>
var serverBuffer = new byte[orriginalData.Length];
var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
int intermediateCount = result.Count;
Assert.False(result.EndOfMessage);
Assert.Equal(WebSocketMessageType.Text, result.MessageType);
result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer, intermediateCount, orriginalData.Length - intermediateCount), CancellationToken.None);
intermediateCount += result.Count;
Assert.False(result.EndOfMessage);
Assert.Equal(WebSocketMessageType.Text, result.MessageType);
result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer, intermediateCount, orriginalData.Length - intermediateCount), CancellationToken.None);
intermediateCount += result.Count;
Assert.True(result.EndOfMessage);
Assert.Equal(orriginalData.Length, intermediateCount);
Assert.Equal(WebSocketMessageType.Text, result.MessageType);
Assert.Equal(orriginalData, serverBuffer);
}))
{
using (var client = new ClientWebSocket())
{ {
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); Assert.True(context.WebSockets.IsWebSocketRequest);
await client.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None); var webSocket = await context.WebSockets.AcceptWebSocketAsync();
var serverBuffer = new byte[orriginalData.Length];
var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
int intermediateCount = result.Count;
Assert.False(result.EndOfMessage);
Assert.Equal(WebSocketMessageType.Text, result.MessageType);
result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer, intermediateCount, orriginalData.Length - intermediateCount), CancellationToken.None);
intermediateCount += result.Count;
Assert.False(result.EndOfMessage);
Assert.Equal(WebSocketMessageType.Text, result.MessageType);
result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer, intermediateCount, orriginalData.Length - intermediateCount), CancellationToken.None);
intermediateCount += result.Count;
Assert.True(result.EndOfMessage);
Assert.Equal(orriginalData.Length, intermediateCount);
Assert.Equal(WebSocketMessageType.Text, result.MessageType);
Assert.Equal(orriginalData, serverBuffer);
}))
{
using (var client = new ClientWebSocket())
{
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
await client.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
}
} }
} }
} }
@ -180,42 +204,45 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")] [OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")]
public async Task SendFragmentedData_Success() public async Task SendFragmentedData_Success()
{ {
var orriginalData = Encoding.UTF8.GetBytes("Hello World"); using (StartLog(out var loggerFactory))
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
Assert.True(context.WebSockets.IsWebSocketRequest); var orriginalData = Encoding.UTF8.GetBytes("Hello World");
var webSocket = await context.WebSockets.AcceptWebSocketAsync(); using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context =>
var serverBuffer = new byte[orriginalData.Length];
var result = await webSocket.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 webSocket.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 webSocket.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);
}))
{
using (var client = new ClientWebSocket())
{ {
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); Assert.True(context.WebSockets.IsWebSocketRequest);
await client.SendAsync(new ArraySegment<byte>(orriginalData, 0, 2), WebSocketMessageType.Binary, false, CancellationToken.None); var webSocket = await context.WebSockets.AcceptWebSocketAsync();
await client.SendAsync(new ArraySegment<byte>(orriginalData, 2, 2), WebSocketMessageType.Binary, false, CancellationToken.None);
await client.SendAsync(new ArraySegment<byte>(orriginalData, 4, 7), WebSocketMessageType.Binary, true, CancellationToken.None); var serverBuffer = new byte[orriginalData.Length];
var result = await webSocket.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 webSocket.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 webSocket.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);
}))
{
using (var client = new ClientWebSocket())
{
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
await client.SendAsync(new ArraySegment<byte>(orriginalData, 0, 2), WebSocketMessageType.Binary, false, CancellationToken.None);
await client.SendAsync(new ArraySegment<byte>(orriginalData, 2, 2), WebSocketMessageType.Binary, false, CancellationToken.None);
await client.SendAsync(new ArraySegment<byte>(orriginalData, 4, 7), WebSocketMessageType.Binary, true, CancellationToken.None);
}
} }
} }
} }
@ -224,24 +251,27 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")] [OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")]
public async Task ReceiveShortData_Success() public async Task ReceiveShortData_Success()
{ {
var orriginalData = Encoding.UTF8.GetBytes("Hello World"); using (StartLog(out var loggerFactory))
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
Assert.True(context.WebSockets.IsWebSocketRequest); var orriginalData = Encoding.UTF8.GetBytes("Hello World");
var webSocket = await context.WebSockets.AcceptWebSocketAsync(); using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context =>
await webSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
}))
{
using (var client = new ClientWebSocket())
{ {
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); Assert.True(context.WebSockets.IsWebSocketRequest);
var clientBuffer = new byte[orriginalData.Length]; var webSocket = await context.WebSockets.AcceptWebSocketAsync();
var result = await client.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None);
Assert.True(result.EndOfMessage); await webSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
Assert.Equal(orriginalData.Length, result.Count); }))
Assert.Equal(WebSocketMessageType.Binary, result.MessageType); {
Assert.Equal(orriginalData, clientBuffer); using (var client = new ClientWebSocket())
{
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
var clientBuffer = new byte[orriginalData.Length];
var result = await client.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);
}
} }
} }
} }
@ -250,24 +280,27 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")] [OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")]
public async Task ReceiveMediumData_Success() public async Task ReceiveMediumData_Success()
{ {
var orriginalData = Encoding.UTF8.GetBytes(new string('a', 130)); using (StartLog(out var loggerFactory))
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
Assert.True(context.WebSockets.IsWebSocketRequest); var orriginalData = Encoding.UTF8.GetBytes(new string('a', 130));
var webSocket = await context.WebSockets.AcceptWebSocketAsync(); using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context =>
await webSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
}))
{
using (var client = new ClientWebSocket())
{ {
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); Assert.True(context.WebSockets.IsWebSocketRequest);
var clientBuffer = new byte[orriginalData.Length]; var webSocket = await context.WebSockets.AcceptWebSocketAsync();
var result = await client.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None);
Assert.True(result.EndOfMessage); await webSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
Assert.Equal(orriginalData.Length, result.Count); }))
Assert.Equal(WebSocketMessageType.Binary, result.MessageType); {
Assert.Equal(orriginalData, clientBuffer); using (var client = new ClientWebSocket())
{
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
var clientBuffer = new byte[orriginalData.Length];
var result = await client.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);
}
} }
} }
} }
@ -276,32 +309,35 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")] [OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")]
public async Task ReceiveLongData() public async Task ReceiveLongData()
{ {
var orriginalData = Encoding.UTF8.GetBytes(new string('a', 0x1FFFF)); using (StartLog(out var loggerFactory))
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
Assert.True(context.WebSockets.IsWebSocketRequest); var orriginalData = Encoding.UTF8.GetBytes(new string('a', 0x1FFFF));
var webSocket = await context.WebSockets.AcceptWebSocketAsync(); using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context =>
await webSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
}))
{
using (var client = new ClientWebSocket())
{ {
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); Assert.True(context.WebSockets.IsWebSocketRequest);
var clientBuffer = new byte[orriginalData.Length]; var webSocket = await context.WebSockets.AcceptWebSocketAsync();
WebSocketReceiveResult result;
int receivedCount = 0;
do
{
result = await client.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); await webSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
Assert.Equal(WebSocketMessageType.Binary, result.MessageType); }))
Assert.Equal(orriginalData, clientBuffer); {
using (var client = new ClientWebSocket())
{
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
var clientBuffer = new byte[orriginalData.Length];
WebSocketReceiveResult result;
int receivedCount = 0;
do
{
result = await client.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(orriginalData, clientBuffer);
}
} }
} }
} }
@ -310,42 +346,45 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")] [OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")]
public async Task ReceiveFragmentedData_Success() public async Task ReceiveFragmentedData_Success()
{ {
var orriginalData = Encoding.UTF8.GetBytes("Hello World"); using (StartLog(out var loggerFactory))
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
Assert.True(context.WebSockets.IsWebSocketRequest); var orriginalData = Encoding.UTF8.GetBytes("Hello World");
var webSocket = await context.WebSockets.AcceptWebSocketAsync(); using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context =>
await webSocket.SendAsync(new ArraySegment<byte>(orriginalData, 0, 2), WebSocketMessageType.Binary, false, 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);
}))
{
using (var client = new ClientWebSocket())
{ {
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); Assert.True(context.WebSockets.IsWebSocketRequest);
var clientBuffer = new byte[orriginalData.Length]; var webSocket = await context.WebSockets.AcceptWebSocketAsync();
var result = await client.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);
result = await client.ReceiveAsync( await webSocket.SendAsync(new ArraySegment<byte>(orriginalData, 0, 2), WebSocketMessageType.Binary, false, CancellationToken.None);
new ArraySegment<byte>(clientBuffer, totalReceived, clientBuffer.Length - totalReceived), CancellationToken.None); await webSocket.SendAsync(new ArraySegment<byte>(orriginalData, 2, 2), WebSocketMessageType.Binary, false, CancellationToken.None);
Assert.False(result.EndOfMessage); await webSocket.SendAsync(new ArraySegment<byte>(orriginalData, 4, 7), WebSocketMessageType.Binary, true, CancellationToken.None);
Assert.Equal(2, result.Count); }))
totalReceived += result.Count; {
Assert.Equal(WebSocketMessageType.Binary, result.MessageType); using (var client = new ClientWebSocket())
{
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
var clientBuffer = new byte[orriginalData.Length];
var result = await client.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);
result = await client.ReceiveAsync( result = await client.ReceiveAsync(
new ArraySegment<byte>(clientBuffer, totalReceived, clientBuffer.Length - totalReceived), CancellationToken.None); new ArraySegment<byte>(clientBuffer, totalReceived, clientBuffer.Length - totalReceived), CancellationToken.None);
Assert.True(result.EndOfMessage); Assert.False(result.EndOfMessage);
Assert.Equal(7, 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);
Assert.Equal(orriginalData, clientBuffer); result = await client.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);
Assert.Equal(orriginalData, clientBuffer);
}
} }
} }
} }
@ -354,27 +393,30 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")] [OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")]
public async Task SendClose_Success() public async Task SendClose_Success()
{ {
string closeDescription = "Test Closed"; using (StartLog(out var loggerFactory))
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
Assert.True(context.WebSockets.IsWebSocketRequest); string closeDescription = "Test Closed";
var webSocket = await context.WebSockets.AcceptWebSocketAsync(); using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context =>
var serverBuffer = new byte[1024];
var result = await webSocket.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);
}))
{
using (var client = new ClientWebSocket())
{ {
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); Assert.True(context.WebSockets.IsWebSocketRequest);
await client.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None); var webSocket = await context.WebSockets.AcceptWebSocketAsync();
Assert.Equal(WebSocketState.CloseSent, client.State); var serverBuffer = new byte[1024];
var result = await webSocket.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);
}))
{
using (var client = new ClientWebSocket())
{
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
await client.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
Assert.Equal(WebSocketState.CloseSent, client.State);
}
} }
} }
} }
@ -383,27 +425,30 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")] [OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")]
public async Task ReceiveClose_Success() public async Task ReceiveClose_Success()
{ {
string closeDescription = "Test Closed"; using (StartLog(out var loggerFactory))
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
Assert.True(context.WebSockets.IsWebSocketRequest); string closeDescription = "Test Closed";
var webSocket = await context.WebSockets.AcceptWebSocketAsync(); using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context =>
await webSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
}))
{
using (var client = new ClientWebSocket())
{ {
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); Assert.True(context.WebSockets.IsWebSocketRequest);
var clientBuffer = new byte[1024]; var webSocket = await context.WebSockets.AcceptWebSocketAsync();
var result = await client.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, client.State); await webSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
}))
{
using (var client = new ClientWebSocket())
{
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
var clientBuffer = new byte[1024];
var result = await client.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, client.State);
}
} }
} }
} }
@ -412,29 +457,32 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")] [OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")]
public async Task CloseFromOpen_Success() public async Task CloseFromOpen_Success()
{ {
string closeDescription = "Test Closed"; using (StartLog(out var loggerFactory))
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
Assert.True(context.WebSockets.IsWebSocketRequest); string closeDescription = "Test Closed";
var webSocket = await context.WebSockets.AcceptWebSocketAsync(); using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context =>
var serverBuffer = new byte[1024];
var result = await webSocket.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);
await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
}))
{
using (var client = new ClientWebSocket())
{ {
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); Assert.True(context.WebSockets.IsWebSocketRequest);
await client.CloseAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None); var webSocket = await context.WebSockets.AcceptWebSocketAsync();
Assert.Equal(WebSocketState.Closed, client.State); var serverBuffer = new byte[1024];
var result = await webSocket.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);
await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
}))
{
using (var client = new ClientWebSocket())
{
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
await client.CloseAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
Assert.Equal(WebSocketState.Closed, client.State);
}
} }
} }
} }
@ -443,31 +491,34 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")] [OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")]
public async Task CloseFromCloseSent_Success() public async Task CloseFromCloseSent_Success()
{ {
string closeDescription = "Test Closed"; using (StartLog(out var loggerFactory))
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
Assert.True(context.WebSockets.IsWebSocketRequest); string closeDescription = "Test Closed";
var webSocket = await context.WebSockets.AcceptWebSocketAsync(); using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context =>
var serverBuffer = new byte[1024];
var result = await webSocket.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);
await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
}))
{
using (var client = new ClientWebSocket())
{ {
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); Assert.True(context.WebSockets.IsWebSocketRequest);
await client.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None); var webSocket = await context.WebSockets.AcceptWebSocketAsync();
Assert.Equal(WebSocketState.CloseSent, client.State);
await client.CloseAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None); var serverBuffer = new byte[1024];
Assert.Equal(WebSocketState.Closed, client.State); var result = await webSocket.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);
await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
}))
{
using (var client = new ClientWebSocket())
{
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
await client.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
Assert.Equal(WebSocketState.CloseSent, client.State);
await client.CloseAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
Assert.Equal(WebSocketState.Closed, client.State);
}
} }
} }
} }
@ -476,39 +527,42 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")] [OSSkipCondition(OperatingSystems.Windows, WindowsVersions.Win7, SkipReason = "No WebSockets Client for this platform")]
public async Task CloseFromCloseReceived_Success() public async Task CloseFromCloseReceived_Success()
{ {
string closeDescription = "Test Closed"; using (StartLog(out var loggerFactory))
using (var server = KestrelWebSocketHelpers.CreateServer(async context =>
{ {
Assert.True(context.WebSockets.IsWebSocketRequest); string closeDescription = "Test Closed";
var webSocket = await context.WebSockets.AcceptWebSocketAsync(); using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context =>
await webSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
var serverBuffer = new byte[1024];
var result = await webSocket.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);
}))
{
using (var client = new ClientWebSocket())
{ {
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); Assert.True(context.WebSockets.IsWebSocketRequest);
var clientBuffer = new byte[1024]; var webSocket = await context.WebSockets.AcceptWebSocketAsync();
var result = await client.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None);
await webSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
var serverBuffer = new byte[1024];
var result = await 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);
}))
{
using (var client = new ClientWebSocket())
{
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
var clientBuffer = new byte[1024];
var result = await client.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, client.State); Assert.Equal(WebSocketState.CloseReceived, client.State);
await client.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None); await client.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
Assert.Equal(WebSocketState.Closed, client.State); Assert.Equal(WebSocketState.Closed, client.State);
}
} }
} }
} }