Fix FxCop violations

coderpatros · coderpatros · commit 9918786d2907 · 2020-02-24T17:35:11.000+10:00
diff --git a/CoderPatros.AuthenticatedHttpClient.AuthorizationHeader.Tests/AuthorizationHeaderAuthenticatedHttpClientTests.cs b/CoderPatros.AuthenticatedHttpClient.AuthorizationHeader.Tests/AuthorizationHeaderAuthenticatedHttpClientTests.cs
@@ -15,19 +15,21 @@ public class AuthorizationHeaderAuthenticatedHttpClientTests
         [Fact]
         public async Task TestRequestAddsAuthenticationHeader()
         {
-            var mockHttp = new MockHttpMessageHandler();
-            mockHttp
-                .Expect("https://www.example.com")
-                .WithHeaders("Authorization", "test-value")
-                .Respond(HttpStatusCode.OK);
-            var client = AuthorizationHeaderAuthenticatedHttpClient.GetClient(new AuthorizationHeaderAuthenticatedHttpClientOptions
+            using (var mockHttp = new MockHttpMessageHandler())
             {
-                Value = "test-value"
-            }, mockHttp);
+                mockHttp
+                    .Expect("https://www.example.com")
+                    .WithHeaders("Authorization", "test-value")
+                    .Respond(HttpStatusCode.OK);
+                var client = AuthorizationHeaderAuthenticatedHttpClient.GetClient(new AuthorizationHeaderAuthenticatedHttpClientOptions
+                {
+                    Value = "test-value"
+                }, mockHttp);
 
-            await client.GetStringAsync("https://www.example.com");
+                await client.GetStringAsync(new Uri("https://www.example.com")).ConfigureAwait(false);
 
-            mockHttp.VerifyNoOutstandingExpectation();
+                mockHttp.VerifyNoOutstandingExpectation();
+            }
         }
     }
 }
diff --git a/CoderPatros.AuthenticatedHttpClient.AuthorizationHeader/AuthorizationHeaderAuthenticatedHttpMessageHandler.cs b/CoderPatros.AuthenticatedHttpClient.AuthorizationHeader/AuthorizationHeaderAuthenticatedHttpMessageHandler.cs
@@ -24,7 +24,7 @@ public AuthorizationHeaderAuthenticatedHttpMessageHandler(
         protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
         {
             request.Headers.Authorization = _authorizationHeader;
-            return await base.SendAsync(request, cancellationToken);
+            return await base.SendAsync(request, cancellationToken).ConfigureAwait(false);
         }
     }
 }
