Support dynamic response headers

- Add support for dynamically matching and producing HTTP headers.
- Add missing null check.

Relates to #473.

Author: martincostello

src/HttpClientInterception/HttpRequestInterceptionBuilder.cs

@@ -499,6 +499,29 @@ public HttpRequestInterceptionBuilder WithContentHeaders(IDictionary<string, str
         return this;
     }
 
+    /// <summary>
+    /// Sets a delegate to a method that generates any custom HTTP content headers to use.
+    /// </summary>
+    /// <param name="headerFactory">Any delegate that creates any custom HTTP content headers to use.</param>
+    /// <returns>
+    /// The current <see cref="HttpRequestInterceptionBuilder"/>.
+    /// </returns>
+    /// <exception cref="ArgumentNullException">
+    /// <paramref name="headerFactory"/> is <see langword="null"/>.
+    /// </exception>
+    public HttpRequestInterceptionBuilder WithContentHeaders(
+        Func<IEnumerable<KeyValuePair<string, ICollection<string>>>> headerFactory)
+    {
+        if (headerFactory is null)
+        {
+            throw new ArgumentNullException(nameof(headerFactory));
+        }
+
+        _contentHeaders = new DynamicDictionary(headerFactory);
+        IncrementRevision();
+        return this;
+    }
+
     /// <summary>
     /// Sets a custom HTTP response header to use with a single value.
     /// </summary>
@@ -947,16 +970,50 @@ public HttpRequestInterceptionBuilder ForRequestHeaders(IDictionary<string, stri
     /// <returns>
     /// The current <see cref="HttpRequestInterceptionBuilder"/>.
     /// </returns>
+    /// <exception cref="ArgumentNullException">
+    /// <paramref name="headers"/> is <see langword="null"/>.
+    /// </exception>
     /// <remarks>
     /// HTTP request headers are only tested for interception if the URI requested was registered for interception.
     /// </remarks>
     public HttpRequestInterceptionBuilder ForRequestHeaders(IDictionary<string, ICollection<string>> headers)
     {
+        if (headers is null)
+        {
+            throw new ArgumentNullException(nameof(headers));
+        }
+
         _requestHeaders = new Dictionary<string, ICollection<string>>(headers, StringComparer.OrdinalIgnoreCase);
         IncrementRevision();
         return this;
     }
 
+    /// <summary>
+    /// Sets a delegate to a method that generates the HTTP request headers to intercept.
+    /// </summary>
+    /// <param name="headerFactory">Any delegate that returns the HTTP request headers to intercept..</param>
+    /// <returns>
+    /// The current <see cref="HttpRequestInterceptionBuilder"/>.
+    /// </returns>
+    /// <exception cref="ArgumentNullException">
+    /// <paramref name="headerFactory"/> is <see langword="null"/>.
+    /// </exception>
+    /// <remarks>
+    /// HTTP request headers are only tested for interception if the URI requested was registered for interception.
+    /// </remarks>
+    public HttpRequestInterceptionBuilder ForRequestHeaders(
+        Func<IEnumerable<KeyValuePair<string, ICollection<string>>>> headerFactory)
+    {
+        if (headerFactory is null)
+        {
+            throw new ArgumentNullException(nameof(headerFactory));
+        }
+
+        _requestHeaders = new DynamicDictionary(headerFactory);
+        IncrementRevision();
+        return this;
+    }
+
     /// <summary>
     /// Configures the builder to match any request whose HTTP content meets the criteria defined by the specified predicate.
     /// </summary>

src/HttpClientInterception/PublicAPI.Unshipped.txt

@@ -1,2 +1,4 @@
 #nullable enable
+JustEat.HttpClientInterception.HttpRequestInterceptionBuilder.ForRequestHeaders(System.Func<System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string!, System.Collections.Generic.ICollection<string!>!>>!>! headerFactory) -> JustEat.HttpClientInterception.HttpRequestInterceptionBuilder!
+JustEat.HttpClientInterception.HttpRequestInterceptionBuilder.WithContentHeaders(System.Func<System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string!, System.Collections.Generic.ICollection<string!>!>>!>! headerFactory) -> JustEat.HttpClientInterception.HttpRequestInterceptionBuilder!
 JustEat.HttpClientInterception.HttpRequestInterceptionBuilder.WithResponseHeaders(System.Func<System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string!, System.Collections.Generic.ICollection<string!>!>>!>! headerFactory) -> JustEat.HttpClientInterception.HttpRequestInterceptionBuilder!

tests/HttpClientInterception.Tests/Examples.cs

@@ -757,43 +757,73 @@ static bool IsHttpGetForJustEatGitHubOrg(HttpRequestMessage request)
     }
 
     [Fact]
