use xunit API + use handshake timeout

Author: DeagleGross

src/Servers/Kestrel/Core/test/TlsListenerTests.cs

@@ -70,9 +70,7 @@ public async Task RunTlsClientHelloCallbackTest_WithExtraShortLastingToken()
         var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(3));
 
         await writer.WriteAsync(new byte[1] { 0x16 });
-        await VerifyThrowsAnyAsync(
-            async () => await listener.OnTlsClientHelloAsync(transportConnection, cts.Token),
-            typeof(OperationCanceledException), typeof(TaskCanceledException));
+        await Assert.ThrowsAnyAsync<OperationCanceledException>(() => listener.OnTlsClientHelloAsync(transportConnection, cts.Token));
         Assert.False(tlsClientHelloCallbackInvoked);
     }
 
@@ -95,9 +93,7 @@ public async Task RunTlsClientHelloCallbackTest_WithPreCanceledToken()
         cts.Cancel();
 
         await writer.WriteAsync(new byte[1] { 0x16 });
-        await VerifyThrowsAnyAsync(
-            async () => await listener.OnTlsClientHelloAsync(transportConnection, cts.Token),
-            typeof(OperationCanceledException), typeof(TaskCanceledException));
+        await Assert.ThrowsAnyAsync<OperationCanceledException>(() => listener.OnTlsClientHelloAsync(transportConnection, cts.Token));
         Assert.False(tlsClientHelloCallbackInvoked);
     }
 
@@ -122,7 +118,7 @@ public async Task RunTlsClientHelloCallbackTest_WithPendingCancellation()
         await writer.WriteAsync(new byte[2] { 0x03, 0x01 });
         cts.Cancel();
 
-        await VerifyThrowsAnyAsync(() => listenerTask, typeof(OperationCanceledException), typeof(TaskCanceledException));
+        await Assert.ThrowsAnyAsync<OperationCanceledException>(() => listenerTask);
         Assert.False(tlsClientHelloCallbackInvoked);
     }
 
@@ -623,28 +619,4 @@ public static IEnumerable<object[]> InvalidClientHelloData_Segmented()
         _invalidTlsClientHelloHeader, _invalid3BytesMessage, _invalid9BytesMessage,
         _invalidUnknownProtocolVersion1, _invalidUnknownProtocolVersion2, _invalidIncorrectHandshakeMessageType
     };
-
-    static async Task VerifyThrowsAnyAsync(Func<Task> code, params Type[] exceptionTypes)
-    {
-        if (exceptionTypes == null || exceptionTypes.Length == 0)
-        {
-            throw new ArgumentException("At least one exception type must be provided.", nameof(exceptionTypes));
-        }
-
-        try
-        {
-            await code();
-        }
-        catch (Exception ex)
-        {
-            if (exceptionTypes.Any(type => type.IsInstanceOfType(ex)))
-            {
-                return;
-            }
-
-            throw ThrowsException.ForIncorrectExceptionType(exceptionTypes.First(), ex);
-        }
-
-        throw ThrowsException.ForNoException(exceptionTypes.First());
-    }
 }

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

@@ -18,6 +18,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
+using Newtonsoft.Json.Linq;
 using Xunit.Sdk;
 
 namespace InMemory.FunctionalTests;
@@ -97,19 +98,59 @@ public async Task TlsClientHelloBytesCallback_PreCanceledToken()
                     var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
                     var token = cancellationTokenSource.Token;
 
+                    await Assert.ThrowsAnyAsync<OperationCanceledException>(() => sslStream.AuthenticateAsClientAsync(new SslClientAuthenticationOptions
+                    {
+                        TargetHost = "localhost",
+                        EnabledSslProtocols = SslProtocols.None
+                    }, token));
+                }
+            }
+        }
+
+        Assert.False(tlsClientHelloCallbackInvoked);
+    }
+
+    [Fact]
+    public async Task TlsClientHelloBytesCallback_UsesOptionsTimeout()
+    {
+        var testContext = new TestServiceContext(LoggerFactory);
+        await using (var server = new TestServer(context => Task.CompletedTask,
+            testContext,
+            listenOptions =>
+            {
+                listenOptions.UseHttps(_x509Certificate2, httpsOptions =>
+                {
+                    httpsOptions.HandshakeTimeout = TimeSpan.FromMilliseconds(1);
+
+                    httpsOptions.TlsClientHelloBytesCallback = (connection, clientHelloBytes) =>
+                    {
+                        Logger.LogDebug("[Received TlsClientHelloBytesCallback] Connection: {0}; TLS client hello buffer: {1}", connection.ConnectionId, clientHelloBytes.Length);
+                        Assert.True(clientHelloBytes.Length > 32);
+                        Assert.NotNull(connection);
+                    };
+                });
+            }))
+        {
+            using (var connection = server.CreateConnection())
+            {
+                using (var sslStream = new SslStream(connection.Stream, false, (sender, cert, chain, errors) => true, null))
+                {
                     try
                     {
                         await sslStream.AuthenticateAsClientAsync(new SslClientAuthenticationOptions
                         {
                             TargetHost = "localhost",
                             EnabledSslProtocols = SslProtocols.None
-                        }, token);
+                        });
 
                         var request = Encoding.ASCII.GetBytes("GET / HTTP/1.1\r\nHost:\r\n\r\n");
-                        await sslStream.WriteAsync(request, 0, request.Length, token);
-                        await sslStream.ReadAsync(new Memory<byte>(new byte[1024]), token);
+                        await sslStream.WriteAsync(request, 0, request.Length);
+                        await sslStream.ReadAsync(new Memory<byte>(new byte[1024]));
                     }
-                    catch (Exception ex) when (ex is OperationCanceledException or TaskCanceledException)
+                    catch (Exception ex)
+                        when (ex is OperationCanceledException or TaskCanceledException // when cancellation comes from tls listener
+                                 or IOException // when the underlying stream is closed due to timeout
+                    )
                     {
                         // expected
                     }
@@ -120,7 +161,5 @@ await sslStream.AuthenticateAsClientAsync(new SslClientAuthenticationOptions
                 }
             }
         }
-
-        Assert.False(tlsClientHelloCallbackInvoked);
     }
 }