Adds possibility to assert on content headers

* Renamed `HasHeader` to `HasRequestHeader`
* Adds `HasContentHeader` extension methods
* Rename assertion `WithHeader` to `WithRequestHeader`
* Adds `WithContentHeader` assertions

Author: dnperfors

.editorconfig

@@ -34,7 +34,7 @@ dotnet_style_prefer_inferred_tuple_names = true:suggestion
 dotnet_style_prefer_inferred_anonymous_type_member_names = true:suggestion
 dotnet_style_prefer_auto_properties = true:silent
 dotnet_style_prefer_conditional_expression_over_assignment = true:suggestion
-dotnet_style_prefer_conditional_expression_over_return = true:suggestion
+dotnet_style_prefer_conditional_expression_over_return = false:suggestion
 dotnet_style_prefer_compound_assignment = true:suggestion
 
 dotnet_style_coalesce_expression = true:suggestion

src/HttpClientTestHelpers/HttpRequestMessageAsserter.cs

@@ -154,24 +154,26 @@ public HttpRequestMessageAsserter WithHttpVersion(Version httpVersion)
         /// <summary>
         /// Asserts whether requests were made with a specific header name. Values are ignored.
         /// </summary>
+        /// <remarks>This method only asserts headers on <see cref="System.Net.Http.Headers.HttpRequestHeader"/></remarks>
         /// <param name="headerName">The name of the header that is expected.</param>
         /// <returns>The <seealso cref="HttpRequestMessageAsserter"/> for further assertions.</returns>
-        public HttpRequestMessageAsserter WithHeader(string headerName)
+        public HttpRequestMessageAsserter WithRequestHeader(string headerName)
         {
             if (string.IsNullOrEmpty(headerName))
             {
                 throw new ArgumentNullException(nameof(headerName));
             }
-            return With(x => x.HasHeader(headerName), $"header '{headerName}'");
+            return With(x => x.HasRequestHeader(headerName), $"request header '{headerName}'");
         }
 
         /// <summary>
         /// Asserts whether requests were made with a specific header name and value.
         /// </summary>
+        /// <remarks>This method only asserts headers on <see cref="System.Net.Http.Headers.HttpRequestHeader"/></remarks>
         /// <param name="headerName">The name of the header that is expected.</param>
         /// <param name="headerValue">The value of the expected header, supports wildcards.</param>
         /// <returns>The <seealso cref="HttpRequestMessageAsserter"/> for further assertions.</returns>
