tests

Author: DeagleGross

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

@@ -158,8 +158,8 @@ public async Task RunTlsClientHelloCallbackTest_DeterministicallyReads()
         Assert.Equal(5, readResult.Buffer.Length);
 
         // ensuring that we have read limited number of times
-        Assert.True(reader.ReadAsyncCounter is >= 2 && reader.ReadAsyncCounter is <= 4,
-            $"Expected ReadAsync() to happen about 2-4 times. Actually happened {reader.ReadAsyncCounter} times.");
+        Assert.True(reader.ReadAsyncCounter is >= 2 && reader.ReadAsyncCounter is <= 5,
+            $"Expected ReadAsync() to happen about 2-5 times. Actually happened {reader.ReadAsyncCounter} times.");
     }
 
     private async Task RunTlsClientHelloCallbackTest_WithMultipleSegments(

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 Xunit.Sdk;
 
 namespace InMemory.FunctionalTests;
 
@@ -66,4 +67,60 @@ await sslStream.AuthenticateAsClientAsync(new SslClientAuthenticationOptions
 
         Assert.True(tlsClientHelloCallbackInvoked);
     }
+
+    [Fact]
+    public async Task TlsClientHelloBytesCallback_PreCanceledToken()
+    {
+        var tlsClientHelloCallbackInvoked = false;
+
+        var testContext = new TestServiceContext(LoggerFactory);
+        await using (var server = new TestServer(context => Task.CompletedTask,
+            testContext,
+            listenOptions =>
+            {
+                listenOptions.UseHttps(_x509Certificate2, httpsOptions =>
+                {
+                    httpsOptions.TlsClientHelloBytesCallback = (connection, clientHelloBytes) =>
+                    {
+                        Logger.LogDebug("[Received TlsClientHelloBytesCallback] Connection: {0}; TLS client hello buffer: {1}", connection.ConnectionId, clientHelloBytes.Length);
+                        tlsClientHelloCallbackInvoked = true;
+                        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))
+                {
+                    var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromMilliseconds(1));
+                    var token = cancellationTokenSource.Token;
+
+                    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);
+                    }
+                    catch (Exception ex) when (ex is OperationCanceledException or TaskCanceledException)
+                    {
+                        // expected
+                    }
+                    catch (Exception ex)
+                    {
+                        ThrowsException.ForIncorrectExceptionType(typeof(OperationCanceledException), ex);
+                    }
+                }
+            }
+        }
+
+        Assert.False(tlsClientHelloCallbackInvoked);
+    }
 }