diff --git a/CoderPatros.AuthenticatedHttpClient.AzureAd.Tests/AzureAdAuthenticatedHttpClientTests.cs b/CoderPatros.AuthenticatedHttpClient.AzureAd.Tests/AzureAdAuthenticatedHttpClientTests.cs
@@ -19,80 +19,94 @@ public class AzureAdAuthenticatedHttpClientTests
         [Fact]
         public async Task TestRequestHasAuthorizationHeader()
         {
-            var mockHttp = new MockHttpMessageHandler();
-            mockHttp
-                .Expect("https://www.example.com")
-                .WithHeaders("Authorization", "Bearer test-access-token")
-                .Respond(HttpStatusCode.OK);
-            var mockMsgHandler = new Mock<AzureAdAuthenticatedHttpMessageHandler>(new AzureAdAuthenticatedHttpClientOptions
+            using (var mockHttp = new MockHttpMessageHandler())
             {
-                Tenant = "test-tenant",
-                ClientId = "test-client-id",
-                AppKey = "test-client-app-key",
-                ResourceId = "test-resource-id"
-            }, mockHttp);
-            mockMsgHandler
-                .Setup(handler => handler.AcquireAccessTokenAsync())
-                .Returns(Task.FromResult("test-access-token"));
-            mockMsgHandler.CallBase = true;
-            var client = new HttpClient(mockMsgHandler.Object);
+                mockHttp
+                    .Expect("https://www.example.com")
+                    .WithHeaders("Authorization", "Bearer test-access-token")
+                    .Respond(HttpStatusCode.OK);
+                var mockMsgHandler = new Mock<AzureAdAuthenticatedHttpMessageHandler>(new AzureAdAuthenticatedHttpClientOptions
+                {
+                    Tenant = "test-tenant",
+                    ClientId = "test-client-id",
+                    AppKey = "test-client-app-key",
+                    ResourceId = "test-resource-id"
+                }, mockHttp);
+                mockMsgHandler
+                    .Setup(handler => handler.AcquireAccessTokenAsync())
+                    .Returns(Task.FromResult("test-access-token"));
+                mockMsgHandler.CallBase = true;
 
-            await client.GetStringAsync("https://www.example.com");
+                using (var client = new HttpClient(mockMsgHandler.Object))
+                {
+                    await client.GetStringAsync(new Uri("https://www.example.com")).ConfigureAwait(false);
 
-            mockHttp.VerifyNoOutstandingExpectation();
+                    mockHttp.VerifyNoOutstandingExpectation();
+                }
+            }
         }
 
         [Fact]
         public async Task TestRequestRetriesThreeTimesToAcquireAccessToken()
         {
-            var mockHttp = new MockHttpMessageHandler();
-            mockHttp
-                .Expect("https://www.example.com")
-                .WithHeaders("Authorization", "Bearer test-access-token")
-                .Respond(HttpStatusCode.OK);
-            var mockMsgHandler = new Mock<AzureAdAuthenticatedHttpMessageHandler>(new AzureAdAuthenticatedHttpClientOptions
+            using (var mockHttp = new MockHttpMessageHandler())
             {
-                Tenant = "test-tenant",
-                ClientId = "test-client-id",
-                AppKey = "test-client-app-key",
-                ResourceId = "test-resource-id"
-            }, mockHttp);
-            mockMsgHandler
-                .SetupSequence(handler => handler.AcquireAccessTokenAsync())
-                .Throws(new AdalException("temporarily_unavailable"))
-                .Throws(new AdalException("temporarily_unavailable"))
-                .Returns(Task.FromResult("test-access-token"));
-            mockMsgHandler.CallBase = true;
-            var client = new HttpClient(mockMsgHandler.Object);
+                mockHttp
+                    .Expect("https://www.example.com")
+                    .WithHeaders("Authorization", "Bearer test-access-token")
+                    .Respond(HttpStatusCode.OK);
+                var mockMsgHandler = new Mock<AzureAdAuthenticatedHttpMessageHandler>(new AzureAdAuthenticatedHttpClientOptions
+                {
+                    Tenant = "test-tenant",
+                    ClientId = "test-client-id",
+                    AppKey = "test-client-app-key",
+                    ResourceId = "test-resource-id"
+                }, mockHttp);
+                mockMsgHandler
+                    .SetupSequence(handler => handler.AcquireAccessTokenAsync())
+                    .Throws(new AdalException("temporarily_unavailable"))
+                    .Throws(new AdalException("temporarily_unavailable"))
+                    .Returns(Task.FromResult("test-access-token"));
+                mockMsgHandler.CallBase = true;
 
-            await client.GetStringAsync("https://www.example.com");
+                using (var client = new HttpClient(mockMsgHandler.Object))
+                {
+                    await client.GetStringAsync(new Uri("https://www.example.com")).ConfigureAwait(false);
 
-            mockHttp.VerifyNoOutstandingExpectation();
-        }    
+                    mockHttp.VerifyNoOutstandingExpectation();
+                }
+            }
+        }
 
         [Fact]
         public async Task TestRequestFailsOnRepeatedFailuresToAcquireAccessTokenFailure()
         {
-            var mockHttp = new MockHttpMessageHandler();
-            mockHttp.Fallback.Respond(req => new HttpResponseMessage(HttpStatusCode.Unauthorized));
-            var mockMsgHandler = new Mock<AzureAdAuthenticatedHttpMessageHandler>(new AzureAdAuthenticatedHttpClientOptions
+            using (var mockHttp = new MockHttpMessageHandler())
             {
-                Tenant = "test-tenant",
-                ClientId = "test-client-id",
-                AppKey = "test-client-app-key",
-                ResourceId = "test-resource-id"
-            }, mockHttp);
-            mockMsgHandler
-                .SetupSequence(handler => handler.AcquireAccessTokenAsync())
-                .Throws(new AdalException("temporarily_unavailable"))
-                .Throws(new AdalException("temporarily_unavailable"))
-                .Throws(new AdalException("temporarily_unavailable"));
-            mockMsgHandler.CallBase = true;
-            var client = new HttpClient(mockMsgHandler.Object);
+                mockHttp.Fallback.Respond(req => new HttpResponseMessage(HttpStatusCode.Unauthorized));
+                var mockMsgHandler = new Mock<AzureAdAuthenticatedHttpMessageHandler>(new AzureAdAuthenticatedHttpClientOptions
+                {
+                    Tenant = "test-tenant",
+                    ClientId = "test-client-id",
+                    AppKey = "test-client-app-key",
+                    ResourceId = "test-resource-id"
+                }, mockHttp);
+                mockMsgHandler
+                    .SetupSequence(handler => handler.AcquireAccessTokenAsync())
+                    .Throws(new AdalException("temporarily_unavailable"))
+                    .Throws(new AdalException("temporarily_unavailable"))
+                    .Throws(new AdalException("temporarily_unavailable"));
+                mockMsgHandler.CallBase = true;
 
-            var exc = await Record.ExceptionAsync(async () => await client.GetStringAsync("https://www.example.com"));
+                using (var client = new HttpClient(mockMsgHandler.Object))
+                {
+                    var exc = await Record.ExceptionAsync(
+                        async () => await client.GetStringAsync(new Uri("https://www.example.com")).ConfigureAwait(false)
+                    ).ConfigureAwait(false);
 
-            Assert.IsType<HttpRequestException>(exc);
-        }    
+                    Assert.IsType<HttpRequestException>(exc);
+                }
+            }
+        }
     }
 }
