Refactored IntegrationTest to enable callers to pass custom request headers

Bart Koelman · Bart Koelman · commit d47661f361ed · 2021-05-12T14:06:14.000+02:00
diff --git a/test/JsonApiDotNetCoreExampleTests/IntegrationTests/ContentNegotiation/AcceptHeaderTests.cs b/test/JsonApiDotNetCoreExampleTests/IntegrationTests/ContentNegotiation/AcceptHeaderTests.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Net;
 using System.Net.Http;
 using System.Net.Http.Headers;
@@ -30,10 +31,8 @@ public async Task Permits_no_Accept_headers()
             // Arrange
             const string route = "/policies";
 
-            var acceptHeaders = new MediaTypeWithQualityHeaderValue[0];
-
             // Act
-            (HttpResponseMessage httpResponse, _) = await _testContext.ExecuteGetAsync<Document>(route, acceptHeaders);
+            (HttpResponseMessage httpResponse, _) = await _testContext.ExecuteGetAsync<Document>(route);
 
             // Assert
             httpResponse.Should().HaveStatusCode(HttpStatusCode.OK);
@@ -65,10 +64,8 @@ public async Task Permits_no_Accept_headers_at_operations_endpoint()
             const string route = "/operations";
             const string contentType = HeaderConstants.AtomicOperationsMediaType;
 
-            var acceptHeaders = new MediaTypeWithQualityHeaderValue[0];
-
             // Act
-            (HttpResponseMessage httpResponse, _) = await _testContext.ExecutePostAsync<ErrorDocument>(route, requestBody, contentType, acceptHeaders);
+            (HttpResponseMessage httpResponse, _) = await _testContext.ExecutePostAsync<ErrorDocument>(route, requestBody, contentType);
 
             // Assert
             httpResponse.Should().HaveStatusCode(HttpStatusCode.OK);
@@ -80,14 +77,14 @@ public async Task Permits_global_wildcard_in_Accept_headers()
             // Arrange
             const string route = "/policies";
 
-            MediaTypeWithQualityHeaderValue[] acceptHeaders =
+            Action<HttpRequestHeaders> setRequestHeaders = headers =>
             {
-                MediaTypeWithQualityHeaderValue.Parse("text/html"),
-                MediaTypeWithQualityHeaderValue.Parse("*/*")
+                headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("text/html"));
+                headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("*/*"));
             };
 
             // Act
-            (HttpResponseMessage httpResponse, _) = await _testContext.ExecuteGetAsync<Document>(route, acceptHeaders);
+            (HttpResponseMessage httpResponse, _) = await _testContext.ExecuteGetAsync<Document>(route, setRequestHeaders);
 
             // Assert
             httpResponse.Should().HaveStatusCode(HttpStatusCode.OK);
@@ -99,14 +96,14 @@ public async Task Permits_application_wildcard_in_Accept_headers()
             // Arrange
             const string route = "/policies";
 
