Refactor access to insecure setting

src/EventStore.Client/ChannelCache.cs

@@ -27,15 +27,14 @@ public ChannelCache(EventStoreClientSettings settings) {
 				DnsEndPointEqualityComparer.Instance);
 		}
 
-		public TChannel GetChannelInfo(DnsEndPoint endPoint, bool? https = null) {
+		public TChannel GetChannelInfo(DnsEndPoint endPoint) {
 			lock (_lock) {
 				ThrowIfDisposed();
 
 				if (!_channels.TryGetValue(endPoint, out var channel)) {
 					channel = ChannelFactory.CreateChannel(
 						settings: _settings,
-						endPoint: endPoint,
-						https: https ?? !_settings.ConnectivitySettings.Insecure);
+						endPoint: endPoint);
 					_channels[endPoint] = channel;
 				}
 

src/EventStore.Client/ChannelFactory.cs

@@ -8,13 +8,10 @@ namespace EventStore.Client {
 	internal static class ChannelFactory {
 		private const int MaxReceiveMessageLength = 17 * 1024 * 1024;
 
-		public static TChannel CreateChannel(EventStoreClientSettings settings, EndPoint endPoint, bool https) =>
-			CreateChannel(settings, endPoint.ToUri(https));
+		public static TChannel CreateChannel(EventStoreClientSettings settings, EndPoint endPoint) {
+			var address = endPoint.ToUri(!settings.ConnectivitySettings.Insecure);
 
-		public static TChannel CreateChannel(EventStoreClientSettings settings, Uri? address) {
-			address ??= settings.ConnectivitySettings.Address;
-
-			if (address.Scheme == Uri.UriSchemeHttp ||settings.ConnectivitySettings.Insecure) {
+			if (settings.ConnectivitySettings.Insecure) {
 				//this must be switched on before creation of the HttpMessageHandler
 				AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
 			}

src/EventStore.Client/EventStoreClientConnectivitySettings.cs

@@ -6,14 +6,22 @@ namespace EventStore.Client {
 	/// A class used to describe how to connect to an instance of EventStoreDB.
 	/// </summary>
 	public class EventStoreClientConnectivitySettings {
-		/// <summary>
-		/// The <see cref="Uri"/> of the EventStoreDB. Use this when connecting to a single node.
-		/// </summary>
-		public Uri Address { get; set; } = new UriBuilder {
+		private const int DefaultPort = 2113;
+		private bool _insecure;
+		private Uri? _address;
+		private Uri _defaultAddress = new UriBuilder {
 			Scheme = Uri.UriSchemeHttps,
-			Port = 2113
+			Port = DefaultPort
 		}.Uri;
 
+		/// <summary>
+		/// The <see cref="Uri"/> of the EventStoreDB. Use this when connecting to a single node.
+		/// </summary>
+		public Uri Address {
+			get { return _address == null ? _defaultAddress : _address; }
+			set { _address = value; }
+		}
+
 		/// <summary>
 		/// The maximum number of times to attempt <see cref="EndPoint"/> discovery.
 		/// </summary>
@@ -74,11 +82,25 @@ public class EventStoreClientConnectivitySettings {
 		/// True if pointing to a single EventStoreDB node.
 		/// </summary>
 		public bool IsSingleNode => GossipSeeds.Length == 0;
-
+		
 		/// <summary>
 		/// True if communicating over an insecure channel; otherwise false.
 		/// </summary>
-		public bool Insecure { get; set; }
+		public bool Insecure {
+			get {
+				return IsSingleNode
+					? string.Compare(Address.Scheme, Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase) != 0
+					: _insecure;
+			}
+			set {
+				_insecure = value;
+
+				_defaultAddress = new UriBuilder {
+					Scheme = value ? Uri.UriSchemeHttp : Uri.UriSchemeHttps,
+					Port = DefaultPort
+				}.Uri;
+			}
+		}
 
 		/// <summary>
 		/// True if certificates will be validated; otherwise false. 

src/EventStore.Client/SingleNodeChannelSelector.cs

@@ -1,4 +1,3 @@
-using System;
 using System.Net;
 using System.Threading;
 using System.Threading.Tasks;
@@ -11,7 +10,6 @@ internal class SingleNodeChannelSelector : IChannelSelector {
 		private readonly ILogger _log;
 		private readonly ChannelCache _channelCache;
 		private readonly DnsEndPoint _endPoint;
-		private readonly bool _https;
 
 		public SingleNodeChannelSelector(
 			EventStoreClientSettings settings,
@@ -21,9 +19,9 @@ public SingleNodeChannelSelector(
 				new NullLogger<SingleNodeChannelSelector>();
 
 			_channelCache = channelCache;
+
 			var uri = settings.ConnectivitySettings.Address;
 			_endPoint = new DnsEndPoint(host: uri.Host, port: uri.Port);
-			_https = string.Compare(uri.Scheme, Uri.UriSchemeHttps, ignoreCase: true) == 0;
 		}
 
 		public Task<ChannelBase> SelectChannelAsync(CancellationToken cancellationToken) =>
@@ -32,7 +30,7 @@ public Task<ChannelBase> SelectChannelAsync(CancellationToken cancellationToken)
 		public ChannelBase SelectChannel(DnsEndPoint endPoint) {
 			_log.LogInformation("Selected {endPoint}.", endPoint);
 
-			return _channelCache.GetChannelInfo(endPoint, _https);
+			return _channelCache.GetChannelInfo(endPoint);
 		}
 	}
 }

test/EventStore.Client.Tests/ConnectionStringTests.cs

@@ -245,6 +245,53 @@ public void with_default_settings() {
 			Assert.Equal(EventStoreClientConnectivitySettings.Default.KeepAliveTimeout,
 				settings.ConnectivitySettings.KeepAliveTimeout);
 		}
+
+		[Theory,
+		 InlineData("esdb://localhost", true),
+		 InlineData("esdb://localhost/?tls=false", false),
+		 InlineData("esdb://localhost/?tls=true", true),
+		 InlineData("esdb://localhost1,localhost2,localhost3", true),
+		 InlineData("esdb://localhost1,localhost2,localhost3/?tls=false", false),
+		 InlineData("esdb://localhost1,localhost2,localhost3/?tls=true", true)]
+		public void use_tls(string connectionString, bool useTls) {
+			var result = EventStoreClientSettings.Create(connectionString);
+
+			Assert.NotEqual(useTls, result.ConnectivitySettings.Insecure);
+			Assert.Equal(useTls ? "https":"http", result.ConnectivitySettings.Address.Scheme);
+		}
+
+		[Theory,
+		 InlineData("esdb://localhost", null, false),
+		 InlineData("esdb://localhost", true, true),
+		 InlineData("esdb://localhost", false, false),
+		 InlineData("esdb://localhost/?tls=true", null, false),
+		 InlineData("esdb://localhost/?tls=true", true, true),
+		 InlineData("esdb://localhost/?tls=true", false, false),
+		 InlineData("esdb://localhost/?tls=false", null, true),
+		 InlineData("esdb://localhost/?tls=false", true, true),
+		 InlineData("esdb://localhost/?tls=false", false, false),
+		 InlineData("esdb://localhost1,localhost2,localhost3", null, false),
+		 InlineData("esdb://localhost1,localhost2,localhost3", true, false),
+		 InlineData("esdb://localhost1,localhost2,localhost3", false, false),
+		 InlineData("esdb://localhost1,localhost2,localhost3/?tls=true", null, false),
+		 InlineData("esdb://localhost1,localhost2,localhost3/?tls=true", true, false),
+		 InlineData("esdb://localhost1,localhost2,localhost3/?tls=true", false, false),
+		 InlineData("esdb://localhost1,localhost2,localhost3/?tls=false", null, true),
+		 InlineData("esdb://localhost1,localhost2,localhost3/?tls=false", true, true),
+		 InlineData("esdb://localhost1,localhost2,localhost3/?tls=false", false, true),
+		]
+		public void override_tls_for_single_node(string connectionString, bool? insecureOverride, bool expected) {
+			var result = EventStoreClientSettings.Create(connectionString);
+			var settings = result.ConnectivitySettings;
+
+			if (insecureOverride.HasValue) {
+				settings.Address = new UriBuilder {
+					Scheme = insecureOverride.Value ? "hTTp" : "HttpS",
+				}.Uri;
+			}
+
+			Assert.Equal(expected, settings.Insecure);
+		}
 
 		private static string GetConnectionString(EventStoreClientSettings settings,
 			Func<string, string>? getKey = default)

test/EventStore.Client.Tests/GrpcServerCapabilitiesClientTests.cs

@@ -1,5 +1,5 @@
-using System;
 using System.Collections.Generic;
+using System.Net;
 using System.Threading.Tasks;
 using EventStore.Client.ServerFeatures;
 using Grpc.Core;
@@ -69,7 +69,7 @@ await sut.GetAsync(
 							new EventStoreClientSettings {
 								CreateHttpMessageHandler = kestrel.CreateHandler
 							},
-							new UriBuilder().Uri)
+							new DnsEndPoint("localhost", 80))
 						.CreateCallInvoker(),
 					cancellationToken: default);