diff --git a/CoderPatros.AuthenticatedHttpClient.AzureAd/AzureAdAuthenticatedHttpMessageHandler.cs b/CoderPatros.AuthenticatedHttpClient.AzureAd/AzureAdAuthenticatedHttpMessageHandler.cs
@@ -35,7 +35,7 @@ public AzureAdAuthenticatedHttpMessageHandler(
 
         internal virtual async Task<string> AcquireAccessTokenAsync()
         {
-            var result = await _authContext.AcquireTokenAsync(_resourceId, _clientCredential);
+            var result = await _authContext.AcquireTokenAsync(_resourceId, _clientCredential).ConfigureAwait(false);
             return result?.AccessToken;
         }
 
@@ -55,7 +55,7 @@ private async Task<string> AcquireTokenWithRetriesAsync(CancellationToken cancel
                 try
                 {
                     // ADAL includes an in memory cache, so this call will only send a message to the server if the cached token is expired.
-                    token = await AcquireAccessTokenAsync();
+                    token = await AcquireAccessTokenAsync().ConfigureAwait(false);
                 }
                 catch (AdalException ex)
                 {
@@ -80,7 +80,7 @@ private async Task<string> AcquireTokenWithRetriesAsync(CancellationToken cancel
 
         protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
         {
-            var accessToken = await AcquireTokenWithRetriesAsync(cancellationToken);
+            var accessToken = await AcquireTokenWithRetriesAsync(cancellationToken).ConfigureAwait(false);
             if (cancellationToken.IsCancellationRequested)
             {
                 return null;
@@ -90,7 +90,7 @@ protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage
                 "Bearer",
                 accessToken);
             
-            return await base.SendAsync(request, cancellationToken);
+            return await base.SendAsync(request, cancellationToken).ConfigureAwait(false);
         }
     }
 }
diff --git a/CoderPatros.AuthenticatedHttpClient.AzureAppServiceManagedIdentity.Tests/AzureAppSericeManagedIdentityAuthenticatedHttpClientTests.cs b/CoderPatros.AuthenticatedHttpClient.AzureAppServiceManagedIdentity.Tests/AzureAppSericeManagedIdentityAuthenticatedHttpClientTests.cs
@@ -18,24 +18,28 @@ public class AzureAppServiceManagedIdentityAuthenticatedHttpClientTests
         [Fact]
         public async Task TestRequestHasAuthorizationHeader()
         {
-            var mockHttp = new MockHttpMessageHandler();
-            mockHttp
-                .Expect("https://www.example.com")
-                .WithHeaders("Authorization", "Bearer test-access-token")
-                .Respond(HttpStatusCode.OK);
-            var mockMsgHandler = new Mock<AzureAppServiceManagedIdentityAuthenticatedHttpMessageHandler>(new AzureAppServiceManagedIdentityAuthenticatedHttpClientOptions
+            using (var mockHttp = new MockHttpMessageHandler())
             {
-                ResourceId = "test-resource-id"
-            }, mockHttp);
-            mockMsgHandler
-                .Setup(handler => handler.GetAccessTokenAsync())
-                .Returns(Task.FromResult("test-access-token"));
-            mockMsgHandler.CallBase = true;
-            var client = new HttpClient(mockMsgHandler.Object);
+                mockHttp
+                    .Expect("https://www.example.com")
+                    .WithHeaders("Authorization", "Bearer test-access-token")
+                    .Respond(HttpStatusCode.OK);
+                var mockMsgHandler = new Mock<AzureAppServiceManagedIdentityAuthenticatedHttpMessageHandler>(new AzureAppServiceManagedIdentityAuthenticatedHttpClientOptions
+                {
+                    ResourceId = "test-resource-id"
+                }, mockHttp);
+                mockMsgHandler
+                    .Setup(handler => handler.GetAccessTokenAsync())
+                    .Returns(Task.FromResult("test-access-token"));
+                mockMsgHandler.CallBase = true;
 
-            await client.GetStringAsync("https://www.example.com");
+                using (var client = new HttpClient(mockMsgHandler.Object))
+                {
+                    await client.GetStringAsync(new Uri("https://www.example.com")).ConfigureAwait(false);
 
-            mockHttp.VerifyNoOutstandingExpectation();
+                    mockHttp.VerifyNoOutstandingExpectation();
+                }
+            }
         }
     }
 }
