Remove reference to HttpEndPoint from HttpConnection

halter73 · halter73 · commit d6e17faf8660 · 2019-06-23T20:35:43.000-07:00
diff --git a/src/SignalR/clients/csharp/Client/src/HttpConnectionFactory.cs b/src/SignalR/clients/csharp/Client/src/HttpConnectionFactory.cs
@@ -61,19 +61,26 @@ public HttpConnectionFactory(IHubProtocol hubProtocol, IOptions<HttpConnectionOp
         /// </returns>
         public async ValueTask<ConnectionContext> ConnectAsync(EndPoint httpEndPoint, CancellationToken cancellationToken = default)
         {
-            var castedHttpEndPoint = httpEndPoint as HttpEndPoint;
-
             if (httpEndPoint == null)
             {
                 throw new ArgumentNullException(nameof(httpEndPoint));
             }
 
+            var castedHttpEndPoint = httpEndPoint as HttpEndPoint;
             if (castedHttpEndPoint == null)
             {
                 throw new NotSupportedException($"The provided {nameof(EndPoint)} must be of type {nameof(HttpEndPoint)}.");
             }
 
-            var connection = new HttpConnection(castedHttpEndPoint, _httpConnectionOptions, _transferFormat, _loggerFactory);
+            if (_httpConnectionOptions.Url != null && _httpConnectionOptions.Url != castedHttpEndPoint.Url)
+            {
+                throw new InvalidOperationException($"If {nameof(HttpConnectionOptions)}.{nameof(HttpConnectionOptions.Url)} was set, it must match the {nameof(HttpEndPoint)}.{nameof(HttpEndPoint.Url)} passed to {nameof(ConnectAsync)}.");
+            }
+
+            var shallowCopiedOptions = ShallowCopyHttpConnectionOptions(_httpConnectionOptions);
+            shallowCopiedOptions.Url ??= castedHttpEndPoint.Url;
+
+            var connection = new HttpConnection(shallowCopiedOptions, _transferFormat, _loggerFactory);
 
             try
             {
@@ -87,5 +94,26 @@ public async ValueTask<ConnectionContext> ConnectAsync(EndPoint httpEndPoint, Ca
                 throw;
             }
         }
+
+        // Internal for testing
+        internal HttpConnectionOptions ShallowCopyHttpConnectionOptions(HttpConnectionOptions options)
+        {
+            return new HttpConnectionOptions
+            {
+                HttpMessageHandlerFactory = options.HttpMessageHandlerFactory,
+                Headers = options.Headers,
+                ClientCertificates = options.ClientCertificates,
+                Cookies = options.Cookies,
+                Url = options.Url,
+                Transports = options.Transports,
+                SkipNegotiation = options.SkipNegotiation,
+                AccessTokenProvider = options.AccessTokenProvider,
+                CloseTimeout = options.CloseTimeout,
+                Credentials = options.Credentials,
+                Proxy = options.Proxy,
+                UseDefaultCredentials = options.UseDefaultCredentials,
+                WebSocketConfiguration = options.WebSocketConfiguration,
+            };
+        }
     }
 }