-        public HttpRequestMessageAsserter WithHeader(string headerName, string headerValue)
+        public HttpRequestMessageAsserter WithRequestHeader(string headerName, string headerValue)
         {
             if (string.IsNullOrEmpty(headerName))
             {
@@ -181,7 +183,42 @@ public HttpRequestMessageAsserter WithHeader(string headerName, string headerVal
             {
                 throw new ArgumentNullException(nameof(headerValue));
             }
-            return With(x => x.HasHeader(headerName, headerValue), $"header '{headerName}' and value '{headerValue}'");
+            return With(x => x.HasRequestHeader(headerName, headerValue), $"request header '{headerName}' and value '{headerValue}'");
+        }
+
+        /// <summary>
+        /// Asserts whether requests were made with a specific header name. Values are ignored.
+        /// </summary>
+        /// <remarks>This method only asserts headers on <see cref="System.Net.Http.Headers.HttpContentHeader"/></remarks>
+        /// <param name="headerName">The name of the header that is expected.</param>
+        /// <returns>The <seealso cref="HttpRequestMessageAsserter"/> for further assertions.</returns>
+        public HttpRequestMessageAsserter WithContentHeader(string headerName)
+        {
+            if (string.IsNullOrEmpty(headerName))
+            {
+                throw new ArgumentNullException(nameof(headerName));
+            }
+            return With(x => x.HasContentHeader(headerName), $"content header '{headerName}'");
+        }
+
+        /// <summary>
+        /// Asserts whether requests were made with a specific header name and value.
+        /// </summary>
+        /// <remarks>This method only asserts headers on <see cref="System.Net.Http.Headers.HttpContentHeader"/></remarks>
+        /// <param name="headerName">The name of the header that is expected.</param>
+        /// <param name="headerValue">The value of the expected header, supports wildcards.</param>
+        /// <returns>The <seealso cref="HttpRequestMessageAsserter"/> for further assertions.</returns>
+        public HttpRequestMessageAsserter WithContentHeader(string headerName, string headerValue)
+        {
+            if (string.IsNullOrEmpty(headerName))
+            {
+                throw new ArgumentNullException(nameof(headerName));
+            }
+            if (string.IsNullOrEmpty(headerValue))
+            {
+                throw new ArgumentNullException(nameof(headerValue));
+            }
+            return With(x => x.HasContentHeader(headerName, headerValue), $"content header '{headerName}' and value '{headerValue}'");
         }
 
         /// <summary>
@@ -191,7 +228,7 @@ public HttpRequestMessageAsserter WithHeader(string headerName, string headerVal
         /// <returns>The <seealso cref="HttpRequestMessageAsserter"/> for further assertions.</returns>
         public HttpRequestMessageAsserter Times(int count)
         {
-            if(count < 0)
+            if (count < 0)
             {
                 throw new ArgumentException("Count should not be less than zero", nameof(count));
             }

src/HttpClientTestHelpers/HttpRequestMessageExtensions.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Net.Http;
+using System.Net.Http.Headers;
 using System.Text.RegularExpressions;
 
 namespace HttpClientTestHelpers
@@ -96,10 +97,11 @@ public static bool HasHttpMethod(this HttpRequestMessage httpRequestMessage, str
         /// <summary>
         /// Determines whether a specific header is set on a request.
         /// </summary>
+        /// <remarks>This method only checks headers in <see cref="System.Net.Http.Headers.HttpRequestHeaders"/></remarks>
         /// <param name="httpRequestMessage">A <see cref="HttpRequestMessage"/> to check the correct method on.</param>
         /// <param name="headerName">The name of the header to locate on the request.</param>
         /// <returns>true when the request contains a header with the specified name; otherwise, false.</returns>
-        public static bool HasHeader(this HttpRequestMessage httpRequestMessage, string headerName)
+        public static bool HasRequestHeader(this HttpRequestMessage httpRequestMessage, string headerName)
         {
             if (httpRequestMessage == null)
             {
@@ -111,17 +113,18 @@ public static bool HasHeader(this HttpRequestMessage httpRequestMessage, string
                 throw new ArgumentNullException(nameof(headerName));
             }
 
-            return httpRequestMessage.Headers.Contains(headerName);
+            return httpRequestMessage.Headers.HasHeader(headerName);
         }
 
         /// <summary>
         /// Determines whether a specific header with a specific value is set on a request.
         /// </summary>
+        /// <remarks>This method only checks headers in <see cref="System.Net.Http.Headers.HttpRequestHeaders"/></remarks>
         /// <param name="httpRequestMessage">A <see cref="HttpRequestMessage"/> to check the correct method on.</param>
         /// <param name="headerName">The name of the header to locate on the request.</param>
         /// <param name="headerValue">The value the header should have. Wildcard is supported.</param>
         /// <returns>true when the request contains a header with the specified name and value; otherwise, false.</returns>
-        public static bool HasHeader(this HttpRequestMessage httpRequestMessage, string headerName, string headerValue)
+        public static bool HasRequestHeader(this HttpRequestMessage httpRequestMessage, string headerName, string headerValue)
         {
             if (httpRequestMessage == null)
             {
@@ -138,7 +141,77 @@ public static bool HasHeader(this HttpRequestMessage httpRequestMessage, string
                 throw new ArgumentNullException(nameof(headerValue));
             }
 
-            if (httpRequestMessage.Headers.TryGetValues(headerName, out var values))
+            return httpRequestMessage.Headers.HasHeader(headerName, headerValue);
+        }
+
+        /// <summary>
+        /// Determines whether a specific header is set on a request.
+        /// </summary>
+        /// <remarks>This method only checks headers in <see cref="System.Net.Http.Headers.HttpContentHeaders"/></remarks>
+        /// <param name="httpRequestMessage">A <see cref="HttpRequestMessage"/> to check the correct method on.</param>
+        /// <param name="headerName">The name of the header to locate on the request.</param>
+        /// <returns>true when the request contains a header with the specified name; otherwise, false.</returns>
+        public static bool HasContentHeader(this HttpRequestMessage httpRequestMessage, string headerName)
+        {
+            if (httpRequestMessage == null)
+            {
+                throw new ArgumentNullException(nameof(httpRequestMessage));
+            }
+
+            if (string.IsNullOrEmpty(headerName))
+            {
+                throw new ArgumentNullException(nameof(headerName));
+            }
+
+            if (httpRequestMessage.Content == null)
+            {
+                return false;
+            }
+
+            return httpRequestMessage.Content.Headers.HasHeader(headerName);
+        }
+
+        /// <summary>
+        /// Determines whether a specific header with a specific value is set on a request.
+        /// </summary>
+        /// <remarks>This method only checks headers in <see cref="System.Net.Http.Headers.HttpContentHeaders"/></remarks>
+        /// <param name="httpRequestMessage">A <see cref="HttpRequestMessage"/> to check the correct method on.</param>
+        /// <param name="headerName">The name of the header to locate on the request.</param>
+        /// <param name="headerValue">The value the header should have. Wildcard is supported.</param>
+        /// <returns>true when the request contains a header with the specified name and value; otherwise, false.</returns>
+        public static bool HasContentHeader(this HttpRequestMessage httpRequestMessage, string headerName, string headerValue)
+        {
+            if (httpRequestMessage == null)
+            {
+                throw new ArgumentNullException(nameof(httpRequestMessage));
+            }
+
+            if (string.IsNullOrEmpty(headerName))
+            {
+                throw new ArgumentNullException(nameof(headerName));
+            }
+
+            if (string.IsNullOrEmpty(headerValue))
+            {
+                throw new ArgumentNullException(nameof(headerValue));
+            }
+
+            if (httpRequestMessage.Content == null)
+            {
+                return false;
+            }
+
+            return httpRequestMessage.Content.Headers.HasHeader(headerName, headerValue);
+        }
+
+        private static bool HasHeader(this HttpHeaders headers, string headerName)
+        {
+            return headers.Contains(headerName);
+        }
+
+        private static bool HasHeader(this HttpHeaders headers, string headerName, string headerValue)
+        {
+            if (headers.TryGetValues(headerName, out var values))
             {
                 var value = string.Join(" ", values);
                 return Matches(value, headerValue);

src/HttpClientTestHelpers/TestableHttpMessageHandler.cs

@@ -25,7 +25,7 @@ protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage reques
         {
             httpRequestMessages.Enqueue(request);
 
-            if(response is TimeoutHttpResponseMessage)
+            if (response is TimeoutHttpResponseMessage)
             {
                 throw new TaskCanceledException(new OperationCanceledException().Message);
             }