diff --git a/CoderPatros.AuthenticatedHttpClient.AzureAppServiceManagedIdentity.Tests/CoderPatros.AuthenticatedHttpClient.AzureAppServiceManagedIdentity.Tests.csproj b/CoderPatros.AuthenticatedHttpClient.AzureAppServiceManagedIdentity.Tests/CoderPatros.AuthenticatedHttpClient.AzureAppServiceManagedIdentity.Tests.csproj
@@ -7,6 +7,10 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="2.9.8">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
     <PackageReference Include="coverlet.msbuild" Version="2.8.0">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
diff --git a/CoderPatros.AuthenticatedHttpClient.AzureAppServiceManagedIdentity/AzureAppServiceManagedIdentityAuthenticatedHttpMessageHandler.cs b/CoderPatros.AuthenticatedHttpClient.AzureAppServiceManagedIdentity/AzureAppServiceManagedIdentityAuthenticatedHttpMessageHandler.cs
@@ -28,18 +28,18 @@ public AzureAppServiceManagedIdentityAuthenticatedHttpMessageHandler(
         [ExcludeFromCodeCoverage]
         internal virtual async Task<string> GetAccessTokenAsync()
         {
-            return await _azureServiceTokenProvider.GetAccessTokenAsync(_resourceId);
+            return await _azureServiceTokenProvider.GetAccessTokenAsync(_resourceId).ConfigureAwait(false);
         }
 
         protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
         {
-            var accessToken = await GetAccessTokenAsync();
+            var accessToken = await GetAccessTokenAsync().ConfigureAwait(false);
 
             request.Headers.Authorization = new AuthenticationHeaderValue(
                 "Bearer",
                 accessToken);
             
-            return await base.SendAsync(request, cancellationToken);
+            return await base.SendAsync(request, cancellationToken).ConfigureAwait(false);
         }
     }
 }