diff --git a/src/SignalR/clients/csharp/Client/test/FunctionalTests/HubConnectionTests.cs b/src/SignalR/clients/csharp/Client/test/FunctionalTests/HubConnectionTests.cs
@@ -73,7 +73,7 @@ private Func<EndPoint, ValueTask<ConnectionContext>> GetHttpConnectionFactory(st
             {
                 var httpEndpoint = (HttpEndPoint)endPoint;
                 var options = new HttpConnectionOptions { Url = httpEndpoint.Url, Transports = transportType };
-                var connection = new HttpConnection(httpEndpoint, options, transferFormat, loggerFactory);
+                var connection = new HttpConnection(options, transferFormat, loggerFactory);
 
                 await connection.StartAsync();
 
diff --git a/src/SignalR/clients/csharp/Client/test/UnitTests/HttpConnectionFactoryTests.cs b/src/SignalR/clients/csharp/Client/test/UnitTests/HttpConnectionFactoryTests.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Net;
 using System.Net.Http;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Connections;
@@ -32,5 +33,36 @@ public async Task ConnectionIsDisposedIfItFailsToStartAsync()
             // We care that the handler (and by extension the client) was disposed
             Assert.True(testHandler.Disposed);
         }
+
+        [Fact]
+        public async Task DoesNotSupportNonHttpEndPoints()
+        {
+            var factory = new HttpConnectionFactory(
+                Mock.Of<IHubProtocol>(p => p.TransferFormat == TransferFormat.Text),
+                Options.Create(new HttpConnectionOptions()),
+                NullLoggerFactory.Instance);
+
+            var ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await factory.ConnectAsync(new IPEndPoint(IPAddress.Loopback, 0)));
+
+            Assert.Equal("The provided EndPoint must be of type HttpEndPoint.", ex.Message);
+        }
+
+        [Fact]
+        public async Task OptionsUrlMustMatchEndPointIfSet()
+        {
+            var url1 = new Uri("http://example.com/1");
+            var url2 = new Uri("http://example.com/2");
+
+            var factory = new HttpConnectionFactory(
+                Mock.Of<IHubProtocol>(p => p.TransferFormat == TransferFormat.Text),
+                Options.Create(new HttpConnectionOptions
+                {
+                    Url = url1
+                }),
+                NullLoggerFactory.Instance);
+
+            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);
+        }
     }
 }
diff --git a/src/SignalR/clients/csharp/Client/test/UnitTests/HubConnectionBuilderTests.cs b/src/SignalR/clients/csharp/Client/test/UnitTests/HubConnectionBuilderTests.cs
@@ -63,7 +63,7 @@ public void BuildCanOnlyBeCalledOnce()
         {
             var builder = new HubConnectionBuilder();
             builder.Services.AddSingleton<IConnectionFactory>(new HttpConnectionFactory(Mock.Of<IHubProtocol>(), Options.Create(new HttpConnectionOptions()), NullLoggerFactory.Instance));
-            builder.WithUrl("https://www.example.com");
+            builder.WithUrl("http://example.com");
 
             Assert.NotNull(builder.Build());
 
diff --git a/src/SignalR/clients/csharp/Client/test/UnitTests/HubConnectionTests.ConnectionLifecycle.cs b/src/SignalR/clients/csharp/Client/test/UnitTests/HubConnectionTests.ConnectionLifecycle.cs
@@ -84,7 +84,7 @@ ValueTask<ConnectionContext> ConnectionFactory(EndPoint endPoint)
                     createCount += 1;
                     return new TestConnection().StartAsync();
                 }
-                var builder = new HubConnectionBuilder().WithUrl("https://www.example.com");
+                var builder = new HubConnectionBuilder().WithUrl("http://example.com");
                 var delegateConnectionFactory = new DelegateConnectionFactory(ConnectionFactory);
                 builder.Services.AddSingleton<IConnectionFactory>(delegateConnectionFactory);
 
@@ -117,7 +117,7 @@ ValueTask<ConnectionContext> ConnectionFactory(EndPoint endPoint)
                     return new TestConnection(onDispose: createCount == 1 ? onDisposeForFirstConnection : null).StartAsync();
                 }
 
-                var builder = new HubConnectionBuilder().WithUrl("https://www.example.com");
+                var builder = new HubConnectionBuilder().WithUrl("http://example.com");
                 var delegateConnectionFactory = new DelegateConnectionFactory(ConnectionFactory);
                 builder.Services.AddSingleton<IConnectionFactory>(delegateConnectionFactory);
 
