Allow appending custom querystring parameters

src/Nest.Tests.Unit/Core/Domain/Connection/ConnectionTests.cs

@@ -0,0 +1,55 @@
+using NUnit.Framework;
+using System;
+using System.Collections.Specialized;
+
+namespace Nest.Tests.Unit.Domain.Connection
+{
+    using System.Net;
+
+    public class TestConnection : Nest.Connection
+    {
+        public TestConnection(IConnectionSettings settings)
+            : base(settings) { }
+
+        public HttpWebRequest GetConnection(string path, string method)
+        {
+            return base.CreateConnection(path, method);
+        }
+    }
+
+    [TestFixture]
+    public class ConnectionTests
+    {
+        [Test]
+        public void CanCreateConnectionWithCustomQueryStringParameters()
+        {
+            // Arrange
+            var uri = new Uri("http://localhost");
+            var query = new NameValueCollection { { "authToken", "ABCDEFGHIJK" } };
+            var connectionSettings = new ConnectionSettings(uri, query);
+            var connection = new TestConnection(connectionSettings);
+
+            // Act
+            var req = connection.GetConnection("/", "GET");
+
+            // Assert
+            Assert.IsTrue(string.Compare(req.Address.ToString(), "http://localhost/?authToken=ABCDEFGHIJK", StringComparison.OrdinalIgnoreCase) == 0);
+        }
+
+        [Test]
+        public void CanCreateConnectionWithPathAndCustomQueryStringParameters()
+        {
+            // Arrange
+            var uri = new Uri("http://localhost:9000");
+            var query = new NameValueCollection { { "authToken", "ABCDEFGHIJK" } };
+            var connectionSettings = new ConnectionSettings(uri, query);            
+            var connection = new TestConnection(connectionSettings);
+
+            // Act
+            var req = connection.GetConnection("/index/", "GET");
+
+            // Assert
+            Assert.IsTrue(string.Compare(req.Address.ToString(), "http://localhost:9000/index/?authToken=ABCDEFGHIJK", StringComparison.OrdinalIgnoreCase) == 0);
+        }
+    }
+}

src/Nest.Tests.Unit/Extensions/NameValueCollectionExtensions.cs

@@ -0,0 +1,78 @@
+using NUnit.Framework;
+using System;
+using System.Collections.Specialized;
+
+namespace Nest.Tests.Unit.Extensions
+{
+    [TestFixture]
+    public class NameValueCollectionExtensions
+    {
+        [Test]
+        public void CanCopyKeyValues()
+        {
+            // Arrange
+            var source = new NameValueCollection { { "key1", "value1" }, { "key2", "value2" }, };
+            var dest = new NameValueCollection();
+
+            // Act
+            source.CopyKeyValues(dest);
+
+            // Assert
+            Assert.IsTrue(dest["key1"] == "value1");
+            Assert.IsTrue(dest["key2"] == "value2");
+        }
+
+        [Test]
+        public void UnableToCopyKeyValues()
+        {
+            // Arrange
+            var source = new NameValueCollection { { "key1", "value1" }, { "key2", "value2" }, };
+            var dest = new NameValueCollection();
+
+            // Act
+            source.CopyKeyValues(dest);
+
+            // Assert
+            Assert.IsTrue(dest["key1"] == "value1");
+            Assert.IsTrue(dest["key2"] == "value2");
+        }
+
+        [Test]
+        public void CopyKeyValuesWithDuplicateKeyThrowException()
+        {
+            // Arrange
+            var source = new NameValueCollection { { "key1", "value1" } };
+            var dest = new NameValueCollection { { "key1", "value1" } };
+
+            // Act            
+            // Assert
+            Assert.Throws<ApplicationException>(() => source.CopyKeyValues(dest));
+        }
+
+        [Test]
+        public void CanCovertNameValueCollectionToQueryString()
+        {
+            // Arrange
+            var queryCollection = new NameValueCollection { { "key1", "value1" }, { "key2", "value2" }, };
+
+            // Act
+            var queryString = queryCollection.ToQueryString();
+
+            // Assert
+            Assert.IsTrue(queryString == "?key1=value1&key2=value2");
+        }
+
+        [Test]
+        public void ConvertEmptyNameValueCollectionToQueryStringReturnsEmptyString()
+        {
+            // Arrange
+            var queryCollection = new NameValueCollection();
+
+            // Act
+            var queryString = queryCollection.ToQueryString();
+
+            // Assert
+            Assert.IsTrue(queryString == string.Empty);
+        }
+    }
+}

src/Nest.Tests.Unit/Extensions/StringExtensionsTests.cs

@@ -0,0 +1,36 @@
+using NUnit.Framework;
+
+namespace Nest.Tests.Unit.Extensions
+{
+    [TestFixture]
+    public class StringExtensionsTests
+    {
+        [Test]
+        public void CanConvertQueryStringToNameValueCollectionWithQuestionMark()
+        {
+            // Arrange
+            var queryString = "?test1=one&test2=two";
+
+            // Act
+            var queryCollection = queryString.ToNameValueCollection();
+
+            // Assert
+            Assert.IsTrue(queryCollection["test1"] == "one");
+            Assert.IsTrue(queryCollection["test2"] == "two");
+        }
+
+        [Test]
+        public void CanConvertQueryStringToNameValueCollectionWithoutQuestionMark()
+        {
+            // Arrange
+            var queryString = "test1=testone&test2=testtwo";
+
+            // Act
+            var queryCollection = queryString.ToNameValueCollection();
+
+            // Assert
+            Assert.IsTrue(queryCollection["test1"] == "testone");
+            Assert.IsTrue(queryCollection["test2"] == "testtwo");
+        }
+    }
+}

