Add DefautCredentials_WebSocket_Success

Author: halter73

src/Security/Authentication/Negotiate/test/Negotiate.FunctionalTest/Microsoft.AspNetCore.Authentication.Negotiate.FunctionalTest.csproj

@@ -9,6 +9,7 @@
     <Reference Include="Microsoft.AspNetCore.Authentication.Negotiate" />
     <Reference Include="Microsoft.AspNetCore.Routing" />
     <Reference Include="Microsoft.AspNetCore.Server.Kestrel" />
+    <Reference Include="Microsoft.AspNetCore.WebSockets" />
     <Reference Include="Microsoft.Extensions.Hosting" />
     <Reference Include="System.Net.Http.WinHttpHandler" />
   </ItemGroup>

src/Security/Authentication/Negotiate/test/Negotiate.FunctionalTest/NegotiateHandlerFunctionalTests.cs

@@ -6,6 +6,9 @@
 using System.Linq;
 using System.Net;
 using System.Net.Http;
+using System.Net.WebSockets;
+using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
@@ -23,7 +26,7 @@ namespace Microsoft.AspNetCore.Authentication.Negotiate
 {
     // In theory this would work on Linux and Mac, but the client would require explicit credentials.
     [OSSkipCondition(OperatingSystems.Linux | OperatingSystems.MacOSX)]
-    public class NegotiateHandlerFunctionalTests
+    public class NegotiateHandlerFunctionalTests : LoggedTest
     {
         private static readonly Version Http11Version = new Version(1, 1);
         private static readonly Version Http2Version = new Version(2, 0);
@@ -109,6 +112,34 @@ public async Task DefautCredentials_Success(Version version)
             Assert.Equal(Http11Version, result.Version); // HTTP/2 downgrades.
         }
 
+        [ConditionalFact]
+        public async Task DefautCredentials_WebSocket_Success()
+        {
+            using var host = await CreateHostAsync();
+
+            var address = host.Services.GetRequiredService<IServer>().Features.Get<IServerAddressesFeature>().Addresses.First().Replace("https://", "wss://");
+
+            using var webSocket = new ClientWebSocket
+            {
+                Options =
+                {
+                    RemoteCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) => true,
+                    UseDefaultCredentials = true,
+                }
+            };
+
+            using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
+
+            await webSocket.ConnectAsync(new Uri($"{address}/AuthenticateWebSocket"), cts.Token);
+
+            var receiveBuffer = new byte[13];
+            var receiveResult = await webSocket.ReceiveAsync(receiveBuffer, cts.Token);
+
+            Assert.True(receiveResult.EndOfMessage);
+            Assert.Equal(WebSocketMessageType.Text, receiveResult.MessageType);
+            Assert.Equal("Hello World!", Encoding.UTF8.GetString(receiveBuffer, 0, receiveResult.Count));
+        }
+
         public static IEnumerable<object[]> HttpOrders =>
             new List<object[]>
             {
@@ -232,9 +263,10 @@ public async Task UnauthorizedAfterAuthenticated_Success(Version version)
             Assert.Equal(Http11Version, result.Version); // HTTP/2 downgrades.
         }
 
-        private static Task<IHost> CreateHostAsync(Action<NegotiateOptions> configureOptions = null)
+        private Task<IHost> CreateHostAsync(Action<NegotiateOptions> configureOptions = null)
         {
             var builder = new HostBuilder()
+                .ConfigureServices(AddTestLogging)
                 .ConfigureServices(services => services
                     .AddRouting()
                     .AddAuthentication(NegotiateDefaults.AuthenticationScheme)
@@ -252,6 +284,7 @@ private static Task<IHost> CreateHostAsync(Action<NegotiateOptions> configureOpt
                     {
                         app.UseRouting();
                         app.UseAuthentication();
+                        app.UseWebSockets();
                         app.UseEndpoints(ConfigureEndpoints);
                     });
                 });
@@ -289,6 +322,27 @@ private static void ConfigureEndpoints(IEndpointRouteBuilder builder)
                 await context.Response.WriteAsync(name);
             });
 
+            builder.Map("/AuthenticateWebSocket", async context =>
+            {
+                if (!context.User.Identity.IsAuthenticated)
+                {
+                    await context.ChallengeAsync();
+                    return;
+                }
+
+                if (!context.WebSockets.IsWebSocketRequest)
+                {
+                    context.Response.StatusCode = 400;
+                    return;
+                }
+
+                Assert.False(string.IsNullOrEmpty(context.User.Identity.Name), "name");
+
+                WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync();
+
+                await webSocket.SendAsync(Encoding.UTF8.GetBytes("Hello World!"), WebSocketMessageType.Text, endOfMessage: true, context.RequestAborted);
+            });
+
             builder.Map("/AlreadyAuthenticated", async context =>
             {
                 Assert.Equal("HTTP/1.1", context.Request.Protocol); // Not HTTP/2

src/Servers/Kestrel/test/InMemory.FunctionalTests/UpgradeTests.cs

@@ -10,7 +10,6 @@
 using Microsoft.AspNetCore.Server.Kestrel.InMemory.FunctionalTests.TestTransport;
 using Microsoft.AspNetCore.Server.Kestrel.Tests;
 using Microsoft.AspNetCore.Testing;
-using Microsoft.Extensions.Logging.Testing;
 using Xunit;
 
 namespace Microsoft.AspNetCore.Server.Kestrel.InMemory.FunctionalTests