-    public static async Task Dynamic_Headers()
+    public static async Task Dynamically_Compute_Http_Headers()
     {
         // Arrange
-        int counter = 0;
+        int contentHeadersCounter = 0;
+        int requestHeadersCounter = 0;
+        int responseHeadersCounter = 0;
 
         var builder = new HttpRequestInterceptionBuilder()
             .ForHost("service.local")
             .ForPath("resource")
-            .WithJsonContent(new object())
+            .ForRequestHeaders(() =>
+            {
+                return new Dictionary<string, ICollection<string>>()
+                {
+                    ["x-sequence"] = new[] { (++requestHeadersCounter).ToString(CultureInfo.InvariantCulture) },
+                };
+            })
+            .WithContentHeaders(() =>
+            {
+                return new Dictionary<string, ICollection<string>>()
+                {
+                    ["content-type"] = new[] { "application/json; v=" + (++contentHeadersCounter).ToString(CultureInfo.InvariantCulture) },
+                };
+            })
             .WithResponseHeaders(() =>
             {
                 return new Dictionary<string, ICollection<string>>()
                 {
-                    ["x-count"] = new[] { (++counter).ToString(CultureInfo.InvariantCulture) },
+                    ["x-count"] = new[] { (++responseHeadersCounter).ToString(CultureInfo.InvariantCulture) },
                 };
             });
 
         var options = new HttpClientInterceptorOptions()
-            .Register(builder);
+            .Register(builder)
+            .ThrowsOnMissingRegistration();
+
+        var method = HttpMethod.Get;
+        string requestUri = "http://service.local/resource";
 
         using var client = options.CreateHttpClient();
-        using var body = new StringContent(@"{ ""FirstName"": ""John"" }");
 
         // Act
-        using var response1 = await client.GetAsync("http://service.local/resource");
+        using var request1 = new HttpRequestMessage(method, requestUri);
+        request1.Headers.Add("x-sequence", "1");
+        using var response1 = await client.SendAsync(request1);
 
         // Assert
         response1.Headers.TryGetValues("x-count", out var values).ShouldBeTrue();
         values.ShouldNotBeNull();
         values.ShouldBe(new[] { "1" });
 
+        response1.Content.Headers.TryGetValues("content-type", out values).ShouldBeTrue();
+        values.ShouldNotBeNull();
+        values.ShouldBe(new[] { "application/json; v=1" });
+
         // Act
-        using var response2 = await client.GetAsync("http://service.local/resource");
+        using var request2 = new HttpRequestMessage(method, requestUri);
+        request2.Headers.Add("x-sequence", "2");
+        using var response2 = await client.SendAsync(request2);
 
         // Assert
         response2.Headers.TryGetValues("x-count", out values).ShouldBeTrue();
         values.ShouldNotBeNull();
         values.ShouldBe(new[] { "2" });
+
+        response2.Content.Headers.TryGetValues("content-type", out values).ShouldBeTrue();
+        values.ShouldNotBeNull();
+        values.ShouldBe(new[] { "application/json; v=2" });
     }
 }

tests/HttpClientInterception.Tests/HttpRequestInterceptionBuilderTests.cs

@@ -1707,10 +1707,14 @@ public static void ForRequestHeaders_Validates_Parameters()
     {
         // Arrange
         var builder = new HttpRequestInterceptionBuilder();
-        IDictionary<string, string> headers = null;
+        IDictionary<string, string> headersOfString = null;
+        IDictionary<string, ICollection<string>> headersOfStrings = null;
+        Func<IEnumerable<KeyValuePair<string, ICollection<string>>>> headerFactory = null;
 
         // Act and Assert
-        Should.Throw<ArgumentNullException>(() => builder.ForRequestHeaders(headers), "headers");
+        Should.Throw<ArgumentNullException>(() => builder.ForRequestHeaders(headersOfString), "headers");
+        Should.Throw<ArgumentNullException>(() => builder.ForRequestHeaders(headersOfStrings), "headers");
+        Should.Throw<ArgumentNullException>(() => builder.ForRequestHeaders(headerFactory), "headerFactory");
     }
 
     [Fact]
@@ -1736,10 +1740,12 @@ public static void WithContentHeaders_Validates_Parameters()
         var builder = new HttpRequestInterceptionBuilder();
         IDictionary<string, string> headers = null;
         IDictionary<string, ICollection<string>> headerValues = null;
+        Func<IEnumerable<KeyValuePair<string, ICollection<string>>>> headerFactory = null;
 
         // Act and Assert
         Should.Throw<ArgumentNullException>(() => builder.WithContentHeaders(headers), "headers");
         Should.Throw<ArgumentNullException>(() => builder.WithContentHeaders(headerValues), "headers");
+        Should.Throw<ArgumentNullException>(() => builder.WithContentHeaders(headerFactory), "headerFactory");
     }
 
     [Fact]
@@ -1764,9 +1770,11 @@ public static void WithResponseHeaders_Validates_Parameters()
         // Arrange
         var builder = new HttpRequestInterceptionBuilder();
         IDictionary<string, string> headers = null;
+        Func<IEnumerable<KeyValuePair<string, ICollection<string>>>> headerFactory = null;
 
         // Act and Assert
         Should.Throw<ArgumentNullException>(() => builder.WithResponseHeaders(headers), "headers");
+        Should.Throw<ArgumentNullException>(() => builder.WithResponseHeaders(headerFactory), "headerFactory");
     }
 
     [Fact]