diff --git a/CoderPatros.AuthenticatedHttpClient.Basic.Tests/BasicAuthenticatedHttpClientTests.cs b/CoderPatros.AuthenticatedHttpClient.Basic.Tests/BasicAuthenticatedHttpClientTests.cs
@@ -29,20 +29,22 @@ public void TestGenerateAuthenticationParameterRFC7617()
         [Fact]
         public async Task TestRequestHasAuthorizationHeader()
         {
-            var mockHttp = new MockHttpMessageHandler();
-            mockHttp
-                .Expect("https://www.example.com")
-                .WithHeaders("Authorization", "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==")
-                .Respond(HttpStatusCode.OK);
-            var client = BasicAuthenticatedHttpClient.GetClient(new BasicAuthenticatedHttpClientOptions
+            using (var mockHttp = new MockHttpMessageHandler())
             {
-                UserId = "Aladdin",
-                Password = "open sesame"
-            }, mockHttp);
+                mockHttp
+                    .Expect("https://www.example.com")
+                    .WithHeaders("Authorization", "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==")
+                    .Respond(HttpStatusCode.OK);
+                var client = BasicAuthenticatedHttpClient.GetClient(new BasicAuthenticatedHttpClientOptions
+                {
+                    UserId = "Aladdin",
+                    Password = "open sesame"
+                }, mockHttp);
 
-            await client.GetStringAsync("https://www.example.com");
+                await client.GetStringAsync(new Uri("https://www.example.com")).ConfigureAwait(false);
 
-            mockHttp.VerifyNoOutstandingExpectation();
+                mockHttp.VerifyNoOutstandingExpectation();
+            }
         }
     }
 }
diff --git a/CoderPatros.AuthenticatedHttpClient.Basic/BasicAuthenticatedHttpMessageHandler.cs b/CoderPatros.AuthenticatedHttpClient.Basic/BasicAuthenticatedHttpMessageHandler.cs
@@ -36,7 +36,7 @@ internal static string GenerateAuthenticationParameter(string userId, string pas
         protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
         {
             request.Headers.Authorization = _authorizationHeader;
-            return await base.SendAsync(request, cancellationToken);
+            return await base.SendAsync(request, cancellationToken).ConfigureAwait(false);
         }
     }
 }
diff --git a/CoderPatros.AuthenticatedHttpClient.CustomHeader.Tests/CustomHeaderAuthenticatedHttpClientTests.cs b/CoderPatros.AuthenticatedHttpClient.CustomHeader.Tests/CustomHeaderAuthenticatedHttpClientTests.cs
diff --git a/CoderPatros.AuthenticatedHttpClient.CustomHeader/CustomHeaderAuthenticatedHttpMessageHandler.cs b/CoderPatros.AuthenticatedHttpClient.CustomHeader/CustomHeaderAuthenticatedHttpMessageHandler.cs
diff --git a/CoderPatros.AuthenticatedHttpClient.QueryStringParameter.Tests/QueryStringParameterAuthenticatedHttpClientTests.cs b/CoderPatros.AuthenticatedHttpClient.QueryStringParameter.Tests/QueryStringParameterAuthenticatedHttpClientTests.cs
diff --git a/CoderPatros.AuthenticatedHttpClient.QueryStringParameter/QueryStringParameterAuthenticatedHttpMessageHandler.cs b/CoderPatros.AuthenticatedHttpClient.QueryStringParameter/QueryStringParameterAuthenticatedHttpMessageHandler.cs

Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ public AuthorizationHeaderAuthenticatedHttpMessageHandler(`
`24`	`24`	`protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)`
`25`	`25`	`{`
`26`	`26`	`request.Headers.Authorization = _authorizationHeader;`
`27`		`- return await base.SendAsync(request, cancellationToken);`
	`27`	`+ return await base.SendAsync(request, cancellationToken).ConfigureAwait(false);`
`28`	`28`	`}`
`29`	`29`	`}`
`30`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ public AzureAdAuthenticatedHttpMessageHandler(`
`35`	`35`
`36`	`36`	`internal virtual async Task<string> AcquireAccessTokenAsync()`
`37`	`37`	`{`
`38`		`- var result = await _authContext.AcquireTokenAsync(_resourceId, _clientCredential);`
	`38`	`+ var result = await _authContext.AcquireTokenAsync(_resourceId, _clientCredential).ConfigureAwait(false);`
