Updated Dependencies, Added Patch as a Method, Ability to add Cust… (#3)

Adds PATCH request type and headers without validation for more use cases.

Co-authored-by: Nick Craver <[email protected]>

Author: KrisJohnstone

src/StackExchange.Utils.Http/Extensions.Modifier.cs

@@ -3,6 +3,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Net;
+using System.Net.Http;
 using System.Net.Http.Headers;
 
 namespace StackExchange.Utils
@@ -124,6 +125,32 @@ public static IRequestBuilder AddHeader(this IRequestBuilder builder, string nam
             }
             return builder;
         }
+        
+        /// <summary>
+        /// Adds a single header without Validation against known Header types.
+        /// (ideal if you have different interpretation to the spec for any known types)
+        /// </summary>
+        /// <param name="builder">The builder we're working on.</param>
+        /// <param name="name">The auth scheme to add to this request.</param>
+        /// <param name="value">The key value (for <paramref name="name"/>) to add to this request.</param>
+        /// <returns>The request builder for chaining.</returns>
+        public static IRequestBuilder AddHeaderWithoutValidation(this IRequestBuilder builder, string name, string value)
+        {
+            if (!string.IsNullOrEmpty(name))
+            {
+                try
+                {
+                    builder.Message.Headers.TryAddWithoutValidation(name, value);
+
+                }
+                catch (Exception e)
+                {
+                    var wrapper = new HttpClientException("Unable to set header using: " + name + " to '" + value + "'", builder.Message.RequestUri, e);
+                    builder.GetSettings().OnException(builder, new HttpExceptionArgs(builder, wrapper));
+                }
+            }
+            return builder;
+        }
 
         /// <summary>
         /// Adds headers to this request.

src/StackExchange.Utils.Http/Extensions.Verbs.cs

@@ -45,5 +45,15 @@ public static Task<HttpCallResponse<T>> PostAsync<T>(this IRequestBuilder<T> bui
         /// <returns>A <see cref="HttpCallResponse{T}"/> to consume.</returns>
         public static Task<HttpCallResponse<T>> PutAsync<T>(this IRequestBuilder<T> builder, CancellationToken cancellationToken = default) =>
             Http.SendAsync(builder, HttpMethod.Put, cancellationToken);
+            
+        /// <summary>
+        /// Issue the request as a PATCH.
+        /// </summary>
+        /// <typeparam name="T">The return type.</typeparam>
+        /// <param name="builder">The builder used for this request.</param>
+        /// <param name="cancellationToken">The cancellation token for stopping the request.</param>
+        /// <returns>A <see cref="HttpCallResponse{T}"/> to consume.</returns>
+        public static Task<HttpCallResponse<T>> PatchAsync<T>(this IRequestBuilder<T> builder, CancellationToken cancellationToken = default) =>
+            Http.SendAsync(builder, new HttpMethod("PATCH"), cancellationToken);
     }
 }

tests/Directory.Build.props

@@ -9,7 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.3.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.4.0" />
     <PackageReference Include="xunit" Version="$(xUnitVersion)" />
     <PackageReference Include="xunit.runner.visualstudio" Version="$(xUnitVersion)" />
   </ItemGroup>

tests/StackExchange.Utils.Tests/HttpTests.cs

@@ -1,6 +1,8 @@
 using System;
+using System.Collections.Generic;
 using System.Net;
 using System.Net.Http;
+using System.Net.Http.Headers;
 using System.Threading.Tasks;
 using Xunit;
 
@@ -122,5 +124,88 @@ public async Task Timeouts()
             Assert.Equal("https://httpbin.org/delay/10", err.Uri.ToString());
             Assert.Null(err.StatusCode);
         }
+        
+        [Fact]
+        public async Task AddHeaderWithoutValidation()
+        {
+            var result = await Http.Request("https://httpbin.org/bearer")
+                                   .AddHeaderWithoutValidation("Authorization","abcd")
+                                   .ExpectJson<HttpBinResponse>()
+                                   .GetAsync();
+            Assert.True(result.RawRequest.Headers.Contains("Authorization"));
+            Assert.Equal(HttpStatusCode.Unauthorized, result.StatusCode);
+        }
+
+        [Fact]
+        public async Task AddHeaders()
+        {
+            var result = await Http.Request("https://httpbin.org/headers")
+                .AddHeaders(new Dictionary<string, string>()
+                {
+                    {"Content-Type", "application/json"},
+                    {"Custom", "Test"}
+                })
+                .SendJson("{}")
+                .ExpectJson<HttpBinResponse>()
+                .GetAsync();
+
+            Assert.Equal(HttpStatusCode.OK,result.StatusCode);
+            Assert.Equal("Test", result.Data.Headers["Custom"]);
+            // Content-Type should be present because we're sending a body up
+            Assert.StartsWith("application/json", result.Data.Headers["Content-Type"]);
+        }
+
+        [Fact]
+        public async Task TestAddHeadersWhereClientAddsHeaderBeforeContent()
+        {
+            var result = await Http.Request("https://httpbin.org/headers")
+                .AddHeaders(new Dictionary<string, string>()
+                {
+                    {"Content-Type", "application/json"},
+                    {"Custom", "Test"}
+                })
+                .SendJson("")
+                .ExpectJson<HttpBinResponse>()
+                .GetAsync();
+
+            Assert.Equal(HttpStatusCode.OK,result.StatusCode);
+            Assert.Equal("Test", result.Data.Headers["Custom"]);
+            Assert.Equal("application/json; charset=utf-8", result.Data.Headers["Content-Type"]);
+        }
+
+        [Fact]
+        public async Task TestAddHeadersWhereClientAddsHeaderAndNoContent()
+        {
+            var result = await Http.Request("https://httpbin.org/headers")
+                .AddHeaders(new Dictionary<string, string>()
+                {
+                    {"Content-Type", "application/json"},
+                    {"Custom", "Test"}
+                })
+                .ExpectJson<HttpBinResponse>()
+                .GetAsync();
+
+            Assert.Equal(HttpStatusCode.OK,result.StatusCode);
+            Assert.Equal("Test", result.Data.Headers["Custom"]);
+            // Content-Type is NOT sent when there's no body - this is correct behavior
+            Assert.DoesNotContain("Content-Type", result.Data.Headers.Keys);
+        }
+
+        [Fact]
+        public async Task PatchRequest()
+        {
+            var guid = Guid.NewGuid().ToString();
+            var result = await Http.Request("https://httpbin.org/patch")
+                .SendPlaintext(guid)
+                .ExpectJson<HttpBinResponse>()
+                .PatchAsync();
+
+            Assert.True(result.Success);
+            Assert.Equal(HttpStatusCode.OK, result.StatusCode);
+            Assert.NotNull(result);
+            Assert.True(result.Data.Form.ContainsKey(guid));
+            Assert.Equal("https://httpbin.org/patch", result.Data.Url);
+            Assert.Equal(Http.DefaultSettings.UserAgent, result.Data.Headers["User-Agent"]);
+        }
     }
 }