-            MediaTypeWithQualityHeaderValue[] acceptHeaders =
+            Action<HttpRequestHeaders> setRequestHeaders = headers =>
             {
-                MediaTypeWithQualityHeaderValue.Parse("text/html;q=0.8"),
-                MediaTypeWithQualityHeaderValue.Parse("application/*;q=0.2")
+                headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("text/html;q=0.8"));
+                headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/*;q=0.2"));
             };
 
             // Act
-            (HttpResponseMessage httpResponse, _) = await _testContext.ExecuteGetAsync<Document>(route, acceptHeaders);
+            (HttpResponseMessage httpResponse, _) = await _testContext.ExecuteGetAsync<Document>(route, setRequestHeaders);
 
             // Assert
             httpResponse.Should().HaveStatusCode(HttpStatusCode.OK);
@@ -118,17 +115,17 @@ public async Task Permits_JsonApi_without_parameters_in_Accept_headers()
             // Arrange
             const string route = "/policies";
 
-            MediaTypeWithQualityHeaderValue[] acceptHeaders =
+            Action<HttpRequestHeaders> setRequestHeaders = headers =>
             {
-                MediaTypeWithQualityHeaderValue.Parse("text/html"),
-                MediaTypeWithQualityHeaderValue.Parse(HeaderConstants.MediaType + "; profile=some"),
-                MediaTypeWithQualityHeaderValue.Parse(HeaderConstants.MediaType + "; ext=other"),
-                MediaTypeWithQualityHeaderValue.Parse(HeaderConstants.MediaType + "; unknown=unexpected"),
-                MediaTypeWithQualityHeaderValue.Parse(HeaderConstants.MediaType + "; q=0.3")
+                headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("text/html"));
+                headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse(HeaderConstants.MediaType + "; profile=some"));
+                headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse(HeaderConstants.MediaType + "; ext=other"));
+                headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse(HeaderConstants.MediaType + "; unknown=unexpected"));
+                headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse(HeaderConstants.MediaType + "; q=0.3"));
             };
 
             // Act
-            (HttpResponseMessage httpResponse, _) = await _testContext.ExecuteGetAsync<Document>(route, acceptHeaders);
+            (HttpResponseMessage httpResponse, _) = await _testContext.ExecuteGetAsync<Document>(route, setRequestHeaders);
 
             // Assert
             httpResponse.Should().HaveStatusCode(HttpStatusCode.OK);
@@ -160,17 +157,17 @@ public async Task Permits_JsonApi_with_AtomicOperations_extension_in_Accept_head
             const string route = "/operations";
             const string contentType = HeaderConstants.AtomicOperationsMediaType;
 
-            MediaTypeWithQualityHeaderValue[] acceptHeaders =
+            Action<HttpRequestHeaders> setRequestHeaders = headers =>
             {
-                MediaTypeWithQualityHeaderValue.Parse("text/html"),
-                MediaTypeWithQualityHeaderValue.Parse(HeaderConstants.MediaType + "; profile=some"),
-                MediaTypeWithQualityHeaderValue.Parse(HeaderConstants.MediaType),
-                MediaTypeWithQualityHeaderValue.Parse(HeaderConstants.MediaType + "; unknown=unexpected"),
-                MediaTypeWithQualityHeaderValue.Parse(HeaderConstants.MediaType + ";ext=\"https://jsonapi.org/ext/atomic\"; q=0.2")
+                headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("text/html"));
+                headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse(HeaderConstants.MediaType + "; profile=some"));
+                headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse(HeaderConstants.MediaType));
+                headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse(HeaderConstants.MediaType + "; unknown=unexpected"));
+                headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse(HeaderConstants.MediaType + ";ext=\"https://jsonapi.org/ext/atomic\"; q=0.2"));
             };
 
             // Act
-            (HttpResponseMessage httpResponse, _) = await _testContext.ExecutePostAsync<ErrorDocument>(route, requestBody, contentType, acceptHeaders);
+            (HttpResponseMessage httpResponse, _) = await _testContext.ExecutePostAsync<ErrorDocument>(route, requestBody, contentType, setRequestHeaders);
 
             // Assert
             httpResponse.Should().HaveStatusCode(HttpStatusCode.OK);
@@ -182,17 +179,17 @@ public async Task Denies_JsonApi_with_parameters_in_Accept_headers()
             // Arrange
             const string route = "/policies";
 
-            MediaTypeWithQualityHeaderValue[] acceptHeaders =
+            Action<HttpRequestHeaders> setRequestHeaders = headers =>
             {
-                MediaTypeWithQualityHeaderValue.Parse("text/html"),
-                MediaTypeWithQualityHeaderValue.Parse(HeaderConstants.MediaType + "; profile=some"),
-                MediaTypeWithQualityHeaderValue.Parse(HeaderConstants.MediaType + "; ext=other"),
-                MediaTypeWithQualityHeaderValue.Parse(HeaderConstants.MediaType + "; unknown=unexpected"),
-                MediaTypeWithQualityHeaderValue.Parse(HeaderConstants.AtomicOperationsMediaType)
+                headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("text/html"));
+                headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse(HeaderConstants.MediaType + "; profile=some"));
+                headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse(HeaderConstants.MediaType + "; ext=other"));
+                headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse(HeaderConstants.MediaType + "; unknown=unexpected"));
+                headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse(HeaderConstants.AtomicOperationsMediaType));
             };
 
             // Act
-            (HttpResponseMessage httpResponse, ErrorDocument responseDocument) = await _testContext.ExecuteGetAsync<ErrorDocument>(route, acceptHeaders);
+            (HttpResponseMessage httpResponse, ErrorDocument responseDocument) = await _testContext.ExecuteGetAsync<ErrorDocument>(route, setRequestHeaders);
 
             // Assert
             httpResponse.Should().HaveStatusCode(HttpStatusCode.NotAcceptable);
@@ -231,14 +228,14 @@ public async Task Denies_JsonApi_in_Accept_headers_at_operations_endpoint()
             const string route = "/operations";
             const string contentType = HeaderConstants.AtomicOperationsMediaType;
 
-            MediaTypeWithQualityHeaderValue[] acceptHeaders =
+            Action<HttpRequestHeaders> setRequestHeaders = headers =>
             {
-                MediaTypeWithQualityHeaderValue.Parse(HeaderConstants.MediaType)
+                headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse(HeaderConstants.MediaType));
             };
 
             // Act
             (HttpResponseMessage httpResponse, ErrorDocument responseDocument) =
-                await _testContext.ExecutePostAsync<ErrorDocument>(route, requestBody, contentType, acceptHeaders);
+                await _testContext.ExecutePostAsync<ErrorDocument>(route, requestBody, contentType, setRequestHeaders);
 
             // Assert
             httpResponse.Should().HaveStatusCode(HttpStatusCode.NotAcceptable);
diff --git a/test/TestBuildingBlocks/IntegrationTest.cs b/test/TestBuildingBlocks/IntegrationTest.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Threading.Tasks;
@@ -16,38 +15,37 @@ public abstract class IntegrationTest
         private static readonly IntegrationTestConfiguration IntegrationTestConfiguration = new IntegrationTestConfiguration();
 
         public async Task<(HttpResponseMessage httpResponse, TResponseDocument responseDocument)> ExecuteGetAsync<TResponseDocument>(string requestUrl,
-            IEnumerable<MediaTypeWithQualityHeaderValue> acceptHeaders = null)
+            Action<HttpRequestHeaders> setRequestHeaders = null)
         {
-            return await ExecuteRequestAsync<TResponseDocument>(HttpMethod.Get, requestUrl, null, null, acceptHeaders);
+            return await ExecuteRequestAsync<TResponseDocument>(HttpMethod.Get, requestUrl, null, null, setRequestHeaders);
         }
 
         public async Task<(HttpResponseMessage httpResponse, TResponseDocument responseDocument)> ExecutePostAsync<TResponseDocument>(string requestUrl,
-            object requestBody, string contentType = HeaderConstants.MediaType, IEnumerable<MediaTypeWithQualityHeaderValue> acceptHeaders = null)
+            object requestBody, string contentType = HeaderConstants.MediaType, Action<HttpRequestHeaders> setRequestHeaders = null)
         {
-            return await ExecuteRequestAsync<TResponseDocument>(HttpMethod.Post, requestUrl, requestBody, contentType, acceptHeaders);
+            return await ExecuteRequestAsync<TResponseDocument>(HttpMethod.Post, requestUrl, requestBody, contentType, setRequestHeaders);
         }
 
         public async Task<(HttpResponseMessage httpResponse, TResponseDocument responseDocument)> ExecutePostAtomicAsync<TResponseDocument>(string requestUrl,
-            object requestBody, string contentType = HeaderConstants.AtomicOperationsMediaType,
-            IEnumerable<MediaTypeWithQualityHeaderValue> acceptHeaders = null)
+            object requestBody, string contentType = HeaderConstants.AtomicOperationsMediaType, Action<HttpRequestHeaders> setRequestHeaders = null)
         {
-            return await ExecuteRequestAsync<TResponseDocument>(HttpMethod.Post, requestUrl, requestBody, contentType, acceptHeaders);
+            return await ExecuteRequestAsync<TResponseDocument>(HttpMethod.Post, requestUrl, requestBody, contentType, setRequestHeaders);
         }
 
         public async Task<(HttpResponseMessage httpResponse, TResponseDocument responseDocument)> ExecutePatchAsync<TResponseDocument>(string requestUrl,
-            object requestBody, string contentType = HeaderConstants.MediaType, IEnumerable<MediaTypeWithQualityHeaderValue> acceptHeaders = null)
+            object requestBody, string contentType = HeaderConstants.MediaType, Action<HttpRequestHeaders> setRequestHeaders = null)
         {
-            return await ExecuteRequestAsync<TResponseDocument>(HttpMethod.Patch, requestUrl, requestBody, contentType, acceptHeaders);
+            return await ExecuteRequestAsync<TResponseDocument>(HttpMethod.Patch, requestUrl, requestBody, contentType, setRequestHeaders);
         }
 
         public async Task<(HttpResponseMessage httpResponse, TResponseDocument responseDocument)> ExecuteDeleteAsync<TResponseDocument>(string requestUrl,
-            object requestBody = null, string contentType = HeaderConstants.MediaType, IEnumerable<MediaTypeWithQualityHeaderValue> acceptHeaders = null)
+            object requestBody = null, string contentType = HeaderConstants.MediaType, Action<HttpRequestHeaders> setRequestHeaders = null)
         {
-            return await ExecuteRequestAsync<TResponseDocument>(HttpMethod.Delete, requestUrl, requestBody, contentType, acceptHeaders);
+            return await ExecuteRequestAsync<TResponseDocument>(HttpMethod.Delete, requestUrl, requestBody, contentType, setRequestHeaders);
         }
 
         private async Task<(HttpResponseMessage httpResponse, TResponseDocument responseDocument)> ExecuteRequestAsync<TResponseDocument>(HttpMethod method,
-            string requestUrl, object requestBody, string contentType, IEnumerable<MediaTypeWithQualityHeaderValue> acceptHeaders)
+            string requestUrl, object requestBody, string contentType, Action<HttpRequestHeaders> setRequestHeaders)
         {
             using var request = new HttpRequestMessage(method, requestUrl);
             string requestText = SerializeRequest(requestBody);
@@ -63,13 +61,7 @@ public abstract class IntegrationTest
                 }
             }
 
-            if (acceptHeaders != null)
-            {
-                foreach (MediaTypeWithQualityHeaderValue acceptHeader in acceptHeaders)
-                {
-                    request.Headers.Accept.Add(acceptHeader);
-                }
-            }
+            setRequestHeaders?.Invoke(request.Headers);
 
             using HttpClient client = CreateClient();
             HttpResponseMessage responseMessage = await client.SendAsync(request);

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`	`1`	`using System;`
`2`		`-using System.Collections.Generic;`
`3`	`2`	`using System.Net.Http;`
`4`	`3`	`using System.Net.Http.Headers;`
`5`	`4`	`using System.Threading.Tasks;`
`@@ -16,38 +15,37 @@ public abstract class IntegrationTest`
`16`	`15`	`private static readonly IntegrationTestConfiguration IntegrationTestConfiguration = new IntegrationTestConfiguration();`
`17`	`16`
`18`	`17`	`public async Task<(HttpResponseMessage httpResponse, TResponseDocument responseDocument)> ExecuteGetAsync<TResponseDocument>(string requestUrl,`
`19`		`- IEnumerable<MediaTypeWithQualityHeaderValue> acceptHeaders = null)`
	`18`	`+ Action<HttpRequestHeaders> setRequestHeaders = null)`
`20`	`19`	`{`
`21`		`- return await ExecuteRequestAsync<TResponseDocument>(HttpMethod.Get, requestUrl, null, null, acceptHeaders);`
	`20`	`+ return await ExecuteRequestAsync<TResponseDocument>(HttpMethod.Get, requestUrl, null, null, setRequestHeaders);`
`22`	`21`	`}`
`23`	`22`
`24`	`23`	`public async Task<(HttpResponseMessage httpResponse, TResponseDocument responseDocument)> ExecutePostAsync<TResponseDocument>(string requestUrl,`
`25`		`- object requestBody, string contentType = HeaderConstants.MediaType, IEnumerable<MediaTypeWithQualityHeaderValue> acceptHeaders = null)`
	`24`	`+ object requestBody, string contentType = HeaderConstants.MediaType, Action<HttpRequestHeaders> setRequestHeaders = null)`
`26`	`25`	`{`
`27`		`- return await ExecuteRequestAsync<TResponseDocument>(HttpMethod.Post, requestUrl, requestBody, contentType, acceptHeaders);`
	`26`	`+ return await ExecuteRequestAsync<TResponseDocument>(HttpMethod.Post, requestUrl, requestBody, contentType, setRequestHeaders);`
`28`	`27`	`}`
`29`	`28`
`30`	`29`	`public async Task<(HttpResponseMessage httpResponse, TResponseDocument responseDocument)> ExecutePostAtomicAsync<TResponseDocument>(string requestUrl,`
`31`		`- object requestBody, string contentType = HeaderConstants.AtomicOperationsMediaType,`
`32`		`- IEnumerable<MediaTypeWithQualityHeaderValue> acceptHeaders = null)`
	`30`	`+ object requestBody, string contentType = HeaderConstants.AtomicOperationsMediaType, Action<HttpRequestHeaders> setRequestHeaders = null)`
`33`	`31`	`{`
`34`		`- return await ExecuteRequestAsync<TResponseDocument>(HttpMethod.Post, requestUrl, requestBody, contentType, acceptHeaders);`
	`32`	`+ return await ExecuteRequestAsync<TResponseDocument>(HttpMethod.Post, requestUrl, requestBody, contentType, setRequestHeaders);`
`35`	`33`	`}`
`36`	`34`
`37`	`35`	`public async Task<(HttpResponseMessage httpResponse, TResponseDocument responseDocument)> ExecutePatchAsync<TResponseDocument>(string requestUrl,`
`38`		`- object requestBody, string contentType = HeaderConstants.MediaType, IEnumerable<MediaTypeWithQualityHeaderValue> acceptHeaders = null)`
	`36`	`+ object requestBody, string contentType = HeaderConstants.MediaType, Action<HttpRequestHeaders> setRequestHeaders = null)`
`39`	`37`	`{`
`40`		`- return await ExecuteRequestAsync<TResponseDocument>(HttpMethod.Patch, requestUrl, requestBody, contentType, acceptHeaders);`
	`38`	`+ return await ExecuteRequestAsync<TResponseDocument>(HttpMethod.Patch, requestUrl, requestBody, contentType, setRequestHeaders);`
`41`	`39`	`}`
`42`	`40`
`43`	`41`	`public async Task<(HttpResponseMessage httpResponse, TResponseDocument responseDocument)> ExecuteDeleteAsync<TResponseDocument>(string requestUrl,`
`44`		`- object requestBody = null, string contentType = HeaderConstants.MediaType, IEnumerable<MediaTypeWithQualityHeaderValue> acceptHeaders = null)`
	`42`	`+ object requestBody = null, string contentType = HeaderConstants.MediaType, Action<HttpRequestHeaders> setRequestHeaders = null)`
`45`	`43`	`{`
`46`		`- return await ExecuteRequestAsync<TResponseDocument>(HttpMethod.Delete, requestUrl, requestBody, contentType, acceptHeaders);`
	`44`	`+ return await ExecuteRequestAsync<TResponseDocument>(HttpMethod.Delete, requestUrl, requestBody, contentType, setRequestHeaders);`
`47`	`45`	`}`
`48`	`46`
`49`	`47`	`private async Task<(HttpResponseMessage httpResponse, TResponseDocument responseDocument)> ExecuteRequestAsync<TResponseDocument>(HttpMethod method,`
`50`		`- string requestUrl, object requestBody, string contentType, IEnumerable<MediaTypeWithQualityHeaderValue> acceptHeaders)`
	`48`	`+ string requestUrl, object requestBody, string contentType, Action<HttpRequestHeaders> setRequestHeaders)`
`51`	`49`	`{`
`52`	`50`	`using var request = new HttpRequestMessage(method, requestUrl);`
`53`	`51`	`string requestText = SerializeRequest(requestBody);`
`@@ -63,13 +61,7 @@ public abstract class IntegrationTest`
`63`	`61`	`}`
`64`	`62`	`}`
`65`	`63`
`66`		`- if (acceptHeaders != null)`
`67`		`- {`
`68`		`- foreach (MediaTypeWithQualityHeaderValue acceptHeader in acceptHeaders)`
`69`		`- {`
`70`		`- request.Headers.Accept.Add(acceptHeader);`
`71`		`- }`
`72`		`- }`
	`64`	`+ setRequestHeaders?.Invoke(request.Headers);`
`73`	`65`
`74`	`66`	`using HttpClient client = CreateClient();`
`75`	`67`	`HttpResponseMessage responseMessage = await client.SendAsync(request);`