src/Nest.Tests.Unit/Extensions/UriExtensionsTests.cs

@@ -0,0 +1,36 @@
+using NUnit.Framework;
+using System;
+
+namespace Nest.Tests.Unit.Extensions
+{
+    [TestFixture]
+    public class UriExtensionsTests
+    {
+        [Test]
+        public void CanGetUrlForUriWithPort()
+        {
+            // Arrange
+            var uri = new Uri("http://localhost:8080");
+
+            // Act
+            var url = uri.ToUrlAndOverridePath("?test1=value1&test2=value2");
+
+            // Assert
+            Assert.IsTrue(url == "http://localhost:8080?test1=value1&test2=value2");
+        }
+
+        [Test]
+        public void CanGetUrlForUriWithoutPort()
+        {
+            // Arrange
+            var uri = new Uri("http://localhost/");
+
+            // Act
+            var url = uri.ToUrlAndOverridePath("?test1=value1&test2=value2");
+
+            // Assert
+            Assert.IsTrue(url == "http://localhost:80?test1=value1&test2=value2");
+        }
+
+    }
+}

src/Nest.Tests.Unit/Nest.Tests.Unit.csproj

@@ -74,6 +74,7 @@
     <Compile Include="Cluster\HealthTests.cs" />
     <Compile Include="Cluster\NodeTests.cs" />
     <Compile Include="Core\Bulk\BulkTests.cs" />
+    <Compile Include="Core\Domain\Connection\ConnectionTests.cs" />
     <Compile Include="Core\MultiSearch\MultiSearchTests.cs" />
     <Compile Include="Core\Get\GetFullTests.cs" />
     <Compile Include="Core\Index\IndexTests.cs" />
@@ -98,6 +99,9 @@
     <Compile Include="Core\Template\PutTemplateRequestTests.cs" />
     <Compile Include="Core\Versioning\VersioningTests.cs" />
     <Compile Include="Core\Warmers\PutWarmerRequestTests.cs" />
+    <Compile Include="Extensions\NameValueCollectionExtensions.cs" />
+    <Compile Include="Extensions\StringExtensionsTests.cs" />
+    <Compile Include="Extensions\UriExtensionsTests.cs" />
     <Compile Include="Internals\Inferno\HostNameWithPathTests.cs" />
     <Compile Include="Internals\Inferno\MapTypeNamesTests.cs" />
     <Compile Include="Internals\Serialize\OptOutTests.cs" />

src/Nest/Domain/Connection/Connection.cs

@@ -1,10 +1,11 @@
 using System;
-using System.Text;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.IO;
 using System.Net;
+using System.Text;
 using System.Threading;
-using System.IO;
 using System.Threading.Tasks;
-using System.Collections.Generic;
 
 namespace Nest
 {
@@ -184,12 +185,17 @@ protected virtual ConnectionStatus DoSynchronousRequest(HttpWebRequest request,
 						RequestUrl = request.RequestUri.ToString(),
 						RequestMethod = request.Method
 					};
+
+                    _ConnectionSettings.ConnectionStatusHandler(cs);
+
 					return cs;
 				}
 			}
 			catch (WebException webException)
 			{
-				return new ConnectionStatus(webException) { Request = data, RequestUrl = request.RequestUri.ToString(), RequestMethod = request.Method };
+				var cs = new ConnectionStatus(webException) { Request = data, RequestUrl = request.RequestUri.ToString(), RequestMethod = request.Method };
+                _ConnectionSettings.ConnectionStatusHandler(cs);
+			    return cs;
 			}		
 		}
 
@@ -209,6 +215,7 @@ protected virtual Task<ConnectionStatus> DoAsyncRequest(HttpWebRequest request,
 				return Task.Factory.StartNew(() =>
 				{
 					this.Iterate(this._AsyncSteps(request, tcs, data), tcs);
+                    _ConnectionSettings.ConnectionStatusHandler(tcs.Task.Result);
 					return tcs.Task.Result;
 				}, TaskCreationOptions.LongRunning);
 			}
@@ -303,11 +310,26 @@ public void Iterate(IEnumerable<Task> asyncIterator, TaskCompletionSource<Connec
 
 		private string _CreateUriString(string path)
 		{
-			var s = this._ConnectionSettings;
-			if (!path.StartsWith("/"))
-				path = "./" + path;
+            var s = this._ConnectionSettings;
+            if (!path.StartsWith("/"))
+                path = "./" + path;
+
+            var uri = new Uri(s.Uri, path);
+            var url = uri.ToString();
+
+            if (s.QueryStringParameters != null)
+            {
+                var existingParams = uri.Query.ToNameValueCollection();
+                var appendedParams = new NameValueCollection();
+                appendedParams.CopyKeyValues(existingParams);
+                appendedParams.CopyKeyValues(s.QueryStringParameters);
+
+                var queryString = appendedParams.ToQueryString();
+
+                url = uri.ToUrlAndOverridePath(uri.PathAndQuery + queryString);
+            }
 
-			return new Uri(s.Uri, path).ToString();
+            return url;            
 		}
 	}
 }