@@ -589,7 +589,7 @@ bool ExpectedErrors(WriteContext writeContext)
             [Fact]
             public async Task HubConnectionClosesWithErrorIfTerminatedWithPartialMessage()
             {
-                var builder = new HubConnectionBuilder().WithUrl("https://www.example.com");
+                var builder = new HubConnectionBuilder().WithUrl("http://example.com");
                 var innerConnection = new TestConnection();
 
                 var delegateConnectionFactory = new DelegateConnectionFactory(
diff --git a/src/SignalR/clients/csharp/Client/test/UnitTests/HubConnectionTests.Helpers.cs b/src/SignalR/clients/csharp/Client/test/UnitTests/HubConnectionTests.Helpers.cs
@@ -13,7 +13,7 @@ public partial class HubConnectionTests
     {
         private static HubConnection CreateHubConnection(TestConnection connection, IHubProtocol protocol = null, ILoggerFactory loggerFactory = null)
         {
-            var builder = new HubConnectionBuilder().WithUrl("https://www.example.com");
+            var builder = new HubConnectionBuilder().WithUrl("http://example.com");
 
             var delegateConnectionFactory = new DelegateConnectionFactory(
                 endPoint => connection.StartAsync());
diff --git a/src/SignalR/clients/csharp/Client/test/UnitTests/HubConnectionTests.Reconnect.cs b/src/SignalR/clients/csharp/Client/test/UnitTests/HubConnectionTests.Reconnect.cs
@@ -78,7 +78,7 @@ bool ExpectedErrors(WriteContext writeContext)
 
                 using (StartVerifiableLog(ExpectedErrors))
                 {
-                    var builder = new HubConnectionBuilder().WithLoggerFactory(LoggerFactory).WithUrl("https://www.example.com");
+                    var builder = new HubConnectionBuilder().WithLoggerFactory(LoggerFactory).WithUrl("http://example.com");
                     var testConnectionFactory = default(ReconnectingConnectionFactory);
                     var startCallCount = 0;
                     var originalConnectionId = "originalConnectionId";
@@ -192,7 +192,7 @@ bool ExpectedErrors(WriteContext writeContext)
 
                 using (StartVerifiableLog(ExpectedErrors))
                 {
-                    var builder = new HubConnectionBuilder().WithLoggerFactory(LoggerFactory).WithUrl("https://www.example.com");
+                    var builder = new HubConnectionBuilder().WithLoggerFactory(LoggerFactory).WithUrl("http://example.com");
                     var startCallCount = 0;
 
                     Task OnTestConnectionStart()
@@ -284,7 +284,7 @@ bool ExpectedErrors(WriteContext writeContext)
 
                 using (StartVerifiableLog(ExpectedErrors))
                 {
-                    var builder = new HubConnectionBuilder().WithLoggerFactory(LoggerFactory).WithUrl("https://www.example.com");
+                    var builder = new HubConnectionBuilder().WithLoggerFactory(LoggerFactory).WithUrl("http://example.com");
                     var testConnectionFactory = new ReconnectingConnectionFactory();
                     builder.Services.AddSingleton<IConnectionFactory>(testConnectionFactory);
 
@@ -379,7 +379,7 @@ bool ExpectedErrors(WriteContext writeContext)
 
                 using (StartVerifiableLog(ExpectedErrors))
                 {
-                    var builder = new HubConnectionBuilder().WithLoggerFactory(LoggerFactory).WithUrl("https://www.example.com");
+                    var builder = new HubConnectionBuilder().WithLoggerFactory(LoggerFactory).WithUrl("http://example.com");
                     var testConnectionFactory = new ReconnectingConnectionFactory();
                     builder.Services.AddSingleton<IConnectionFactory>(testConnectionFactory);
 
@@ -434,7 +434,7 @@ bool ExpectedErrors(WriteContext writeContext)
 
                 using (StartVerifiableLog(ExpectedErrors))
                 {
-                    var builder = new HubConnectionBuilder().WithLoggerFactory(LoggerFactory).WithUrl("https://www.example.com");
+                    var builder = new HubConnectionBuilder().WithLoggerFactory(LoggerFactory).WithUrl("http://example.com");
                     var testConnectionFactory = new ReconnectingConnectionFactory(() => new TestConnection(autoHandshake: false));
                     builder.Services.AddSingleton<IConnectionFactory>(testConnectionFactory);
 
@@ -492,7 +492,7 @@ bool ExpectedErrors(WriteContext writeContext)
 
                 using (StartVerifiableLog(ExpectedErrors))
                 {
-                    var builder = new HubConnectionBuilder().WithLoggerFactory(LoggerFactory).WithUrl("https://www.example.com");
+                    var builder = new HubConnectionBuilder().WithLoggerFactory(LoggerFactory).WithUrl("http://example.com");
                     var testConnectionFactory = new ReconnectingConnectionFactory(() => new TestConnection(autoHandshake: false));
                     builder.Services.AddSingleton<IConnectionFactory>(testConnectionFactory);
 
@@ -599,7 +599,7 @@ bool ExpectedErrors(WriteContext writeContext)
 
                 using (StartVerifiableLog(ExpectedErrors))
                 {
-                    var builder = new HubConnectionBuilder().WithLoggerFactory(LoggerFactory).WithUrl("https://www.example.com");
+                    var builder = new HubConnectionBuilder().WithLoggerFactory(LoggerFactory).WithUrl("http://example.com");
                     var testConnectionFactory = new ReconnectingConnectionFactory(() => new TestConnection(autoHandshake: false));
                     builder.Services.AddSingleton<IConnectionFactory>(testConnectionFactory);
 
@@ -718,7 +718,7 @@ bool ExpectedErrors(WriteContext writeContext)
 
                 using (StartVerifiableLog(ExpectedErrors))
                 {
-                    var builder = new HubConnectionBuilder().WithLoggerFactory(LoggerFactory).WithUrl("https://www.example.com");
+                    var builder = new HubConnectionBuilder().WithLoggerFactory(LoggerFactory).WithUrl("http://example.com");
                     var connectionStartTcs = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
 
                     async Task OnTestConnectionStart()
@@ -809,7 +809,7 @@ bool ExpectedErrors(WriteContext writeContext)
 
                 using (StartVerifiableLog(ExpectedErrors))
                 {
-                    var builder = new HubConnectionBuilder().WithLoggerFactory(LoggerFactory).WithUrl("https://www.example.com");
+                    var builder = new HubConnectionBuilder().WithLoggerFactory(LoggerFactory).WithUrl("http://example.com");
                     var testConnectionFactory = new ReconnectingConnectionFactory();
                     builder.Services.AddSingleton<IConnectionFactory>(testConnectionFactory);
 
diff --git a/src/SignalR/clients/csharp/Client/test/UnitTests/HubConnectionTests.cs b/src/SignalR/clients/csharp/Client/test/UnitTests/HubConnectionTests.cs
@@ -59,7 +59,7 @@ public async Task SendAsyncThrowsIfSerializingMessageFails()
         [Fact]
         public async Task ClosedEventRaisedWhenTheClientIsStopped()
         {
-            var builder = new HubConnectionBuilder().WithUrl("https://www.example.com");
+            var builder = new HubConnectionBuilder().WithUrl("http://example.com");
 
             var delegateConnectionFactory = new DelegateConnectionFactory(
                 endPoint => new TestConnection().StartAsync());
diff --git a/src/SignalR/clients/csharp/Http.Connections.Client/src/HttpConnection.cs b/src/SignalR/clients/csharp/Http.Connections.Client/src/HttpConnection.cs
@@ -37,7 +37,6 @@ public partial class HttpConnection : ConnectionContext, IConnectionInherentKeep
         private bool _disposed;
         private bool _hasInherentKeepAlive;
 
-        private readonly HttpEndPoint _httpEndPoint;
         private readonly HttpClient _httpClient;
         private readonly HttpConnectionOptions _httpConnectionOptions;
         private readonly TransferFormat _transferFormat;
@@ -130,11 +129,17 @@ private static HttpConnectionOptions CreateHttpOptions(Uri url, HttpTransportTyp
         /// <param name="httpConnectionOptions">The connection options to use.</param>
         /// <param name="loggerFactory">The logger factory.</param>
         public HttpConnection(HttpConnectionOptions httpConnectionOptions, ILoggerFactory loggerFactory)
-            : this(ValidateHttpConnnectionOptionAndCreateHttpEndpoint(httpConnectionOptions), httpConnectionOptions, TransferFormat.Binary, loggerFactory)
+            : this(httpConnectionOptions, TransferFormat.Binary, loggerFactory)
         {
         }
 
-        private static HttpEndPoint ValidateHttpConnnectionOptionAndCreateHttpEndpoint(HttpConnectionOptions httpConnectionOptions)
+        /// <summary>
+        /// Initializes a new instance of the <see cref="HttpConnection"/> class.
+        /// </summary>
+        /// <param name="httpConnectionOptions">The connection options to use.</param>
+        /// <param name="transferFormat">The transfer format the connection should use.</param>
+        /// <param name="loggerFactory">The logger factory.</param>
+        public HttpConnection(HttpConnectionOptions httpConnectionOptions, TransferFormat transferFormat, ILoggerFactory loggerFactory)
         {
             if (httpConnectionOptions == null)
             {
@@ -146,30 +151,12 @@ private static HttpEndPoint ValidateHttpConnnectionOptionAndCreateHttpEndpoint(H
                 throw new ArgumentException("Options does not have a URL specified.", nameof(httpConnectionOptions));
             }
 
-            return new HttpEndPoint(httpConnectionOptions.Url);
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="HttpConnection"/> class.
-        /// </summary>
-        /// <param name="httpEndPoint">The <see cref="HttpEndPoint"/> to connect to. This overrides <see cref="HttpConnectionOptions.Url"/>.</param>
-        /// <param name="httpConnectionOptions">The connection options to use.</param>
-        /// <param name="transferFormat">The transfer format the connection should use.</param>
-        /// <param name="loggerFactory">The logger factory.</param>
-        public HttpConnection(HttpEndPoint httpEndPoint, HttpConnectionOptions httpConnectionOptions, TransferFormat transferFormat, ILoggerFactory loggerFactory)
-        {
             _loggerFactory = loggerFactory ?? NullLoggerFactory.Instance;
 
             _logger = _loggerFactory.CreateLogger<HttpConnection>();
-            _httpEndPoint = httpEndPoint ?? throw new ArgumentNullException(nameof(httpEndPoint));
             _httpConnectionOptions = httpConnectionOptions ?? throw new ArgumentNullException(nameof(httpConnectionOptions));
             _transferFormat = transferFormat;
 
-            if (httpConnectionOptions.Url != null && httpConnectionOptions.Url != httpEndPoint.Url)
-            {
-                throw new InvalidOperationException($"If {nameof(HttpConnectionOptions)}.{nameof(HttpConnectionOptions.Url)} is set, it must match {nameof(HttpEndPoint)}.{nameof(httpEndPoint.Url)}.");
-            }
-
             if (!httpConnectionOptions.SkipNegotiation || httpConnectionOptions.Transports != HttpTransportType.WebSockets)
             {
                 _httpClient = CreateHttpClient();
@@ -183,7 +170,7 @@ public HttpConnection(HttpEndPoint httpEndPoint, HttpConnectionOptions httpConne
 
         // Used by unit tests
         internal HttpConnection(HttpConnectionOptions httpConnectionOptions, TransferFormat transferFormat, ILoggerFactory loggerFactory, ITransportFactory transportFactory)
-            : this(new HttpEndPoint(httpConnectionOptions.Url), httpConnectionOptions, transferFormat, loggerFactory)
+            : this(httpConnectionOptions, transferFormat, loggerFactory)
         {
             // Don't null out the _transportFactory if one isn't provided.
             if (transportFactory != null)
@@ -299,7 +286,7 @@ private async Task DisposeAsyncCore()
 
         private async Task SelectAndStartTransport(TransferFormat transferFormat, CancellationToken cancellationToken)
         {
-            var uri = _httpEndPoint.Url;
+            var uri = _httpConnectionOptions.Url;
             // Set the initial access token provider back to the original one from options
             _accessTokenProvider = _httpConnectionOptions.AccessTokenProvider;
 
diff --git a/src/SignalR/samples/ClientSample/RawSample.cs b/src/SignalR/samples/ClientSample/RawSample.cs
@@ -35,8 +35,7 @@ public static async Task<int> ExecuteAsync(string baseUrl)
 
             Console.WriteLine($"Connecting to {baseUrl}...");
 
-            var uri = new Uri(baseUrl);
-            var connection = new HttpConnection(new HttpEndPoint(uri), new HttpConnectionOptions(), TransferFormat.Text, loggerFactory: null);
+            var connection = new HttpConnection(new HttpConnectionOptions() { Url = new Uri(baseUrl) }, TransferFormat.Text, loggerFactory: null);
 
             try
             {
diff --git a/src/SignalR/server/SignalR/test/EndToEndTests.cs b/src/SignalR/server/SignalR/test/EndToEndTests.cs

Original file line number	Diff line number	Diff line change
`@@ -61,19 +61,26 @@ public HttpConnectionFactory(IHubProtocol hubProtocol, IOptions<HttpConnectionOp`
`61`	`61`	`/// </returns>`
`62`	`62`	`public async ValueTask<ConnectionContext> ConnectAsync(EndPoint httpEndPoint, CancellationToken cancellationToken = default)`
`63`	`63`	`{`
`64`		`- var castedHttpEndPoint = httpEndPoint as HttpEndPoint;`
`65`		`-`
`66`	`64`	`if (httpEndPoint == null)`
`67`	`65`	`{`
`68`	`66`	`throw new ArgumentNullException(nameof(httpEndPoint));`
`69`	`67`	`}`
`70`	`68`
	`69`	`+ var castedHttpEndPoint = httpEndPoint as HttpEndPoint;`
`71`	`70`	`if (castedHttpEndPoint == null)`
`72`	`71`	`{`
`73`	`72`	`throw new NotSupportedException($"The provided {nameof(EndPoint)} must be of type {nameof(HttpEndPoint)}.");`
`74`	`73`	`}`
`75`	`74`
`76`		`- var connection = new HttpConnection(castedHttpEndPoint, _httpConnectionOptions, _transferFormat, _loggerFactory);`
	`75`	`+ if (_httpConnectionOptions.Url != null && _httpConnectionOptions.Url != castedHttpEndPoint.Url)`
	`76`	`+ {`
	`77`	`+ throw new InvalidOperationException($"If {nameof(HttpConnectionOptions)}.{nameof(HttpConnectionOptions.Url)} was set, it must match the {nameof(HttpEndPoint)}.{nameof(HttpEndPoint.Url)} passed to {nameof(ConnectAsync)}.");`
	`78`	`+ }`
	`79`	`+`
	`80`	`+ var shallowCopiedOptions = ShallowCopyHttpConnectionOptions(_httpConnectionOptions);`
	`81`	`+ shallowCopiedOptions.Url ??= castedHttpEndPoint.Url;`
	`82`	`+`
	`83`	`+ var connection = new HttpConnection(shallowCopiedOptions, _transferFormat, _loggerFactory);`
`77`	`84`
`78`	`85`	`try`
`79`	`86`	`{`
`@@ -87,5 +94,26 @@ public async ValueTask<ConnectionContext> ConnectAsync(EndPoint httpEndPoint, Ca`
`87`	`94`	`throw;`
`88`	`95`	`}`
`89`	`96`	`}`
	`97`	`+`
	`98`	`+ // Internal for testing`
	`99`	`+ internal HttpConnectionOptions ShallowCopyHttpConnectionOptions(HttpConnectionOptions options)`
	`100`	`+ {`
	`101`	`+ return new HttpConnectionOptions`
	`102`	`+ {`
	`103`	`+ HttpMessageHandlerFactory = options.HttpMessageHandlerFactory,`
	`104`	`+ Headers = options.Headers,`
	`105`	`+ ClientCertificates = options.ClientCertificates,`
	`106`	`+ Cookies = options.Cookies,`
	`107`	`+ Url = options.Url,`
	`108`	`+ Transports = options.Transports,`
	`109`	`+ SkipNegotiation = options.SkipNegotiation,`
	`110`	`+ AccessTokenProvider = options.AccessTokenProvider,`
	`111`	`+ CloseTimeout = options.CloseTimeout,`
	`112`	`+ Credentials = options.Credentials,`
	`113`	`+ Proxy = options.Proxy,`
	`114`	`+ UseDefaultCredentials = options.UseDefaultCredentials,`
	`115`	`+ WebSocketConfiguration = options.WebSocketConfiguration,`
	`116`	`+ };`
	`117`	`+ }`
`90`	`118`	`}`
`91`	`119`	`}`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ private Func<EndPoint, ValueTask<ConnectionContext>> GetHttpConnectionFactory(st`
`73`	`73`	`{`
`74`	`74`	`var httpEndpoint = (HttpEndPoint)endPoint;`
`75`	`75`	`var options = new HttpConnectionOptions { Url = httpEndpoint.Url, Transports = transportType };`
`76`		`- var connection = new HttpConnection(httpEndpoint, options, transferFormat, loggerFactory);`
	`76`	`+ var connection = new HttpConnection(options, transferFormat, loggerFactory);`
`77`	`77`
`78`	`78`	`await connection.StartAsync();`
`79`	`79`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ public void BuildCanOnlyBeCalledOnce()`
`63`	`63`	`{`
`64`	`64`	`var builder = new HubConnectionBuilder();`
`65`	`65`	`builder.Services.AddSingleton<IConnectionFactory>(new HttpConnectionFactory(Mock.Of<IHubProtocol>(), Options.Create(new HttpConnectionOptions()), NullLoggerFactory.Instance));`
`66`		`- builder.WithUrl("https://www.example.com");`
	`66`	`+ builder.WithUrl("http://example.com");`
`67`	`67`
`68`	`68`	`Assert.NotNull(builder.Build());`
`69`	`69`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ public partial class HubConnectionTests`
`13`	`13`	`{`
`14`	`14`	`private static HubConnection CreateHubConnection(TestConnection connection, IHubProtocol protocol = null, ILoggerFactory loggerFactory = null)`
`15`	`15`	`{`
`16`		`- var builder = new HubConnectionBuilder().WithUrl("https://www.example.com");`
	`16`	`+ var builder = new HubConnectionBuilder().WithUrl("http://example.com");`
`17`	`17`
`18`	`18`	`var delegateConnectionFactory = new DelegateConnectionFactory(`
`19`	`19`	`endPoint => connection.StartAsync());`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ public async Task SendAsyncThrowsIfSerializingMessageFails()`
`59`	`59`	`[Fact]`
`60`	`60`	`public async Task ClosedEventRaisedWhenTheClientIsStopped()`
`61`	`61`	`{`
`62`		`- var builder = new HubConnectionBuilder().WithUrl("https://www.example.com");`
	`62`	`+ var builder = new HubConnectionBuilder().WithUrl("http://example.com");`
`63`	`63`
`64`	`64`	`var delegateConnectionFactory = new DelegateConnectionFactory(`
`65`	`65`	`endPoint => new TestConnection().StartAsync());`
Original file line number	Diff line number	Diff line change
`@@ -35,8 +35,7 @@ public static async Task<int> ExecuteAsync(string baseUrl)`
`35`	`35`
`36`	`36`	`Console.WriteLine($"Connecting to {baseUrl}...");`
`37`	`37`
`38`		`- var uri = new Uri(baseUrl);`
`39`		`- var connection = new HttpConnection(new HttpEndPoint(uri), new HttpConnectionOptions(), TransferFormat.Text, loggerFactory: null);`
	`38`	`+ var connection = new HttpConnection(new HttpConnectionOptions() { Url = new Uri(baseUrl) }, TransferFormat.Text, loggerFactory: null);`
`40`	`39`
`41`	`40`	`try`
`42`	`41`	`{`