Add ShallowCopyHttpConnectionOptionsCopiesAllPublicProperties

Author: halter73

src/SignalR/clients/csharp/Client/src/HttpConnectionFactory.cs

@@ -96,7 +96,7 @@ public async ValueTask<ConnectionContext> ConnectAsync(EndPoint httpEndPoint, Ca
         }
 
         // Internal for testing
-        internal HttpConnectionOptions ShallowCopyHttpConnectionOptions(HttpConnectionOptions options)
+        internal static HttpConnectionOptions ShallowCopyHttpConnectionOptions(HttpConnectionOptions options)
         {
             return new HttpConnectionOptions
             {

src/SignalR/clients/csharp/Client/src/Microsoft.AspNetCore.SignalR.Client.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <Description>Client for ASP.NET Core SignalR</Description>
@@ -11,4 +11,7 @@
     <Reference Include="Microsoft.AspNetCore.Http.Connections.Client" />
   </ItemGroup>
 
+  <ItemGroup>
+    <InternalsVisibleTo Include="Microsoft.AspNetCore.SignalR.Client.Tests" />
+  </ItemGroup>
 </Project>

src/SignalR/clients/csharp/Client/test/UnitTests/HttpConnectionFactoryTests.cs

@@ -1,8 +1,16 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
 using System;
+using System.Collections.Generic;
 using System.Net;
 using System.Net.Http;
+using System.Net.WebSockets;
+using System.Reflection;
+using System.Security.Cryptography.X509Certificates;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Connections;
+using Microsoft.AspNetCore.Http.Connections;
 using Microsoft.AspNetCore.Http.Connections.Client;
 using Microsoft.AspNetCore.SignalR.Protocol;
 using Microsoft.Extensions.Logging.Abstractions;
@@ -64,5 +72,49 @@ public async Task OptionsUrlMustMatchEndPointIfSet()
             var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await factory.ConnectAsync(new HttpEndPoint(url2)));
             Assert.Equal("If HttpConnectionOptions.Url was set, it must match the HttpEndPoint.Url passed to ConnectAsync.", ex.Message);
         }
+
+        [Fact]
+        public void ShallowCopyHttpConnectionOptionsCopiesAllPublicProperties()
+        {
+            Func<HttpMessageHandler, HttpMessageHandler> handlerFactory = handler => handler;
+            Func<Task<string>> tokenProvider = () => Task.FromResult("");
+            Action<ClientWebSocketOptions> webSocketConfig = options => { };
+
+            var testValues = new Dictionary<string, object>
+            {
+                { $"{nameof(HttpConnectionOptions.HttpMessageHandlerFactory)}", handlerFactory },
+                { $"{nameof(HttpConnectionOptions.Headers)}", new Dictionary<string, string>() },
+                { $"{nameof(HttpConnectionOptions.ClientCertificates)}", new X509CertificateCollection() },
+                { $"{nameof(HttpConnectionOptions.Cookies)}", new CookieContainer() },
+                { $"{nameof(HttpConnectionOptions.Url)}", new Uri("https://example.com") },
+                { $"{nameof(HttpConnectionOptions.Transports)}", HttpTransportType.ServerSentEvents },
+                { $"{nameof(HttpConnectionOptions.SkipNegotiation)}", true },
+                { $"{nameof(HttpConnectionOptions.AccessTokenProvider)}", tokenProvider },
+                { $"{nameof(HttpConnectionOptions.CloseTimeout)}", TimeSpan.FromDays(1) },
+                { $"{nameof(HttpConnectionOptions.Credentials)}", Mock.Of<ICredentials>() },
+                { $"{nameof(HttpConnectionOptions.Proxy)}", Mock.Of<IWebProxy>() },
+                { $"{nameof(HttpConnectionOptions.UseDefaultCredentials)}", true },
+                { $"{nameof(HttpConnectionOptions.WebSocketConfiguration)}", webSocketConfig },
+            };
+
+            var options = new HttpConnectionOptions();
+            var properties = typeof(HttpConnectionOptions)
+                .GetProperties(BindingFlags.Public | BindingFlags.Instance);
+
+            foreach (var property in properties)
+            {
+                property.SetValue(options, testValues[property.Name]);
+            }
+
+            var shallowCopiedOptions = HttpConnectionFactory.ShallowCopyHttpConnectionOptions(options);
+
+            foreach (var property in properties)
+            {
+                Assert.Equal(testValues[property.Name], property.GetValue(shallowCopiedOptions));
+                testValues.Remove(property.Name);
+            }
+
+            Assert.Empty(testValues);
+        }
     }
 }