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

Fix flaky test 

Use dynamic port assignment to reduce address binding failures due to port collisions
This commit is contained in:
John Luo 2018-08-23 14:48:28 -07:00
parent 42efbb40c4
commit 752f934a23
3 changed files with 379 additions and 410 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -14,7 +14,7 @@ namespace Microsoft.AspNetCore.WebSockets.Test
{ {
public class KestrelWebSocketHelpers public class KestrelWebSocketHelpers
{ {
public static IDisposable CreateServer(ILoggerFactory loggerFactory, Func<HttpContext, Task> app, Action<WebSocketOptions> configure = null) public static IDisposable CreateServer(ILoggerFactory loggerFactory, Func<HttpContext, Task> app, int clientPort, Action<WebSocketOptions> configure = null)
{ {
configure = configure ?? (o => { }); configure = configure ?? (o => { });
Action<IApplicationBuilder> startup = builder => Action<IApplicationBuilder> startup = builder =>
@ -46,7 +46,7 @@ namespace Microsoft.AspNetCore.WebSockets.Test
var configBuilder = new ConfigurationBuilder(); var configBuilder = new ConfigurationBuilder();
configBuilder.AddInMemoryCollection(); configBuilder.AddInMemoryCollection();
var config = configBuilder.Build(); var config = configBuilder.Build();
config["server.urls"] = "http://localhost:54321"; config["server.urls"] = $"http://localhost:{clientPort}";
var host = new WebHostBuilder() var host = new WebHostBuilder()
.ConfigureServices(s => .ConfigureServices(s =>

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

@ -10,6 +10,7 @@
<ItemGroup> <ItemGroup>
<PackageReference Include="Microsoft.Extensions.Logging.Testing" Version="$(MicrosoftExtensionsLoggingTestingPackageVersion)" /> <PackageReference Include="Microsoft.Extensions.Logging.Testing" Version="$(MicrosoftExtensionsLoggingTestingPackageVersion)" />
<PackageReference Include="Microsoft.AspNetCore.Server.IntegrationTesting" Version="$(MicrosoftAspNetCoreServerIntegrationTestingPackageVersion)" />
<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)" />

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

@ -8,12 +8,11 @@ using System.Net.WebSockets;
using System.Text; using System.Text;
using System.Threading; using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Server.IntegrationTesting.Common;
using Microsoft.AspNetCore.Testing.xunit; using Microsoft.AspNetCore.Testing.xunit;
using Microsoft.AspNetCore.WebSockets.Internal; using Microsoft.AspNetCore.WebSockets.Internal;
using Microsoft.Extensions.Logging.Testing; using Microsoft.Extensions.Logging.Testing;
using Xunit; using Xunit;
using Xunit.Abstractions;
namespace Microsoft.AspNetCore.WebSockets.Test namespace Microsoft.AspNetCore.WebSockets.Test
{ {
@ -27,27 +26,28 @@ namespace Microsoft.AspNetCore.WebSockets.Test
#endif #endif
public class WebSocketMiddlewareTests : LoggedTest public class WebSocketMiddlewareTests : LoggedTest
{ {
private static string ClientAddress = "ws://localhost:54321/"; private readonly int ClientPort;
private readonly string ClientAddress;
public WebSocketMiddlewareTests(ITestOutputHelper output) : base(output) public WebSocketMiddlewareTests()
{ {
ClientPort = TestPortHelper.GetNextPort();
ClientAddress = $"ws://localhost:{ClientPort}/";
} }
[ConditionalFact] [ConditionalFact]
public async Task Connect_Success() public async Task Connect_Success()
{ {
using (StartLog(out var loggerFactory)) using (var server = KestrelWebSocketHelpers.CreateServer(LoggerFactory, async context =>
{ {
using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context => Assert.True(context.WebSockets.IsWebSocketRequest);
var webSocket = await context.WebSockets.AcceptWebSocketAsync();
},
ClientPort))
{
using (var client = new ClientWebSocket())
{ {
Assert.True(context.WebSockets.IsWebSocketRequest); await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
var webSocket = await context.WebSockets.AcceptWebSocketAsync();
}))
{
using (var client = new ClientWebSocket())
{
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
}
} }
} }
} }
@ -55,30 +55,28 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[ConditionalFact] [ConditionalFact]
public async Task NegotiateSubProtocol_Success() public async Task NegotiateSubProtocol_Success()
{ {
using (StartLog(out var loggerFactory)) using (var server = KestrelWebSocketHelpers.CreateServer(LoggerFactory, async context =>
{ {
using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context => Assert.True(context.WebSockets.IsWebSocketRequest);
Assert.Equal("alpha, bravo, charlie", context.Request.Headers["Sec-WebSocket-Protocol"]);
var webSocket = await context.WebSockets.AcceptWebSocketAsync("Bravo");
},
ClientPort))
{
using (var client = new ClientWebSocket())
{ {
Assert.True(context.WebSockets.IsWebSocketRequest); client.Options.AddSubProtocol("alpha");
Assert.Equal("alpha, bravo, charlie", context.Request.Headers["Sec-WebSocket-Protocol"]); client.Options.AddSubProtocol("bravo");
var webSocket = await context.WebSockets.AcceptWebSocketAsync("Bravo"); client.Options.AddSubProtocol("charlie");
})) await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
{
using (var client = new ClientWebSocket())
{
client.Options.AddSubProtocol("alpha");
client.Options.AddSubProtocol("bravo");
client.Options.AddSubProtocol("charlie");
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
// The Windows version of ClientWebSocket uses the casing from the header (Bravo) // 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 // However, the Managed version seems match the header against the list generated by
// the AddSubProtocol calls (case-insensitively) and then use the version from // 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. // 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 // 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. // ensure this behavior is codified by this test.
Assert.Equal("Bravo", client.SubProtocol, ignoreCase: true); Assert.Equal("Bravo", client.SubProtocol, ignoreCase: true);
}
} }
} }
} }
@ -86,26 +84,24 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[ConditionalFact] [ConditionalFact]
public async Task SendEmptyData_Success() public async Task SendEmptyData_Success()
{ {
using (StartLog(out var loggerFactory)) using (var server = KestrelWebSocketHelpers.CreateServer(LoggerFactory, async context =>
{ {
using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context => Assert.True(context.WebSockets.IsWebSocketRequest);
{ var webSocket = await context.WebSockets.AcceptWebSocketAsync();
Assert.True(context.WebSockets.IsWebSocketRequest);
var webSocket = await context.WebSockets.AcceptWebSocketAsync();
var serverBuffer = new byte[0]; var serverBuffer = new byte[0];
var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None); 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.Binary, result.MessageType); Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
})) },
ClientPort))
{
using (var client = new ClientWebSocket())
{ {
using (var client = new ClientWebSocket()) await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
{ var orriginalData = new byte[0];
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); await client.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
var orriginalData = new byte[0];
await client.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
}
} }
} }
} }
@ -113,27 +109,25 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[ConditionalFact] [ConditionalFact]
public async Task SendShortData_Success() public async Task SendShortData_Success()
{ {
using (StartLog(out var loggerFactory)) var orriginalData = Encoding.UTF8.GetBytes("Hello World");
using (var server = KestrelWebSocketHelpers.CreateServer(LoggerFactory, async context =>
{ {
var orriginalData = Encoding.UTF8.GetBytes("Hello World"); Assert.True(context.WebSockets.IsWebSocketRequest);
using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context => var webSocket = await context.WebSockets.AcceptWebSocketAsync();
{
Assert.True(context.WebSockets.IsWebSocketRequest);
var webSocket = await context.WebSockets.AcceptWebSocketAsync();
var serverBuffer = new byte[orriginalData.Length]; var serverBuffer = new byte[orriginalData.Length];
var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None); var result = await 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);
})) },
ClientPort))
{
using (var client = new ClientWebSocket())
{ {
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);
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
await client.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
}
} }
} }
} }
@ -141,27 +135,25 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[ConditionalFact] [ConditionalFact]
public async Task SendMediumData_Success() public async Task SendMediumData_Success()
{ {
using (StartLog(out var loggerFactory)) var orriginalData = Encoding.UTF8.GetBytes(new string('a', 130));
using (var server = KestrelWebSocketHelpers.CreateServer(LoggerFactory, async context =>
{ {
var orriginalData = Encoding.UTF8.GetBytes(new string('a', 130)); Assert.True(context.WebSockets.IsWebSocketRequest);
using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context => var webSocket = await context.WebSockets.AcceptWebSocketAsync();
{
Assert.True(context.WebSockets.IsWebSocketRequest);
var webSocket = await context.WebSockets.AcceptWebSocketAsync();
var serverBuffer = new byte[orriginalData.Length]; var serverBuffer = new byte[orriginalData.Length];
var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None); var result = await 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);
})) },
ClientPort))
{
using (var client = new ClientWebSocket())
{ {
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);
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
await client.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
}
} }
} }
} }
@ -169,39 +161,37 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[ConditionalFact] [ConditionalFact]
public async Task SendLongData_Success() public async Task SendLongData_Success()
{ {
using (StartLog(out var loggerFactory)) var orriginalData = Encoding.UTF8.GetBytes(new string('a', 0x1FFFF));
using (var server = KestrelWebSocketHelpers.CreateServer(LoggerFactory, async context =>
{ {
var orriginalData = Encoding.UTF8.GetBytes(new string('a', 0x1FFFF)); Assert.True(context.WebSockets.IsWebSocketRequest);
using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context => 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);
},
ClientPort))
{
using (var client = new ClientWebSocket())
{ {
Assert.True(context.WebSockets.IsWebSocketRequest); await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
var webSocket = await context.WebSockets.AcceptWebSocketAsync(); await client.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
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);
}
} }
} }
} }
@ -209,45 +199,43 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[ConditionalFact] [ConditionalFact]
public async Task SendFragmentedData_Success() public async Task SendFragmentedData_Success()
{ {
using (StartLog(out var loggerFactory)) var orriginalData = Encoding.UTF8.GetBytes("Hello World");
using (var server = KestrelWebSocketHelpers.CreateServer(LoggerFactory, async context =>
{ {
var orriginalData = Encoding.UTF8.GetBytes("Hello World"); Assert.True(context.WebSockets.IsWebSocketRequest);
using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context => var webSocket = await context.WebSockets.AcceptWebSocketAsync();
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);
},
ClientPort))
{
using (var client = new ClientWebSocket())
{ {
Assert.True(context.WebSockets.IsWebSocketRequest); await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
var webSocket = await context.WebSockets.AcceptWebSocketAsync(); 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);
var serverBuffer = new byte[orriginalData.Length]; await client.SendAsync(new ArraySegment<byte>(orriginalData, 4, 7), WebSocketMessageType.Binary, true, CancellationToken.None);
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);
}
} }
} }
} }
@ -255,27 +243,25 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[ConditionalFact] [ConditionalFact]
public async Task ReceiveShortData_Success() public async Task ReceiveShortData_Success()
{ {
using (StartLog(out var loggerFactory)) var orriginalData = Encoding.UTF8.GetBytes("Hello World");
using (var server = KestrelWebSocketHelpers.CreateServer(LoggerFactory, async context =>
{ {
var orriginalData = Encoding.UTF8.GetBytes("Hello World"); Assert.True(context.WebSockets.IsWebSocketRequest);
using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context => var webSocket = await context.WebSockets.AcceptWebSocketAsync();
{
Assert.True(context.WebSockets.IsWebSocketRequest);
var webSocket = await context.WebSockets.AcceptWebSocketAsync();
await webSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None); await webSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
})) },
ClientPort))
{
using (var client = new ClientWebSocket())
{ {
using (var client = new ClientWebSocket()) await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
{ var clientBuffer = new byte[orriginalData.Length];
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); var result = await client.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None);
var clientBuffer = new byte[orriginalData.Length]; Assert.True(result.EndOfMessage);
var result = await client.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None); Assert.Equal(orriginalData.Length, result.Count);
Assert.True(result.EndOfMessage); Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
Assert.Equal(orriginalData.Length, result.Count); Assert.Equal(orriginalData, clientBuffer);
Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
Assert.Equal(orriginalData, clientBuffer);
}
} }
} }
} }
@ -283,27 +269,25 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[ConditionalFact] [ConditionalFact]
public async Task ReceiveMediumData_Success() public async Task ReceiveMediumData_Success()
{ {
using (StartLog(out var loggerFactory)) var orriginalData = Encoding.UTF8.GetBytes(new string('a', 130));
using (var server = KestrelWebSocketHelpers.CreateServer(LoggerFactory, async context =>
{ {
var orriginalData = Encoding.UTF8.GetBytes(new string('a', 130)); Assert.True(context.WebSockets.IsWebSocketRequest);
using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context => var webSocket = await context.WebSockets.AcceptWebSocketAsync();
{
Assert.True(context.WebSockets.IsWebSocketRequest);
var webSocket = await context.WebSockets.AcceptWebSocketAsync();
await webSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None); await webSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
})) },
ClientPort))
{
using (var client = new ClientWebSocket())
{ {
using (var client = new ClientWebSocket()) await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
{ var clientBuffer = new byte[orriginalData.Length];
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); var result = await client.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None);
var clientBuffer = new byte[orriginalData.Length]; Assert.True(result.EndOfMessage);
var result = await client.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None); Assert.Equal(orriginalData.Length, result.Count);
Assert.True(result.EndOfMessage); Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
Assert.Equal(orriginalData.Length, result.Count); Assert.Equal(orriginalData, clientBuffer);
Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
Assert.Equal(orriginalData, clientBuffer);
}
} }
} }
} }
@ -311,35 +295,33 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[ConditionalFact] [ConditionalFact]
public async Task ReceiveLongData() public async Task ReceiveLongData()
{ {
using (StartLog(out var loggerFactory)) var orriginalData = Encoding.UTF8.GetBytes(new string('a', 0x1FFFF));
using (var server = KestrelWebSocketHelpers.CreateServer(LoggerFactory, async context =>
{ {
var orriginalData = Encoding.UTF8.GetBytes(new string('a', 0x1FFFF)); Assert.True(context.WebSockets.IsWebSocketRequest);
using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context => var webSocket = await context.WebSockets.AcceptWebSocketAsync();
{
Assert.True(context.WebSockets.IsWebSocketRequest);
var webSocket = await context.WebSockets.AcceptWebSocketAsync();
await webSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None); await webSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None);
})) },
ClientPort))
{
using (var client = new ClientWebSocket())
{ {
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
{ {
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); result = await client.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 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(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);
} }
} }
} }
@ -347,45 +329,43 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[ConditionalFact] [ConditionalFact]
public async Task ReceiveFragmentedData_Success() public async Task ReceiveFragmentedData_Success()
{ {
using (StartLog(out var loggerFactory)) var orriginalData = Encoding.UTF8.GetBytes("Hello World");
using (var server = KestrelWebSocketHelpers.CreateServer(LoggerFactory, async context =>
{ {
var orriginalData = Encoding.UTF8.GetBytes("Hello World"); Assert.True(context.WebSockets.IsWebSocketRequest);
using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context => var webSocket = await context.WebSockets.AcceptWebSocketAsync();
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);
},
ClientPort))
{
using (var client = new ClientWebSocket())
{ {
Assert.True(context.WebSockets.IsWebSocketRequest); await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
var webSocket = await context.WebSockets.AcceptWebSocketAsync(); 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);
await webSocket.SendAsync(new ArraySegment<byte>(orriginalData, 0, 2), WebSocketMessageType.Binary, false, CancellationToken.None); result = await client.ReceiveAsync(
await webSocket.SendAsync(new ArraySegment<byte>(orriginalData, 2, 2), WebSocketMessageType.Binary, false, CancellationToken.None); new ArraySegment<byte>(clientBuffer, totalReceived, clientBuffer.Length - totalReceived), CancellationToken.None);
await webSocket.SendAsync(new ArraySegment<byte>(orriginalData, 4, 7), WebSocketMessageType.Binary, true, CancellationToken.None); Assert.False(result.EndOfMessage);
})) Assert.Equal(2, result.Count);
{ totalReceived += result.Count;
using (var client = new ClientWebSocket()) Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
{
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.False(result.EndOfMessage); Assert.True(result.EndOfMessage);
Assert.Equal(2, result.Count); Assert.Equal(7, result.Count);
totalReceived += result.Count; totalReceived += result.Count;
Assert.Equal(WebSocketMessageType.Binary, result.MessageType); Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
result = await client.ReceiveAsync( Assert.Equal(orriginalData, clientBuffer);
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);
}
} }
} }
} }
@ -393,30 +373,28 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[ConditionalFact] [ConditionalFact]
public async Task SendClose_Success() public async Task SendClose_Success()
{ {
using (StartLog(out var loggerFactory)) string closeDescription = "Test Closed";
using (var server = KestrelWebSocketHelpers.CreateServer(LoggerFactory, async context =>
{ {
string closeDescription = "Test Closed"; Assert.True(context.WebSockets.IsWebSocketRequest);
using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context => var webSocket = await context.WebSockets.AcceptWebSocketAsync();
{
Assert.True(context.WebSockets.IsWebSocketRequest);
var webSocket = await context.WebSockets.AcceptWebSocketAsync();
var serverBuffer = new byte[1024]; var serverBuffer = new byte[1024];
var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None); 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);
})) },
ClientPort))
{
using (var client = new ClientWebSocket())
{ {
using (var client = new ClientWebSocket()) await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
{ await client.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
await client.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
Assert.Equal(WebSocketState.CloseSent, client.State); Assert.Equal(WebSocketState.CloseSent, client.State);
}
} }
} }
} }
@ -424,30 +402,28 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[ConditionalFact] [ConditionalFact]
public async Task ReceiveClose_Success() public async Task ReceiveClose_Success()
{ {
using (StartLog(out var loggerFactory)) string closeDescription = "Test Closed";
using (var server = KestrelWebSocketHelpers.CreateServer(LoggerFactory, async context =>
{ {
string closeDescription = "Test Closed"; Assert.True(context.WebSockets.IsWebSocketRequest);
using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context => var webSocket = await context.WebSockets.AcceptWebSocketAsync();
{
Assert.True(context.WebSockets.IsWebSocketRequest);
var webSocket = await context.WebSockets.AcceptWebSocketAsync();
await webSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None); await webSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
})) },
ClientPort))
{
using (var client = new ClientWebSocket())
{ {
using (var client = new ClientWebSocket()) await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
{ var clientBuffer = new byte[1024];
await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); var result = await client.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None);
var clientBuffer = new byte[1024]; Assert.True(result.EndOfMessage);
var result = await client.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None); Assert.Equal(0, result.Count);
Assert.True(result.EndOfMessage); Assert.Equal(WebSocketMessageType.Close, result.MessageType);
Assert.Equal(0, result.Count); Assert.Equal(WebSocketCloseStatus.NormalClosure, result.CloseStatus);
Assert.Equal(WebSocketMessageType.Close, result.MessageType); Assert.Equal(closeDescription, result.CloseStatusDescription);
Assert.Equal(WebSocketCloseStatus.NormalClosure, result.CloseStatus);
Assert.Equal(closeDescription, result.CloseStatusDescription);
Assert.Equal(WebSocketState.CloseReceived, client.State); Assert.Equal(WebSocketState.CloseReceived, client.State);
}
} }
} }
} }
@ -455,32 +431,30 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[ConditionalFact] [ConditionalFact]
public async Task CloseFromOpen_Success() public async Task CloseFromOpen_Success()
{ {
using (StartLog(out var loggerFactory)) string closeDescription = "Test Closed";
using (var server = KestrelWebSocketHelpers.CreateServer(LoggerFactory, async context =>
{ {
string closeDescription = "Test Closed"; Assert.True(context.WebSockets.IsWebSocketRequest);
using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context => var webSocket = await context.WebSockets.AcceptWebSocketAsync();
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);
},
ClientPort))
{
using (var client = new ClientWebSocket())
{ {
Assert.True(context.WebSockets.IsWebSocketRequest); await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
var webSocket = await context.WebSockets.AcceptWebSocketAsync(); 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.CloseAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
Assert.Equal(WebSocketState.Closed, client.State);
}
} }
} }
} }
@ -488,34 +462,32 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[ConditionalFact] [ConditionalFact]
public async Task CloseFromCloseSent_Success() public async Task CloseFromCloseSent_Success()
{ {
using (StartLog(out var loggerFactory)) string closeDescription = "Test Closed";
using (var server = KestrelWebSocketHelpers.CreateServer(LoggerFactory, async context =>
{ {
string closeDescription = "Test Closed"; Assert.True(context.WebSockets.IsWebSocketRequest);
using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context => var webSocket = await context.WebSockets.AcceptWebSocketAsync();
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);
},
ClientPort))
{
using (var client = new ClientWebSocket())
{ {
Assert.True(context.WebSockets.IsWebSocketRequest); await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
var webSocket = await context.WebSockets.AcceptWebSocketAsync(); await client.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
Assert.Equal(WebSocketState.CloseSent, client.State);
var serverBuffer = new byte[1024]; await client.CloseAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None); Assert.Equal(WebSocketState.Closed, client.State);
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);
}
} }
} }
} }
@ -523,42 +495,40 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[ConditionalFact] [ConditionalFact]
public async Task CloseFromCloseReceived_Success() public async Task CloseFromCloseReceived_Success()
{ {
using (StartLog(out var loggerFactory)) string closeDescription = "Test Closed";
using (var server = KestrelWebSocketHelpers.CreateServer(LoggerFactory, async context =>
{ {
string closeDescription = "Test Closed"; Assert.True(context.WebSockets.IsWebSocketRequest);
using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, async context => var webSocket = await context.WebSockets.AcceptWebSocketAsync();
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);
},
ClientPort))
{
using (var client = new ClientWebSocket())
{ {
Assert.True(context.WebSockets.IsWebSocketRequest); await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None);
var webSocket = await context.WebSockets.AcceptWebSocketAsync(); var clientBuffer = new byte[1024];
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);
}
} }
} }
} }
@ -573,43 +543,42 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[InlineData(HttpStatusCode.OK, "http://ExAmPLE.cOm")] [InlineData(HttpStatusCode.OK, "http://ExAmPLE.cOm")]
public async Task OriginIsValidatedForWebSocketRequests(HttpStatusCode expectedCode, params string[] origins) public async Task OriginIsValidatedForWebSocketRequests(HttpStatusCode expectedCode, params string[] origins)
{ {
using (StartLog(out var loggerFactory)) using (var server = KestrelWebSocketHelpers.CreateServer(LoggerFactory, context =>
{ {
using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, context => Assert.True(context.WebSockets.IsWebSocketRequest);
return Task.CompletedTask;
},
ClientPort,
o =>
{
if (origins != null)
{ {
Assert.True(context.WebSockets.IsWebSocketRequest); foreach (var origin in origins)
return Task.CompletedTask;
}, o =>
{
if (origins != null)
{ {
foreach (var origin in origins) o.AllowedOrigins.Add(origin);
{
o.AllowedOrigins.Add(origin);
}
} }
})) }
}))
{
using (var client = new HttpClient())
{ {
using (var client = new HttpClient()) var uri = new UriBuilder(ClientAddress);
uri.Scheme = "http";
// Craft a valid WebSocket Upgrade request
using (var request = new HttpRequestMessage(HttpMethod.Get, uri.ToString()))
{ {
var uri = new UriBuilder(ClientAddress); request.Headers.Connection.Clear();
uri.Scheme = "http"; request.Headers.Connection.Add("Upgrade");
request.Headers.Upgrade.Add(new System.Net.Http.Headers.ProductHeaderValue("websocket"));
request.Headers.Add(Constants.Headers.SecWebSocketVersion, Constants.Headers.SupportedVersion);
// SecWebSocketKey required to be 16 bytes
request.Headers.Add(Constants.Headers.SecWebSocketKey, Convert.ToBase64String(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }, Base64FormattingOptions.None));
// Craft a valid WebSocket Upgrade request request.Headers.Add("Origin", "http://example.com");
using (var request = new HttpRequestMessage(HttpMethod.Get, uri.ToString()))
{
request.Headers.Connection.Clear();
request.Headers.Connection.Add("Upgrade");
request.Headers.Upgrade.Add(new System.Net.Http.Headers.ProductHeaderValue("websocket"));
request.Headers.Add(Constants.Headers.SecWebSocketVersion, Constants.Headers.SupportedVersion);
// SecWebSocketKey required to be 16 bytes
request.Headers.Add(Constants.Headers.SecWebSocketKey, Convert.ToBase64String(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }, Base64FormattingOptions.None));
request.Headers.Add("Origin", "http://example.com"); var response = await client.SendAsync(request);
Assert.Equal(expectedCode, response.StatusCode);
var response = await client.SendAsync(request);
Assert.Equal(expectedCode, response.StatusCode);
}
} }
} }
} }
@ -618,26 +587,25 @@ namespace Microsoft.AspNetCore.WebSockets.Test
[Fact] [Fact]
public async Task OriginIsNotValidatedForNonWebSocketRequests() public async Task OriginIsNotValidatedForNonWebSocketRequests()
{ {
using (StartLog(out var loggerFactory)) using (var server = KestrelWebSocketHelpers.CreateServer(LoggerFactory, context =>
{ {
using (var server = KestrelWebSocketHelpers.CreateServer(loggerFactory, context => Assert.False(context.WebSockets.IsWebSocketRequest);
return Task.CompletedTask;
},
ClientPort,
o => o.AllowedOrigins.Add("http://example.com")))
{
using (var client = new HttpClient())
{ {
Assert.False(context.WebSockets.IsWebSocketRequest); var uri = new UriBuilder(ClientAddress);
return Task.CompletedTask; uri.Scheme = "http";
}, o => o.AllowedOrigins.Add("http://example.com")))
{ using (var request = new HttpRequestMessage(HttpMethod.Get, uri.ToString()))
using (var client = new HttpClient())
{ {
var uri = new UriBuilder(ClientAddress); request.Headers.Add("Origin", "http://notexample.com");
uri.Scheme = "http";
using (var request = new HttpRequestMessage(HttpMethod.Get, uri.ToString())) var response = await client.SendAsync(request);
{ Assert.Equal(HttpStatusCode.OK, response.StatusCode);
request.Headers.Add("Origin", "http://notexample.com");
var response = await client.SendAsync(request);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
} }
} }
} }