`39`	`39`	`return result?.AccessToken;`
`40`	`40`	`}`
`41`	`41`
`@@ -55,7 +55,7 @@ private async Task<string> AcquireTokenWithRetriesAsync(CancellationToken cancel`
`55`	`55`	`try`
`56`	`56`	`{`
`57`	`57`	`// ADAL includes an in memory cache, so this call will only send a message to the server if the cached token is expired.`
`58`		`- token = await AcquireAccessTokenAsync();`
	`58`	`+ token = await AcquireAccessTokenAsync().ConfigureAwait(false);`
`59`	`59`	`}`
`60`	`60`	`catch (AdalException ex)`
`61`	`61`	`{`
`@@ -80,7 +80,7 @@ private async Task<string> AcquireTokenWithRetriesAsync(CancellationToken cancel`
`80`	`80`
`81`	`81`	`protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)`
`82`	`82`	`{`
`83`		`- var accessToken = await AcquireTokenWithRetriesAsync(cancellationToken);`
	`83`	`+ var accessToken = await AcquireTokenWithRetriesAsync(cancellationToken).ConfigureAwait(false);`
`84`	`84`	`if (cancellationToken.IsCancellationRequested)`
`85`	`85`	`{`
`86`	`86`	`return null;`
`@@ -90,7 +90,7 @@ protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage`
`90`	`90`	`"Bearer",`
`91`	`91`	`accessToken);`
`92`	`92`
`93`		`- return await base.SendAsync(request, cancellationToken);`
	`93`	`+ return await base.SendAsync(request, cancellationToken).ConfigureAwait(false);`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,18 +28,18 @@ public AzureAppServiceManagedIdentityAuthenticatedHttpMessageHandler(`
`28`	`28`	`[ExcludeFromCodeCoverage]`
`29`	`29`	`internal virtual async Task<string> GetAccessTokenAsync()`
`30`	`30`	`{`
`31`		`- return await _azureServiceTokenProvider.GetAccessTokenAsync(_resourceId);`
	`31`	`+ return await _azureServiceTokenProvider.GetAccessTokenAsync(_resourceId).ConfigureAwait(false);`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)`
`35`	`35`	`{`
`36`		`- var accessToken = await GetAccessTokenAsync();`
	`36`	`+ var accessToken = await GetAccessTokenAsync().ConfigureAwait(false);`
`37`	`37`
`38`	`38`	`request.Headers.Authorization = new AuthenticationHeaderValue(`
`39`	`39`	`"Bearer",`
`40`	`40`	`accessToken);`
`41`	`41`
`42`		`- return await base.SendAsync(request, cancellationToken);`
	`42`	`+ return await base.SendAsync(request, cancellationToken).ConfigureAwait(false);`
`43`	`43`	`}`
`44`	`44`	`}`
`45`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ internal static string GenerateAuthenticationParameter(string userId, string pas`
`36`	`36`	`protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)`
`37`	`37`	`{`
`38`	`38`	`request.Headers.Authorization = _authorizationHeader;`
`39`		`- return await base.SendAsync(request, cancellationToken);`
	`39`	`+ return await base.SendAsync(request, cancellationToken).ConfigureAwait(false);`
`40`	`40`	`}`
`41`	`41`	`}`
`42`	`42`	`}`