From c98c181a262d42f380fe5310851736675c108916 Mon Sep 17 00:00:00 2001
From: Russ Cam <russ.cam@elastic.co>
Date: Wed, 30 Nov 2016 11:00:23 +1100
Subject: [PATCH] Tests for .Net Core HttpConnection

---
 .../Connection/HttpConnection-CoreFx.cs       |   8 +-
 .../Connection/HttpConnectionTests.cs         | 117 ++++++++++++++++++
 2 files changed, 121 insertions(+), 4 deletions(-)
 create mode 100644 src/Tests/ClientConcepts/Connection/HttpConnectionTests.cs

diff --git a/src/Elasticsearch.Net/Connection/HttpConnection-CoreFx.cs b/src/Elasticsearch.Net/Connection/HttpConnection-CoreFx.cs
index 3a6642bd86d..4174ecd87f0 100644
--- a/src/Elasticsearch.Net/Connection/HttpConnection-CoreFx.cs
+++ b/src/Elasticsearch.Net/Connection/HttpConnection-CoreFx.cs
@@ -32,17 +32,17 @@ public class HttpConnection : IConnection
 	{
 		private readonly object _lock = new object();
 
-		private readonly ConcurrentDictionary<int, HttpClient> _clients = new ConcurrentDictionary<int, HttpClient>();
+		protected readonly ConcurrentDictionary<int, HttpClient> Clients = new ConcurrentDictionary<int, HttpClient>();
 
 		private HttpClient GetClient(RequestData requestData)
 		{
 			var key = GetClientKey(requestData);
 			HttpClient client;
-			if (!this._clients.TryGetValue(key, out client))
+			if (!this.Clients.TryGetValue(key, out client))
 			{
 				lock (_lock)
 				{
-					client = this._clients.GetOrAdd(key, h =>
+					client = this.Clients.GetOrAdd(key, h =>
 					{
 						var handler = CreateHttpClientHandler(requestData);
 						var httpClient = new HttpClient(handler, false)
@@ -223,7 +223,7 @@ private static int GetClientKey(RequestData requestData)
 
 		protected virtual void DisposeManagedResources()
 		{
-			foreach (var c in _clients)
+			foreach (var c in Clients)
 				c.Value.Dispose();
 		}
 	}
diff --git a/src/Tests/ClientConcepts/Connection/HttpConnectionTests.cs b/src/Tests/ClientConcepts/Connection/HttpConnectionTests.cs
new file mode 100644
index 00000000000..34c0ce22a22
--- /dev/null
+++ b/src/Tests/ClientConcepts/Connection/HttpConnectionTests.cs
@@ -0,0 +1,117 @@
+#if DOTNETCORE
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Elasticsearch.Net;
+using FluentAssertions;
+using Nest;
+using Tests.Framework;
+
+namespace Tests.ClientConcepts.Connection
+{
+    public class HttpConnectionTests
+    {
+	    public class TestableHttpConnection : HttpConnection
+	    {
+		    public int ClientCount => this.Clients.Count;
+
+		    public int CallCount { get; private set; }
+
+		    public override ElasticsearchResponse<TReturn> Request<TReturn>(RequestData requestData)
+		    {
+			    CallCount++;
+			    return base.Request<TReturn>(requestData);
+		    }
+
+		    public override Task<ElasticsearchResponse<TReturn>> RequestAsync<TReturn>(RequestData requestData, CancellationToken cancellationToken)
+		    {
+			    CallCount++;
+			    return base.RequestAsync<TReturn>(requestData, cancellationToken);
+		    }
+	    }
+
+	    [U]
+	    public async Task SingleInstanceOfHttpClient()
+	    {
+			var connection = new TestableHttpConnection();
+		    var requestData = CreateRequestData(TimeSpan.FromMinutes(1));
+			connection.Request<string>(requestData);
+
+			connection.CallCount.Should().Be(1);
+		    connection.ClientCount.Should().Be(1);
+
+			await connection.RequestAsync<string>(requestData, CancellationToken.None).ConfigureAwait(false);
+
+			connection.CallCount.Should().Be(2);
+			connection.ClientCount.Should().Be(1);
+		}
+
+	    [U]
+		public async Task MultipleInstancesOfHttpClientWhenRequestTimeoutChanges()
+		{
+			await MultipleInstancesOfHttpClientWhen(() => CreateRequestData(TimeSpan.FromSeconds(30)));
+		}
+
+		[U]
+		public async Task MultipleInstancesOfHttpClientWhenProxyChanges()
+		{
+			await MultipleInstancesOfHttpClientWhen(() => CreateRequestData(proxyAddress: new Uri("http://localhost:9400")));
+		}
+
+		[U]
+		public async Task MultipleInstancesOfHttpClientWhenAutomaticProxyDetectionChanges()
+		{
+			await MultipleInstancesOfHttpClientWhen(() => CreateRequestData(disableAutomaticProxyDetection: true));
+		}
+
+		[U]
+		public async Task MultipleInstancesOfHttpClientWhenHttpCompressionChanges()
+		{
+			await MultipleInstancesOfHttpClientWhen(() => CreateRequestData(httpCompression: true));
+		}
+
+	    private static async Task MultipleInstancesOfHttpClientWhen(Func<RequestData> differentRequestData)
+	    {
+		    var connection = new TestableHttpConnection();
+		    var requestData = CreateRequestData();
+		    connection.Request<string>(requestData);
+
+		    connection.CallCount.Should().Be(1);
+		    connection.ClientCount.Should().Be(1);
+
+		    requestData = differentRequestData();
+		    await connection.RequestAsync<string>(requestData, CancellationToken.None).ConfigureAwait(false);
+
+		    connection.CallCount.Should().Be(2);
+		    connection.ClientCount.Should().Be(2);
+	    }
+
+	    private static RequestData CreateRequestData(
+			TimeSpan requestTimeout = default(TimeSpan),
+			Uri proxyAddress = null,
+			bool disableAutomaticProxyDetection = false,
+			bool httpCompression = false)
+		{
+			if (requestTimeout == default(TimeSpan))
+				requestTimeout = TimeSpan.FromMinutes(1);
+
+			var connectionSettings = new ConnectionSettings(new Uri("http://localhost:9200"))
+				.RequestTimeout(requestTimeout)
+				.DisableAutomaticProxyDetection(disableAutomaticProxyDetection)
+				.EnableHttpCompression(httpCompression);
+
+			if (proxyAddress != null)
+				connectionSettings.Proxy(proxyAddress, null, null);
+
+			var requestData = new RequestData(HttpMethod.GET, "/", null, connectionSettings, new PingRequestParameters(),
+			    new MemoryStreamFactory())
+		    {
+			    Node = new Node(new Uri("http://localhost:9200"))
+		    };
+		    return requestData;
+	    }
+    }
+}
+#endif