HttpResponseMessage

TestTransport\InMemoryHttpClientSlim.cs (1)

99new HttpResponseMessage(status).EnsureSuccessStatusCode();

ArcadeHttpMessageHandler.cs (2)

24return Task.FromResult(new HttpResponseMessage() 31return Task.FromResult(new HttpResponseMessage()

FacebookTests.cs (3)

335var res = new HttpResponseMessage(HttpStatusCode.OK); 344var res = new HttpResponseMessage(HttpStatusCode.OK); 480var res = new HttpResponseMessage(code);

GoogleTests.cs (1)

1124var res = new HttpResponseMessage(code);

MicrosoftAccountTests.cs (1)

427var res = new HttpResponseMessage(HttpStatusCode.OK);

OAuthTests.cs (1)

535var res = new HttpResponseMessage(code);

OpenIdConnect\OpenIdConnectChallengeTests.cs (3)

976return new HttpResponseMessage() 984return new HttpResponseMessage() { Content = new StringContent("{ }", Encoding.ASCII, "application/json") }; 994return new HttpResponseMessage() { Content = new StringContent("{ \"request_uri\": \"my_reference_value\", \"expires_in\": 60}", Encoding.ASCII, "application/json") };

OpenIdConnect\OpenIdConnectEventTests.cs (2)

1395return Task.FromResult(new HttpResponseMessage() 1403return Task.FromResult(new HttpResponseMessage() { Content = new StringContent("{ }", Encoding.ASCII, "application/json") });

OpenIdConnect\OpenIdConnectEventTests_Handler.cs (2)

1390return Task.FromResult(new HttpResponseMessage() 1398return Task.FromResult(new HttpResponseMessage() { Content = new StringContent("{ }", Encoding.ASCII, "application/json") });

OpenIdConnect\TestSettings.cs (1)

340return new HttpResponseMessage()

TwitterTests.cs (6)

399var res = new HttpResponseMessage(HttpStatusCode.OK); 468var res = new HttpResponseMessage(HttpStatusCode.OK); 484var res = new HttpResponseMessage(HttpStatusCode.OK); 596return new HttpResponseMessage(HttpStatusCode.OK) 611return new HttpResponseMessage(HttpStatusCode.Forbidden) 626return new HttpResponseMessage(HttpStatusCode.Forbidden)

WsFederation\WsFederationTest.cs (1)

453var newResponse = new HttpResponseMessage() { Content = new StringContent(metadata, Encoding.UTF8, "text/xml") };

WsFederation\WsFederationTest_Handler.cs (1)

449var newResponse = new HttpResponseMessage() { Content = new StringContent(metadata, Encoding.UTF8, "text/xml") };

HeaderPropagationIntegrationTest.cs (1)

235return Task.FromResult(new HttpResponseMessage());

HeaderPropagationMessageHandlerTest.cs (1)

269return Task.FromResult(new HttpResponseMessage());

HttpClientSlim.cs (1)

102new HttpResponseMessage(status).EnsureSuccessStatusCode();

LongPollingTransportTests.cs (3)

725responseTaskCompletionSource.TrySetResult(new HttpResponseMessage(HttpStatusCode.OK)); 729responseTaskCompletionSource.TrySetResult(new HttpResponseMessage(HttpStatusCode.NoContent)); 733return await Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK));

ResponseUtils.cs (1)

28return new HttpResponseMessage(statusCode)

ServerSentEventsTransportTests.cs (12)

SpaProxyTests.cs (1)

27.ReturnsAsync(new HttpResponseMessage

ClientHandler.cs (1)

192var response = new HttpResponseMessage();

TestResources\ReturningHttpClientHandler.cs (2)

16return new(HttpStatusCode.Gone); 22return Task.FromResult(new HttpResponseMessage(HttpStatusCode.Gone));

TestResources\TestHandler.cs (1)

16return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK));

DownloadFile_Tests.cs (11)

GeneralTests.cs (6)

64new HttpResponseMessage(feedResponseStatusCode)); 86new HttpResponseMessage(initialResponseStatusCode), 87new HttpResponseMessage(HttpStatusCode.OK) 118var response = new HttpResponseMessage(feedResponseStatusCode); 156new HttpResponseMessage(initialResponseStatusCode) 160new HttpResponseMessage(HttpStatusCode.OK)

PublishToSymbolServerTest.cs (13)

FindDotNetCliPackageTests.cs (16)

NoRemoteCallHandler.cs (1)

37var response = new HttpResponseMessage

NoRemoteCallNotSeekableHandler.cs (1)

40var response = new HttpResponseMessage

Latency\Internal\HttpClientLatencyLogEnricherTest.cs (2)

45using HttpResponseMessage httpResponseMessage = new(); 65using HttpResponseMessage httpResponseMessage = new();

Logging\HttpClientLoggerTest.cs (14)

Logging\HttpHeadersReaderTest.cs (4)

24using var httpResponse = new HttpResponseMessage(); 42using var httpResponse = new HttpResponseMessage(); 145using var httpResponse = new HttpResponseMessage { Content = responseContent }; 178using var httpResponse = new HttpResponseMessage();

Logging\HttpRequestReaderTest.cs (7)

90using var httpResponseMessage = new HttpResponseMessage 150using var httpResponseMessage = new HttpResponseMessage 219using var httpResponseMessage = new HttpResponseMessage 294using var httpResponseMessage = new HttpResponseMessage 424using var httpResponseMessage = new HttpResponseMessage 491using var httpResponseMessage = new HttpResponseMessage 559using var httpResponseMessage = new HttpResponseMessage

Logging\HttpResponseBodyReaderTest.cs (6)

40using var httpResponse = new HttpResponseMessage 58using var httpResponse = new HttpResponseMessage 83using var httpResponse = new HttpResponseMessage 103using var httpResponse = new HttpResponseMessage 127using var httpResponse = new HttpResponseMessage 152using var httpResponse = new HttpResponseMessage

Logging\Internal\NoRemoteCallHandler.cs (1)

31var response = new HttpResponseMessage

DependencyInjection\PollyHttpClientBuilderExtensionsTest.cs (4)

247(req) => new HttpResponseMessage(statusCode), 248(req) => new HttpResponseMessage(HttpStatusCode.OK), 293(req) => new HttpResponseMessage(HttpStatusCode.OK), 569return Task.FromResult(new HttpResponseMessage(HttpStatusCode.Created));

PolicyHttpMessageHandlerTest.cs (10)

NoRemoteCallHandler.cs (1)

18_response = new HttpResponseMessage

Hedging\HedgingTests.cs (1)

334_responses.Enqueue(new HttpResponseMessage(statusCode));

Hedging\HttpClientHedgingResiliencePredicatesTests.cs (1)

42using var response = new HttpResponseMessage(code);

Hedging\StandardHedgingTests.cs (3)

116using var response = new HttpResponseMessage(HttpStatusCode.OK); 361return new HttpResponseMessage(HttpStatusCode.OK); 375return new HttpResponseMessage(HttpStatusCode.OK);

Helpers\TestHandlerStub.cs (1)

17: this((_, _) => Task.FromResult(new HttpResponseMessage(statusCode)))

Internal\RequestMessageSnapshotStrategyTests.cs (1)

29return new ValueTask<HttpResponseMessage>(new HttpResponseMessage());

Internal\RetryAfterHelperTests.cs (4)

19using var response = new HttpResponseMessage(); 31using var response = new HttpResponseMessage(); 44using var response = new HttpResponseMessage(); 58using var response = new HttpResponseMessage();

Polly\HttpCircuitBreakerStrategyOptionsTests.cs (1)

59using var response = new HttpResponseMessage { StatusCode = statusCode };

Polly\HttpClientResiliencePredicatesTests.cs (1)

55var response = new HttpResponseMessage { StatusCode = statusCode };

Polly\HttpRetryStrategyOptionsTests.cs (4)

58var response = new HttpResponseMessage { StatusCode = statusCode }; 83var response = new HttpResponseMessage { StatusCode = statusCode }; 102using var responseMessage = new HttpResponseMessage(); 130using var responseMessage = new HttpResponseMessage

Resilience\HttpClientBuilderExtensionsTests.Standard.cs (1)

245return Task.FromResult(new HttpResponseMessage(HttpStatusCode.InternalServerError));

Resilience\HttpResilienceMetricsEnricherTests.cs (1)

46using var response = new HttpResponseMessage(System.Net.HttpStatusCode.InternalServerError);

Resilience\ResilienceHandlerTest.cs (2)

112return Task.FromResult(new HttpResponseMessage { StatusCode = HttpStatusCode.Created }); 137return Task.FromResult(new HttpResponseMessage { StatusCode = HttpStatusCode.Created });

System\Net\Http\SocketsHttpHandler\Http2Stream.cs (1)

137_response = new HttpResponseMessage()

System\Net\Http\SocketsHttpHandler\Http3RequestStream.cs (1)

1039_response = new HttpResponseMessage()

System\Net\Http\SocketsHttpHandler\HttpConnection.cs (1)

663var response = new HttpResponseMessage() { RequestMessage = request, Content = new HttpConnectionResponseContent() };

Integration\FrontendBrowserTokenAuthTests.cs (2)

43var response = await client.GetAsync("/").DefaultTimeout(); 145var response = await client.PostAsync("/api/validatetoken?token=" + requestToken, content: null).DefaultTimeout();

Integration\FrontendOpenIdConnectAuthTests.cs (2)

40var response = await client.GetAsync("/").DefaultTimeout(); 85var response = await client.GetAsync("/").DefaultTimeout();

Integration\OtlpCorsHttpServiceTests.cs (5)

36var responseMessage = await httpClient.SendAsync(preflightRequest).DefaultTimeout(); 60var responseMessage1 = await httpClient.SendAsync(preflightRequest1).DefaultTimeout(); 74var responseMessage2 = await httpClient.SendAsync(preflightRequest2).DefaultTimeout(); 101var responseMessage = await httpClient.SendAsync(preflightRequest).DefaultTimeout(); 129var responseMessage = await httpClient.SendAsync(preflightRequest).DefaultTimeout();

Integration\OtlpHttpServiceTests.cs (11)

Integration\ResponseCompressionTests.cs (2)

28var response = await client.SendAsync(request).DefaultTimeout(); 50var response = await client.SendAsync(request).DefaultTimeout();

Integration\StartupTests.cs (3)

299var response = await httpClient.SendAsync(request).DefaultTimeout(); 400var responseMessage = await httpClient.SendAsync(request).DefaultTimeout(); 693var response = await client.GetAsync("/").DefaultTimeout();

Middleware\ValidateTokenMiddlewareTests.cs (6)

22var response = await host.GetTestClient().GetAsync("/login?t=test").DefaultTimeout(); 30var response = await host.GetTestClient().GetAsync("/login?t=test&returnUrl=/test").DefaultTimeout(); 38var response = await host.GetTestClient().GetAsync("/login?t=wrong").DefaultTimeout(); 46var response = await host.GetTestClient().GetAsync("/login?t=wrong&returnUrl=/test").DefaultTimeout(); 54var response = await host.GetTestClient().GetAsync("/login?t=token").DefaultTimeout(); 62var response = await host.GetTestClient().GetAsync("/login?t=token&returnUrl=/test").DefaultTimeout();

IntegrationServicesTests.cs (1)

33var response = await _integrationServicesFixture.IntegrationServiceA.HttpGetAsync("http", $"/{resourceName}/verify");

tests\Shared\WorkloadTesting\AspireProject.cs (1)

364var res = await Client.Value.GetAsync(dashboardUrl, token);

tests\Shared\WorkloadTesting\ProjectInfo.cs (1)

20public Task<HttpResponseMessage> HttpGetAsync(string bindingName, string path, CancellationToken cancellationToken = default)

Dcp\DcpKubernetesClient.cs (1)

71var httpResponse = await SendRequest<object?>(url, HttpMethod.Get, customHeaders : null, body: null, cancellationToken).ConfigureAwait(false);

PostgresFunctionalTests.cs (2)

95var response = await client.GetAsync(path); 178var response = await client.PostAsync("/api/connect", httpContent);

RedisBuilderExtensions.cs (2)

289var deleteResponse = await client.SendAsync(deleteRequest, cancellationToken).ConfigureAwait(false); 297var response = await client.PostAsync(apiUrl, content, ctx)

RedisFunctionalTests.cs (5)

85var response = await client.GetAsync(path); 260var response = await client.GetAsync("/api/databases", cts.Token); 287var testConnectionResponse = await client.GetAsync($"/api/databases/test/{db.Id}", cts2.Token); 665var response = await httpClient.GetAsync("/api/settings", ct); 696var response = await client.PatchAsync(apiUrl, jsonContent, ct);

AppHostTests.cs (2)

97HttpResponseMessage? response = null; 272var response = await client.GetAsync(path);

tests\Shared\WorkloadTesting\AspireProject.cs (1)

364var res = await Client.Value.GetAsync(dashboardUrl, token);

tests\Shared\WorkloadTesting\ProjectInfo.cs (1)

20public Task<HttpResponseMessage> HttpGetAsync(string bindingName, string path, CancellationToken cancellationToken = default)

ClaimsTransformTests.cs (2)

25var response = await Client.GetAsync("/"); 36var response = await Client.GetAsync("/Home/MyClaims");

CookiesTests.cs (5)

24var response = await Client.GetAsync("/"); 35var response = await Client.GetAsync("/Home/MyClaims"); 58var response = await Client.GetAsync("/Account/Logout"); 72var response = await Client.GetAsync("/Home/MyClaims"); 81var goToSignIn = await Client.GetAsync("/account/login");

CustomAuthorizationFailureResponseTests.cs (2)

24var response = await Client.GetAsync("api/Sample/customPolicyWithCustomForbiddenMessage"); 34var response = await Client.GetAsync("api/Sample/customPolicy");

CustomPolicyProviderTests.cs (13)

28var response = await Client.GetAsync("/"); 39var response = await Client.GetAsync("/Home/MinimumAge10"); 51var signIn = await SignIn(Client, "Dude", DateTime.Now.Subtract(TimeSpan.FromDays(365 * 20)).ToString(DateTimeFormatInfo.InvariantInfo.ShortDatePattern, CultureInfo.InvariantCulture)); 54var response = await Client.GetAsync("/Home/MinimumAge10"); 67var signIn = await SignIn(Client, "Dude", DateTime.Now.Subtract(TimeSpan.FromDays(365 * 5)).ToString(DateTimeFormatInfo.InvariantInfo.ShortDatePattern, CultureInfo.InvariantCulture)); 70var response = await Client.GetAsync("/Home/MinimumAge10"); 82var signIn = await SignIn(Client, "Dude", DateTime.Now.Subtract(TimeSpan.FromDays(365 * 55)).ToString(DateTimeFormatInfo.InvariantInfo.ShortDatePattern, CultureInfo.InvariantCulture)); 85var response = await Client.GetAsync("/Home/MinimumAge50"); 98var signIn = await SignIn(Client, "Dude", DateTime.Now.Subtract(TimeSpan.FromDays(365 * 20)).ToString(DateTimeFormatInfo.InvariantInfo.ShortDatePattern, CultureInfo.InvariantCulture)); 101var response = await Client.GetAsync("/Home/MinimumAge50"); 113var response = await Client.GetAsync("/Home/MinimumAge50"); 121internal static async Task<HttpResponseMessage> SignIn(HttpClient client, string userName, string dob) 123var goToSignIn = await client.GetAsync("/account/signin");

DynamicSchemeTests.cs (4)

26var response = await Client.GetAsync("/"); 37var response = await AddScheme("New1", "NewOne"); 80private async Task<HttpResponseMessage> AddScheme(string name, string message) 82var goToSignIn = await Client.GetAsync("/");

HttpClientExtensions.cs (2)

16public static Task<HttpResponseMessage> SendAsync( 28public static Task<HttpResponseMessage> SendAsync(

IdentityExternalClaimsTests.cs (2)

25var response = await Client.GetAsync("/"); 36var response = await Client.GetAsync("/MyClaims");

PathSchemeSelectionTests.cs (7)

26var response = await Client.GetAsync("/"); 37var response = await Client.GetAsync("/api"); 48var response = await Client.GetAsync("/Home/MyClaims"); 60var response = await Client.GetAsync("/api/Home/MyClaims"); 84var response = await Client.GetAsync("/Account/Logout"); 98var response = await Client.GetAsync("/Home/MyClaims"); 107var goToSignIn = await Client.GetAsync("/account/login");

StaticFilesAuthTests.cs (2)

24var response = await Client.GetAsync("/"); 35var response = await Client.GetAsync(scenario);

TestAssert.cs (3)

67public static Uri IsRedirect(HttpResponseMessage responseMessage) 73public static async Task<IHtmlDocument> IsHtmlDocumentAsync(HttpResponseMessage response) 106internal static void IsOK(HttpResponseMessage download)

Services\WeatherForecastService.cs (1)

21var result = await _httpClient.GetAsync("/WeatherData");

BasicHttpBindingTests.4.0.0.cs (2)

118return Task.FromResult((HttpResponseMessage)null); 176return Task.FromResult((HttpResponseMessage)null);

HttpBindingTestHelpers.cs (5)

30public Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> OnSendingAsync { get; set; } 31public Func<HttpResponseMessage, CancellationToken, Task<HttpResponseMessage>> OnSentAsync { get; set; } 45protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 47HttpResponseMessage response;

NetHttpBindingTests.cs (1)

372return Task.FromResult<HttpResponseMessage>(null);

src\System.Private.ServiceModel\tests\Scenarios\Binding\Http\HttpBindingTestHelpers.cs (5)

30public Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> OnSendingAsync { get; set; } 31public Func<HttpResponseMessage, CancellationToken, Task<HttpResponseMessage>> OnSentAsync { get; set; } 45protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 47HttpResponseMessage response;

WSHttpBindingTests.cs (1)

372return Task.FromResult<HttpResponseMessage>(null);

LoggingMessageHandler.cs (2)

25protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 28var result = await base.SendAsync(request, cancellationToken);

DatabaseErrorPageMiddlewareTest.cs (7)

43HttpResponseMessage response = await server.CreateClient().GetAsync("http://localhost/"); 139HttpResponseMessage response = await server.CreateClient().GetAsync("http://localhost/"); 200HttpResponseMessage response = await server.CreateClient().GetAsync("http://localhost/"); 239HttpResponseMessage response = await server.CreateClient().GetAsync("http://localhost/"); 285HttpResponseMessage response = await client.GetAsync("http://localhost/"); 362HttpResponseMessage response = await server.CreateClient().GetAsync("http://localhost/"); 485HttpResponseMessage response = await server.CreateClient().GetAsync("http://localhost/");

MigrationsEndPointMiddlewareTest.cs (5)

40HttpResponseMessage response = await server.CreateClient().GetAsync("http://localhost/"); 125HttpResponseMessage response = await server.CreateClient() 161var response = await server.CreateClient().PostAsync("http://localhost" + MigrationsEndPointOptions.DefaultPath, formData); 193var response = await server.CreateClient().PostAsync("http://localhost" + MigrationsEndPointOptions.DefaultPath, formData); 222var response = await server.CreateClient().PostAsync("http://localhost" + MigrationsEndPointOptions.DefaultPath, formData);

DatabaseErrorPageSampleTest.cs (1)

28var response = await Client.SendAsync(request);

DeveloperExceptionPageSampleTest.cs (2)

29var response = await Client.SendAsync(request); 45var response = await Client.SendAsync(request);

ExceptionHandlerSampleTest.cs (1)

25var response = await Client.SendAsync(request);

MiddlewareAnalysisSampleTest.cs (1)

25var response = await Client.SendAsync(request);

ProblemDetailsExceptionHandlerSampleTest.cs (2)

30var response = await Client.SendAsync(request); 47var response = await Client.SendAsync(request);

StatusCodeSampleTest.cs (5)

30var response = await Client.SendAsync(request); 46var response = await Client.SendAsync(request); 64var response = await Client.SendAsync(request); 85var response = await Client.SendAsync(request); 102var response = await Client.SendAsync(request);

WelcomePageSampleTest.cs (1)

23var response = await Client.SendAsync(request);

HttpClientWrapper.cs (3)

31var response = await _client.GetAsync(url); 44private readonly HttpResponseMessage _response; 46public HttpResponseMessageWrapper(HttpResponseMessage response)

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\HttpChannelFactory.cs (1)

879private HttpResponseMessage _httpResponseMessage;

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\HttpChannelHelpers.cs (2)

112public static HttpResponseMessage ProcessGetResponseWebException(HttpRequestException requestException, HttpRequestMessage request, HttpAbortReason abortReason) 147internal static Exception CreateUnexpectedResponseException(HttpResponseMessage response)

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\HttpResponseMessageExtensionMethods.cs (4)

15internal static void CopyPropertiesFromMessage(this HttpResponseMessage httpResponseMessage, Message message) 29internal static bool CreateContentIfNull(this HttpResponseMessage httpResponseMessage) 42internal static void MergeWebHeaderCollection(this HttpResponseMessage responseMessage, WebHeaderCollection headersToMerge) 48internal static WebHeaderCollection ToWebHeaderCollection(this HttpResponseMessage httpResponse)

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\HttpResponseMessageHelper.cs (2)

21private readonly HttpResponseMessage _httpResponseMessage; 25public HttpResponseMessageHelper(HttpResponseMessage httpResponseMessage, HttpChannelFactory<IRequestChannel> factory)

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\HttpResponseMessageProperty.cs (6)

31internal HttpResponseMessageProperty(HttpResponseMessage httpResponseMessage) 153public HttpResponseMessage HttpResponseMessage 166internal static HttpResponseMessage GetHttpResponseMessageFromMessage(Message message) 168HttpResponseMessage httpResponseMessage = null; 291public HttpResponseMessageBackedProperty(HttpResponseMessage httpResponseMessage) 298public HttpResponseMessage HttpResponseMessage { get; private set; }

Program.cs (1)

114using var response = await httpClient.SendAsync(request).ConfigureAwait(false);

Startup.cs (1)

77var response = await client.GetAsync(uri);

Program.cs (1)

22var response = await client.GetAsync("https://localhost:5003");

Program.cs (13)

Http2TrailersResetTests.cs (16)

Http3Tests.cs (7)

50var response = await client.GetAsync(Fixture.Client.BaseAddress.ToString() + "Http3_Direct"); 70var response1 = await client.SendAsync(request); 76var response3 = await client.GetAsync(address); 92var response2 = await client.GetAsync(address); 109var response = await client.GetAsync(address); 136var response = await client.GetAsync(address, HttpCompletionOption.ResponseHeadersRead); 153var response = await client.GetAsync(address, HttpCompletionOption.ResponseHeadersRead);

src\Servers\IIS\IIS\test\Common.FunctionalTests\AspNetCorePortTests.cs (2)

95var response = await deploymentResult.HttpClient.GetAsync("/ServerAddresses"); 111var response = await deploymentResult.HttpClient.GetAsync("/Shutdown");

src\Servers\IIS\IIS\test\Common.FunctionalTests\BasicAuthTests.cs (1)

64var response = await deploymentResult.HttpClient.SendAsync(request);

src\Servers\IIS\IIS\test\Common.FunctionalTests\CompressionTests.cs (1)

142var response = await client.PostAsync("ReadAndWriteEchoLines", new StringContent(messages));

src\Servers\IIS\IIS\test\Common.FunctionalTests\GlobalVersionTests.cs (7)

52var response = await deploymentResult.HttpClient.GetAsync(_helloWorldRequest); 76var response = await deploymentResult.HttpClient.GetAsync(_helloWorldRequest); 99var response = await deploymentResult.HttpClient.GetAsync(_helloWorldRequest); 122var response = await deploymentResult.HttpClient.GetAsync(_helloWorldRequest); 146var response = await deploymentResult.HttpClient.GetAsync("CheckRequestHandlerVersion"); 167var response = await deploymentResult.HttpClient.GetAsync("CheckRequestHandlerVersion"); 199var response = await deploymentResult.HttpClient.GetAsync("HelloWorld");

src\Servers\IIS\IIS\test\Common.FunctionalTests\Http2Tests.cs (2)

320var response = await SendRequestAsync(Fixture.Client.BaseAddress.ToString() + "ResponseTrailers_HTTP1_TrailersNotAvailable", http2: false); 389private async Task<HttpResponseMessage> SendRequestAsync(string uri, bool http2 = true)

src\Servers\IIS\IIS\test\Common.FunctionalTests\HttpsTests.cs (1)

89var response = await client.GetAsync("GetClientCert");

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\Helpers.cs (8)

29var response = await deploymentResult.HttpClient.RetryRequestAsync(path, r => r.IsSuccessStatusCode); 41public static async Task StressLoad(HttpClient httpClient, string path, Action<HttpResponseMessage> action) 53var response = await connection.GetAsync(path); 105public static Task<HttpResponseMessage> RetryRequestAsync(this HttpClient client, string uri, Func<HttpResponseMessage, bool> predicate) 110public static async Task<HttpResponseMessage> RetryRequestAsync(this HttpClient client, string uri, Func<HttpResponseMessage, Task<bool>> predicate) 112HttpResponseMessage response = await client.GetAsync(uri);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\IISFunctionalTestBase.cs (2)

53var response = await deploymentResult.HttpClient.RetryRequestAsync("HelloWorld", r => r.StatusCode == HttpStatusCode.ServiceUnavailable); 68var response = await deploymentResult.HttpClient.RetryRequestAsync("HelloWorld", r => r.IsSuccessStatusCode);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Inprocess\HttpSysRequestInfoTests.cs (1)

35var response = await deploymentResult.HttpClient.GetAsync("/HttpSysRequestTimingInfo");

src\Servers\IIS\IIS\test\Common.FunctionalTests\Inprocess\MaxRequestBodySizeTests.cs (5)

44var result = await deploymentResult.HttpClient.PostAsync("/ReadRequestBody", new StringContent("test")); 64var result = await deploymentResult.HttpClient.PostAsync("/ReadRequestBody", new StringContent("test")); 87var result = await deploymentResult.HttpClient.PostAsync("/ReadRequestBodyLarger", new StringContent(new string('a', 100000000))); 108var result = await deploymentResult.HttpClient.PostAsync("/ReadRequestBodyLarger", new StringContent(new string('a', 10000))); 154var result = await deploymentResult.HttpClient.PostAsync("/IncreaseRequestLimit", new StringContent("1"));

src\Servers\IIS\IIS\test\Common.FunctionalTests\Latin1Tests.cs (2)

51var result = await client.SendAsync(requestMessage); 69var result = await client.SendAsync(requestMessage);

src\Servers\IIS\IIS\test\Common.FunctionalTests\LoggingTests.cs (5)

169var response = await deploymentResult.HttpClient.GetAsync("/"); 211var response = await deploymentResult.HttpClient.GetAsync(path); 245var response = await deploymentResult.HttpClient.GetAsync("Test"); 261var response = await deploymentResult.HttpClient.GetAsync("Test"); 275var response = await deploymentResult.HttpClient.GetAsync("Test");

src\Servers\IIS\IIS\test\Common.FunctionalTests\MaxRequestBodySizeTests.cs (5)

45var result = await deploymentResult.HttpClient.PostAsync("/ReadRequestBody", new StringContent("test")); 65var result = await deploymentResult.HttpClient.PostAsync("/ReadRequestBody", new StringContent("test")); 88var result = await deploymentResult.HttpClient.PostAsync("/ReadRequestBodyLarger", new StringContent(new string('a', 100000000))); 109var result = await deploymentResult.HttpClient.PostAsync("/ReadRequestBodyLarger", new StringContent(new string('a', 10000))); 155var result = await deploymentResult.HttpClient.PostAsync("/IncreaseRequestLimit", new StringContent("1"));

src\Servers\IIS\IIS\test\Common.FunctionalTests\MultiApplicationTests.cs (4)

59var result1 = await result.HttpClient.GetAsync("/app1/HelloWorld"); 60var result2 = await result.HttpClient.GetAsync("/app2/HelloWorld"); 86var result1 = await result.HttpClient.GetAsync("/app1/HelloWorld"); 87var result2 = await result.HttpClient.GetAsync("/app2/HelloWorld");

src\Servers\IIS\IIS\test\Common.FunctionalTests\RequestResponseTests.cs (19)

src\Servers\IIS\IIS\test\Common.FunctionalTests\WebSocketTests.cs (2)

43using var response = await client.PostAsync(Fixture.DeploymentResult.ApplicationBaseUri + "WebSocketNotUpgradable", new StringContent("Hello World")); 58using var response = await client.PostAsync(Fixture.DeploymentResult.ApplicationBaseUri + "WebSocketUpgradable", new StringContent(""));

src\Servers\IIS\IIS\test\Common.FunctionalTests\WindowsAuthTests.cs (1)

55var response = await client.GetAsync("/Auth");

src\Servers\IIS\IIS\test\IIS.Shared.FunctionalTests\StdOutRedirectionTests.cs (5)

45var response = await deploymentResult.HttpClient.GetAsync("/HelloWorld"); 69var response = await deploymentResult.HttpClient.GetAsync("/HelloWorld"); 99var response = await deploymentResult.HttpClient.GetAsync("/HelloWorld"); 125var response = await deploymentResult.HttpClient.GetAsync("/HelloWorld"); 152var response = await deploymentResult.HttpClient.GetAsync("/HelloWorld");

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\Helpers.cs (8)

29var response = await deploymentResult.HttpClient.RetryRequestAsync(path, r => r.IsSuccessStatusCode); 41public static async Task StressLoad(HttpClient httpClient, string path, Action<HttpResponseMessage> action) 53var response = await connection.GetAsync(path); 105public static Task<HttpResponseMessage> RetryRequestAsync(this HttpClient client, string uri, Func<HttpResponseMessage, bool> predicate) 110public static async Task<HttpResponseMessage> RetryRequestAsync(this HttpClient client, string uri, Func<HttpResponseMessage, Task<bool>> predicate) 112HttpResponseMessage response = await client.GetAsync(uri);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\IISFunctionalTestBase.cs (2)

53var response = await deploymentResult.HttpClient.RetryRequestAsync("HelloWorld", r => r.StatusCode == HttpStatusCode.ServiceUnavailable); 68var response = await deploymentResult.HttpClient.RetryRequestAsync("HelloWorld", r => r.IsSuccessStatusCode);

src\Servers\IIS\IIS\test\Common.LongTests\ShutdownTests.cs (10)

src\Servers\IIS\IIS\test\Common.LongTests\StartupTests.cs (33)

StartupTimeBenchmark.cs (1)

50var response = await _client.GetAsync("");

NewHandlerTests.cs (1)

27var response = await result.HttpClient.GetAsync("/HelloWorld");

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\Helpers.cs (8)

29var response = await deploymentResult.HttpClient.RetryRequestAsync(path, r => r.IsSuccessStatusCode); 41public static async Task StressLoad(HttpClient httpClient, string path, Action<HttpResponseMessage> action) 53var response = await connection.GetAsync(path); 105public static Task<HttpResponseMessage> RetryRequestAsync(this HttpClient client, string uri, Func<HttpResponseMessage, bool> predicate) 110public static async Task<HttpResponseMessage> RetryRequestAsync(this HttpClient client, string uri, Func<HttpResponseMessage, Task<bool>> predicate) 112HttpResponseMessage response = await client.GetAsync(uri);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\IISFunctionalTestBase.cs (2)

53var response = await deploymentResult.HttpClient.RetryRequestAsync("HelloWorld", r => r.StatusCode == HttpStatusCode.ServiceUnavailable); 68var response = await deploymentResult.HttpClient.RetryRequestAsync("HelloWorld", r => r.IsSuccessStatusCode);

src\Servers\IIS\IIS\test\Common.LongTests\ShutdownTests.cs (10)

src\Servers\IIS\IIS\test\Common.LongTests\StartupTests.cs (33)

NewShimTests.cs (1)

25var response = await result.HttpClient.GetAsync("/HelloWorld");

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\Helpers.cs (8)

29var response = await deploymentResult.HttpClient.RetryRequestAsync(path, r => r.IsSuccessStatusCode); 41public static async Task StressLoad(HttpClient httpClient, string path, Action<HttpResponseMessage> action) 53var response = await connection.GetAsync(path); 105public static Task<HttpResponseMessage> RetryRequestAsync(this HttpClient client, string uri, Func<HttpResponseMessage, bool> predicate) 110public static async Task<HttpResponseMessage> RetryRequestAsync(this HttpClient client, string uri, Func<HttpResponseMessage, Task<bool>> predicate) 112HttpResponseMessage response = await client.GetAsync(uri);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\IISFunctionalTestBase.cs (2)

53var response = await deploymentResult.HttpClient.RetryRequestAsync("HelloWorld", r => r.StatusCode == HttpStatusCode.ServiceUnavailable); 68var response = await deploymentResult.HttpClient.RetryRequestAsync("HelloWorld", r => r.IsSuccessStatusCode);

src\Servers\IIS\IIS\test\Common.LongTests\ShutdownTests.cs (10)

src\Servers\IIS\IIS\test\Common.LongTests\StartupTests.cs (33)

ShadowCopyTests.cs (10)

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\Helpers.cs (8)

29var response = await deploymentResult.HttpClient.RetryRequestAsync(path, r => r.IsSuccessStatusCode); 41public static async Task StressLoad(HttpClient httpClient, string path, Action<HttpResponseMessage> action) 53var response = await connection.GetAsync(path); 105public static Task<HttpResponseMessage> RetryRequestAsync(this HttpClient client, string uri, Func<HttpResponseMessage, bool> predicate) 110public static async Task<HttpResponseMessage> RetryRequestAsync(this HttpClient client, string uri, Func<HttpResponseMessage, Task<bool>> predicate) 112HttpResponseMessage response = await client.GetAsync(uri);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\IISFunctionalTestBase.cs (2)

53var response = await deploymentResult.HttpClient.RetryRequestAsync("HelloWorld", r => r.StatusCode == HttpStatusCode.ServiceUnavailable); 68var response = await deploymentResult.HttpClient.RetryRequestAsync("HelloWorld", r => r.IsSuccessStatusCode);

ResponseBodySizeTests.cs (1)

27var response = await testServer.HttpClient.GetAsync("/");

TestServerTest.cs (1)

30var result = await testServer.HttpClient.GetAsync(expectedPath);

InProcess\AuthenticationTests.cs (1)

31var response = await deploymentResult.HttpClient.GetAsync("/AuthenticationAnonymous");

InProcess\IISExpressShutdownTests.cs (2)

84var response = await result.HttpClient.GetAsync("/HelloWorld"); 96var response = await result.HttpClient.GetAsync("/HelloWorld");

OutOfProcess\MultipleAppTests.cs (2)

45var requestTasks = new List<Task<HttpResponseMessage>>(); 54var response = await requestTask;

OutOfProcess\NtlmAuthentationTest.cs (1)

45var response = await result.HttpClient.GetAsync("/HelloWorld");

src\Servers\IIS\IIS\test\Common.FunctionalTests\AspNetCorePortTests.cs (2)

95var response = await deploymentResult.HttpClient.GetAsync("/ServerAddresses"); 111var response = await deploymentResult.HttpClient.GetAsync("/Shutdown");

src\Servers\IIS\IIS\test\Common.FunctionalTests\BasicAuthTests.cs (1)

64var response = await deploymentResult.HttpClient.SendAsync(request);

src\Servers\IIS\IIS\test\Common.FunctionalTests\CompressionTests.cs (1)

142var response = await client.PostAsync("ReadAndWriteEchoLines", new StringContent(messages));

src\Servers\IIS\IIS\test\Common.FunctionalTests\GlobalVersionTests.cs (7)

52var response = await deploymentResult.HttpClient.GetAsync(_helloWorldRequest); 76var response = await deploymentResult.HttpClient.GetAsync(_helloWorldRequest); 99var response = await deploymentResult.HttpClient.GetAsync(_helloWorldRequest); 122var response = await deploymentResult.HttpClient.GetAsync(_helloWorldRequest); 146var response = await deploymentResult.HttpClient.GetAsync("CheckRequestHandlerVersion"); 167var response = await deploymentResult.HttpClient.GetAsync("CheckRequestHandlerVersion"); 199var response = await deploymentResult.HttpClient.GetAsync("HelloWorld");

src\Servers\IIS\IIS\test\Common.FunctionalTests\Http2Tests.cs (2)

320var response = await SendRequestAsync(Fixture.Client.BaseAddress.ToString() + "ResponseTrailers_HTTP1_TrailersNotAvailable", http2: false); 389private async Task<HttpResponseMessage> SendRequestAsync(string uri, bool http2 = true)

src\Servers\IIS\IIS\test\Common.FunctionalTests\HttpsTests.cs (1)

89var response = await client.GetAsync("GetClientCert");

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\Helpers.cs (8)

29var response = await deploymentResult.HttpClient.RetryRequestAsync(path, r => r.IsSuccessStatusCode); 41public static async Task StressLoad(HttpClient httpClient, string path, Action<HttpResponseMessage> action) 53var response = await connection.GetAsync(path); 105public static Task<HttpResponseMessage> RetryRequestAsync(this HttpClient client, string uri, Func<HttpResponseMessage, bool> predicate) 110public static async Task<HttpResponseMessage> RetryRequestAsync(this HttpClient client, string uri, Func<HttpResponseMessage, Task<bool>> predicate) 112HttpResponseMessage response = await client.GetAsync(uri);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\IISFunctionalTestBase.cs (2)

53var response = await deploymentResult.HttpClient.RetryRequestAsync("HelloWorld", r => r.StatusCode == HttpStatusCode.ServiceUnavailable); 68var response = await deploymentResult.HttpClient.RetryRequestAsync("HelloWorld", r => r.IsSuccessStatusCode);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Inprocess\HttpSysRequestInfoTests.cs (1)

35var response = await deploymentResult.HttpClient.GetAsync("/HttpSysRequestTimingInfo");

src\Servers\IIS\IIS\test\Common.FunctionalTests\Inprocess\MaxRequestBodySizeTests.cs (5)

44var result = await deploymentResult.HttpClient.PostAsync("/ReadRequestBody", new StringContent("test")); 64var result = await deploymentResult.HttpClient.PostAsync("/ReadRequestBody", new StringContent("test")); 87var result = await deploymentResult.HttpClient.PostAsync("/ReadRequestBodyLarger", new StringContent(new string('a', 100000000))); 108var result = await deploymentResult.HttpClient.PostAsync("/ReadRequestBodyLarger", new StringContent(new string('a', 10000))); 154var result = await deploymentResult.HttpClient.PostAsync("/IncreaseRequestLimit", new StringContent("1"));

src\Servers\IIS\IIS\test\Common.FunctionalTests\Latin1Tests.cs (2)

51var result = await client.SendAsync(requestMessage); 69var result = await client.SendAsync(requestMessage);

src\Servers\IIS\IIS\test\Common.FunctionalTests\LoggingTests.cs (5)

169var response = await deploymentResult.HttpClient.GetAsync("/"); 211var response = await deploymentResult.HttpClient.GetAsync(path); 245var response = await deploymentResult.HttpClient.GetAsync("Test"); 261var response = await deploymentResult.HttpClient.GetAsync("Test"); 275var response = await deploymentResult.HttpClient.GetAsync("Test");

src\Servers\IIS\IIS\test\Common.FunctionalTests\MaxRequestBodySizeTests.cs (5)

45var result = await deploymentResult.HttpClient.PostAsync("/ReadRequestBody", new StringContent("test")); 65var result = await deploymentResult.HttpClient.PostAsync("/ReadRequestBody", new StringContent("test")); 88var result = await deploymentResult.HttpClient.PostAsync("/ReadRequestBodyLarger", new StringContent(new string('a', 100000000))); 109var result = await deploymentResult.HttpClient.PostAsync("/ReadRequestBodyLarger", new StringContent(new string('a', 10000))); 155var result = await deploymentResult.HttpClient.PostAsync("/IncreaseRequestLimit", new StringContent("1"));

src\Servers\IIS\IIS\test\Common.FunctionalTests\MultiApplicationTests.cs (4)

59var result1 = await result.HttpClient.GetAsync("/app1/HelloWorld"); 60var result2 = await result.HttpClient.GetAsync("/app2/HelloWorld"); 86var result1 = await result.HttpClient.GetAsync("/app1/HelloWorld"); 87var result2 = await result.HttpClient.GetAsync("/app2/HelloWorld");

src\Servers\IIS\IIS\test\Common.FunctionalTests\RequestResponseTests.cs (19)

src\Servers\IIS\IIS\test\Common.FunctionalTests\WebSocketTests.cs (2)

43using var response = await client.PostAsync(Fixture.DeploymentResult.ApplicationBaseUri + "WebSocketNotUpgradable", new StringContent("Hello World")); 58using var response = await client.PostAsync(Fixture.DeploymentResult.ApplicationBaseUri + "WebSocketUpgradable", new StringContent(""));

src\Servers\IIS\IIS\test\Common.FunctionalTests\WindowsAuthTests.cs (1)

55var response = await client.GetAsync("/Auth");

src\Servers\IIS\IIS\test\Common.LongTests\ShutdownTests.cs (10)

src\Servers\IIS\IIS\test\Common.LongTests\StartupTests.cs (33)

UpgradeFeatureDetectionTests.cs (1)

74var response = await deploymentResult.HttpClient.GetAsync("UpgradeFeatureDetection");

ServiceUtilHelper.cs (3)

544HttpResponseMessage response = httpClient.GetAsync(requestUri).GetAwaiter().GetResult(); 556HttpResponseMessage response = httpClient.GetAsync(requestUri).GetAwaiter().GetResult(); 568HttpResponseMessage response = await httpClient.GetAsync(requestUri);

EventSourceTests.cs (1)

195using var responseMessage = await httpClient.SendAsync(httpRequestMessage);

Http2\Http2EndToEndTests.cs (1)

72using var responseMessage = await httpClient.SendAsync(httpRequestMessage);

KestrelMetricsTests.cs (4)

552HttpResponseMessage responseMessage = null; 630HttpResponseMessage responseMessage = null; 731using var responseMessage = await httpClient.SendAsync(httpRequestMessage); 813using var responseMessage = await httpClient.SendAsync(httpRequestMessage, HttpCompletionOption.ResponseHeadersRead).DefaultTimeout();

StaticFileRegeneration\RegenerateThirdPartyNotices.cs (1)

74HttpResponseMessage response = await client.GetAsync(c.Url);

Http2\Http2RequestTests.cs (4)

130var response1 = await client.SendAsync(request1, CancellationToken.None); 187var response = await client.SendAsync(request1, CancellationToken.None); 214var responseMessage = await client.SendAsync(request, CancellationToken.None).DefaultTimeout(); 298var responseMessage = await client.SendAsync(request, CancellationToken.None).DefaultTimeout();

Http2WebSocketInteropTests.cs (1)

197protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

Http3\Http3RequestTests.cs (36)

Http3\Http3TlsTests.cs (7)

61var response = await client.SendAsync(request, CancellationToken.None).DefaultTimeout(); 107var response = await client.SendAsync(request, CancellationToken.None).DefaultTimeout(); 149var response = await client.SendAsync(request, CancellationToken.None).DefaultTimeout(); 209using var response = await sendTask.DefaultTimeout(); 248var response = await client.SendAsync(request, CancellationToken.None).DefaultTimeout(); 327var response = await client.SendAsync(request, CancellationToken.None).DefaultTimeout(); 492var response = await client.SendAsync(request, CancellationToken.None).DefaultTimeout();

HttpClientHttp2InteropTests.cs (31)

Program.cs (1)

84var httpResponse = await new HttpClient().GetAsync(ServerUrl + $"/generatetoken?user={userId}");

AuthorizationHandler.cs (1)

8protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

ArcadeHttpMessageHandler.cs (2)

15public Task<HttpResponseMessage> SendAsync(HttpRequestMessage request) => SendAsync(request, CancellationToken.None); 17protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

RequestResponseHelper.cs (1)

14public HttpResponseMessage ResponseMessage { get; set;}

FakeHttpClient.cs (4)

15public static HttpClient WithResponses(params HttpResponseMessage[] responses) 21private readonly IEnumerator<HttpResponseMessage> _responseEnumerator; 23public FakeHttpMessageHandler(IEnumerable<HttpResponseMessage> responses) 36protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

FacebookHandler.cs (1)

52var response = await Backchannel.GetAsync(endpoint, Context.RequestAborted);

GoogleHandler.cs (1)

50var response = await Backchannel.SendAsync(request, Context.RequestAborted);

MicrosoftAccountHandler.cs (1)

46var response = await Backchannel.SendAsync(request, Context.RequestAborted);

OAuthHandler.cs (2)

222var response = await Backchannel.SendAsync(requestMessage, Context.RequestAborted); 232private static OAuthTokenResponse PrepareFailedOAuthTokenResponse(HttpResponseMessage response, string body)

OpenIdConnectHandler.cs (5)

599var parResponseMessage = await Backchannel.SendAsync(requestMessage, Context.RequestAborted); 608private async Task<string> GetPushedAuthorizationRequestUri(HttpResponseMessage parResponseMessage) 994var responseMessage = await Backchannel.SendAsync(requestMessage, Context.RequestAborted); 1060var responseMessage = await Backchannel.SendAsync(requestMessage, Context.RequestAborted); 1513private OpenIdConnectProtocolException CreateOpenIdConnectProtocolException(OpenIdConnectMessage message, HttpResponseMessage? response)

AuthenticationMiddlewareTests.cs (1)

56var response = await server.CreateClient().GetAsync("http://example.com/");

CertificateTests.cs (28)

CookieTests.cs (2)

40var response = await server.CreateClient().GetAsync("http://example.com/normal"); 1937public HttpResponseMessage Response { get; set; }

DynamicSchemeTests.cs (2)

31var response = await server.CreateClient().GetAsync("http://example.com/add/One"); 66var response = await server.CreateClient().GetAsync("http://example.com/add/One");

FacebookTests.cs (7)

139var res = transaction.Response; 171var res = transaction.Response; 203var res = transaction.Response; 335var res = new HttpResponseMessage(HttpStatusCode.OK); 344var res = new HttpResponseMessage(HttpStatusCode.OK); 478private static HttpResponseMessage ReturnJsonResponse(object content, HttpStatusCode code = HttpStatusCode.OK) 480var res = new HttpResponseMessage(code);

GoogleTests.cs (2)

1122private static HttpResponseMessage ReturnJsonResponse(object content, HttpStatusCode code = HttpStatusCode.OK) 1124var res = new HttpResponseMessage(code);

JwtBearerTests.cs (1)

909var response = await server.CreateClient().SendAsync(new HttpRequestMessage(HttpMethod.Get, string.Empty));

JwtBearerTests_Handler.cs (1)

854var response = await server.CreateClient().SendAsync(new HttpRequestMessage(HttpMethod.Get, string.Empty));

MicrosoftAccountTests.cs (5)

144var res = transaction.Response; 162var res = transaction.Response; 180var res = transaction.Response; 425private static HttpResponseMessage ReturnJsonResponse(object content) 427var res = new HttpResponseMessage(HttpStatusCode.OK);

OAuthTests.cs (8)

132var res = transaction.Response; 160var res = transaction.Response; 190var res = transaction.Response; 216var res = transaction.Response; 245var res = transaction.Response; 274var res = transaction.Response; 533private static HttpResponseMessage ReturnJsonResponse(object content, HttpStatusCode code = HttpStatusCode.OK) 535var res = new HttpResponseMessage(code);

OpenIdConnect\OpenIdConnectChallengeTests.cs (28)

OpenIdConnect\OpenIdConnectEventTests.cs (36)

OpenIdConnect\OpenIdConnectEventTests_Handler.cs (36)

OpenIdConnect\OpenIdConnectTests.cs (6)

48var res = transaction.Response; 75var res = transaction.Response; 102var res = transaction.Response; 128var res = transaction.Response; 155var res = transaction.Response; 180var res = transaction.Response;

OpenIdConnect\TestSettings.cs (2)

318protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 332private async Task<HttpResponseMessage> ReturnResource(string resource)

OpenIdConnect\TestTransaction.cs (1)

13public HttpResponseMessage Response { get; set; }

TestHttpMessageHandler.cs (3)

10public Func<HttpRequestMessage, HttpResponseMessage> Sender { get; set; } 12protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, System.Threading.CancellationToken cancellationToken) 19return Task.FromResult<HttpResponseMessage>(null);

Transaction.cs (1)

12public HttpResponseMessage Response { get; set; }

TwitterTests.cs (9)

221var response = await client.SendAsync(request); 271var response = await client.SendAsync(request); 378var response = await client.SendAsync(request); 399var res = new HttpResponseMessage(HttpStatusCode.OK); 468var res = new HttpResponseMessage(HttpStatusCode.OK); 484var res = new HttpResponseMessage(HttpStatusCode.OK); 592private HttpResponseMessage BackchannelRequestToken(HttpRequestMessage req) 607private HttpResponseMessage JsonErroredBackchannelRequestToken(HttpRequestMessage req) 622private HttpResponseMessage UnknownContentTypeErroredBackchannelRequestToken(HttpRequestMessage req)

WsFederation\WsFederationTest.cs (12)

75var response = await httpClient.GetAsync("/"); 91var response = await httpClient.GetAsync("/mapped-challenge"); 107var response = await httpClient.GetAsync("/premapped-challenge"); 123var response = await httpClient.GetAsync("/"); 156var response = await httpClient.PostAsync(httpClient.BaseAddress + "signin-wsfed", form); 174var response = await httpClient.GetAsync("/"); 191var response = await httpClient.GetAsync("/signin-wsfed?wa=wsignoutcleanup1.0"); 233var result = await server.CreateClient().GetAsync(""); 262private void CopyCookies(HttpResponseMessage response, HttpRequestMessage request) 450protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 453var newResponse = new HttpResponseMessage() { Content = new StringContent(metadata, Encoding.UTF8, "text/xml") }; 454return Task.FromResult<HttpResponseMessage>(newResponse);

WsFederation\WsFederationTest_Handler.cs (12)

73var response = await httpClient.GetAsync("/"); 89var response = await httpClient.GetAsync("/mapped-challenge"); 105var response = await httpClient.GetAsync("/premapped-challenge"); 121var response = await httpClient.GetAsync("/"); 154var response = await httpClient.PostAsync(httpClient.BaseAddress + "signin-wsfed", form); 172var response = await httpClient.GetAsync("/"); 189var response = await httpClient.GetAsync("/signin-wsfed?wa=wsignoutcleanup1.0"); 231var result = await server.CreateClient().GetAsync(""); 260private void CopyCookies(HttpResponseMessage response, HttpRequestMessage request) 446protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 449var newResponse = new HttpResponseMessage() { Content = new StringContent(metadata, Encoding.UTF8, "text/xml") }; 450return Task.FromResult<HttpResponseMessage>(newResponse);

TwitterHandler.cs (5)

183private async Task<HttpResponseMessage> ExecuteRequestAsync(string url, HttpMethod httpMethod, RequestToken? accessToken = null, Dictionary<string, string>? extraOAuthPairs = null, Dictionary<string, string>? queryParameters = null, Dictionary<string, string>? formData = null) 273var response = await ExecuteRequestAsync(TwitterDefaults.RequestTokenEndpoint, HttpMethod.Post, extraOAuthPairs: new Dictionary<string, string>() { { "oauth_callback", callBackUri } }); 299var response = await ExecuteRequestAsync(TwitterDefaults.AccessTokenEndpoint, HttpMethod.Post, token, formData: formPost); 324var response = await ExecuteRequestAsync("https://api.twitter.com/1.1/account/verify_credentials.json", HttpMethod.Get, accessToken, queryParameters: new Dictionary<string, string>() { { "include_email", "true" } }); 356private async Task EnsureTwitterRequestSuccess(HttpResponseMessage response)

Transaction.cs (1)

13public HttpResponseMessage Response { get; set; }

CorsMiddlewareTests.cs (10)

HealthCheckEndpointRouteBuilderExtensionsTest.cs (2)

77var response = await client.GetAsync("/healthz"); 122var response = await client.GetAsync("/healthz");

HealthCheckMiddlewareSampleTest.cs (4)

29var response = await client.GetAsync("/health"); 51var response = await client.GetAsync("/health"); 74var response = await client.GetAsync("/health/live"); 96var response = await client.GetAsync("/health/ready");

HealthCheckMiddlewareTests.cs (25)

Latency\ChecpointAcceptanceTests.cs (2)

103HttpResponseMessage? response = null; 127using var response = await host.GetTestServer().CreateClient().GetAsync("/Path");

Logging\AcceptanceTests.cs (13)

Logging\AcceptanceTests.Mvc.cs (5)

65using var response = await client.GetAsync($"/api/users/{UserId}/someTestData?{QueryParamName}=foo").ConfigureAwait(false); 100using var response = await client.GetAsync($"/api/users/{UserId}/someTestData?{QueryParamName}=foo").ConfigureAwait(false); 146using var response = await client.GetAsync($"/api/users/{UserId}/{NoDataClassParamValue}?{QueryParamName}=foo").ConfigureAwait(false); 190using var response = await client.GetAsync($"/api/users/{UserId}/someTestData?{QueryParamName}=foo").ConfigureAwait(false); 231using var response = await client.GetAsync(RequestPath).ConfigureAwait(false);

Logging\AcceptanceTests.Routing.cs (1)

65using var response = await client.GetAsync(httpPath).ConfigureAwait(false);

DeveloperExceptionPageMiddlewareTest.cs (11)

ExceptionHandlerMiddlewareTest.cs (3)

72var response = await server.CreateClient().SendAsync(request); 338var response = await server.CreateClient().GetAsync("/path"); 405var response = await server.CreateClient().GetAsync("/path");

ExceptionHandlerTest.cs (18)

StatusCodeMiddlewareTest.cs (8)

61var response = await client.GetAsync(destination); 127var response = await client.GetAsync(destination + "?name=James"); 189var response = await client.GetAsync(destination + "?name=James"); 244var response = await client.GetAsync(destination + "?name=James"); 278var response = await client.GetAsync("/"); 312var response = await client.GetAsync("/"); 349var response = await client.GetAsync("/skip"); 387var response = await client.GetAsync("/");

WebHostFunctionalTests.cs (6)

39var response = await RetryHelper.RetryRequest(() => deploymentResult.HttpClient.GetAsync(string.Empty), logger, deploymentResult.HostShutdownToken, retryCount: 5); 64var response = await RetryHelper.RetryRequest(() => deploymentResult.HttpClient.GetAsync(string.Empty), logger, deploymentResult.HostShutdownToken, retryCount: 5); 91var response = await RetryHelper.RetryRequest(() => deploymentResult.HttpClient.GetAsync(string.Empty), logger, deploymentResult.HostShutdownToken); 165var response = await RetryHelper.RetryRequest(() => deploymentResult.HttpClient.GetAsync(string.Empty), Logger, deploymentResult.HostShutdownToken, retryCount: 5); 184private async Task ExecuteStartOrStartWithTest(Func<DeploymentResult, Task<HttpResponseMessage>> getResponse, string applicationName) 188var response = await RetryHelper.RetryRequest(() => getResponse(deploymentResult), logger, deploymentResult.HostShutdownToken);

HeaderPropagationMessageHandler.cs (1)

41protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

HeaderPropagationIntegrationTest.cs (5)

64var response = await client.SendAsync(request); 113var response = await client.SendAsync(request); 140var response = await client.SendAsync(request); 186var response = await client.SendAsync(request); 232protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

HeaderPropagationMessageHandlerTest.cs (1)

264protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,

HostFilteringMiddlewareTests.cs (5)

74var response = await server.CreateClient().GetAsync("/"); 117var response = await server.CreateClient().GetAsync("/"); 168var response = await server.CreateRequest("/").GetAsync(); 220var response = await server.CreateRequest("/").GetAsync(); 259var response = await server.CreateRequest("/").GetAsync();

LinkedApplicationTests.cs (1)

46var response = await RetryHelper.RetryRequest(() => result.HttpClient.GetAsync("/"), logger, retryCount: 10);

HttpConnection.cs (1)

485using (var response = await httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false))

Internal\AccessTokenHttpMessageHandler.cs (2)

22protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 40var result = await base.SendAsync(request, cancellationToken).ConfigureAwait(false);

Internal\Http2HttpMessageHandler.cs (1)

20protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

Internal\LoggingHttpMessageHandler.cs (2)

25protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 29var response = await base.SendAsync(request, cancellationToken).ConfigureAwait(false);

Internal\LongPollingTransport.cs (3)

57using (var response = await _httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false)) 156HttpResponseMessage response; 235var response = await _httpClient.SendAsync(request).ConfigureAwait(false);

Internal\LongPollingTransport.Log.cs (1)

44public static void PollResponseReceived(ILogger logger, HttpResponseMessage response)

Internal\SendUtils.cs (1)

51using (var response = await httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false))

Internal\ServerSentEventsTransport.cs (3)

58HttpResponseMessage? response = null; 88private async Task ProcessAsync(Uri url, HttpResponseMessage response) 126private async Task ProcessEventStream(HttpResponseMessage response, CancellationToken cancellationToken)

HttpConnectionDispatcherTests.cs (5)

3259var response = await client.GetAsync("generatetoken?user=bob"); 3322var response = await client.GetAsync("signin?user=bob"); 3421var response = await client.GetAsync("generatetoken?user=bob"); 3607protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 3609var response = await base.SendAsync(request, cancellationToken);

HttpResponseJsonExtensionsTests.cs (2)

512var result = await client.GetAsync("/"); 544var result = await client.GetAsync("/");

HttpLoggingMiddlewareTests.cs (11)

HstsMiddlewareTests.cs (8)

68var response = await client.SendAsync(request); 114var response = await client.SendAsync(request); 160var response = await client.SendAsync(request); 205var response = await client.SendAsync(request); 260var response = await client.SendAsync(request); 315var response = await client.SendAsync(request); 362var response = await client.SendAsync(request); 408var response = await client.SendAsync(request);

HttpsPolicyTests.cs (1)

67var response = await client.SendAsync(request);

HttpsRedirectionMiddlewareTests.cs (8)

53var response = await client.SendAsync(request); 108var response = await client.SendAsync(request); 164var response = await client.SendAsync(request); 226var response = await client.SendAsync(request); 266var response = await client.SendAsync(request); 354var response = await client.SendAsync(request); 401var response = await client.SendAsync(request); 445var response = await client.SendAsync(request);

AuthorizationTests.cs (4)

47var response = await client.GetAsync(url); 86var response = await client.GetAsync(url); 119var response = await client.GetAsync(url); 147var response = await client.GetAsync(url);

Extensions\HttpClientExtensions.cs (3)

11public static Task<HttpResponseMessage> SendAsync( 19public static Task<HttpResponseMessage> SendAsync( 30public static Task<HttpResponseMessage> SendAsync(

Extensions\ResponseAssert.cs (3)

15public static Uri IsRedirect(HttpResponseMessage responseMessage) 21public static async Task<IHtmlDocument> IsHtmlDocumentAsync(HttpResponseMessage response) 54internal static void IsOK(HttpResponseMessage download)

ManagementTests.cs (1)

343var response = await client.GetAsync("/Identity/Account/Manage/DownloadPersonalData");

MapIdentityApiTests.cs (52)

NoIdentityAddedTests.cs (1)

32var response = await client.GetAsync(endpoint);

Pages\Account\ConfirmEmail.cs (1)

20var response = await client.GetAsync(link.Href);

Pages\Account\ExternalLogin.cs (4)

29var response = await Client.SendAsync(_emailForm, new Dictionary<string, string> 34var indexResponse = await Client.GetAsync(redirect); 41var response = await Client.SendAsync(_emailForm, new Dictionary<string, string> 48var registerResponse = await Client.GetAsync(redirect);

Pages\Account\ForgotPassword.cs (2)

20var response = await Client.SendAsync(_forgotPasswordForm, new Dictionary<string, string> 25var forgotPasswordConfirmationResponse = await Client.GetAsync(goToForgotPasswordConfirmation);

Pages\Account\Login.cs (12)

37var externalFormResponse = await Client.SendAsync(_externalLoginForm, _contosoButton); 39var contosoLoginResponse = await Client.GetAsync(goToContosoLogin); 48var response = await Client.GetAsync(_forgotPasswordLink.Href); 56var response = await Client.GetAsync(_reconfirmLink.Href); 64var loggedIn = await SendLoginForm(userName, password); 68var indexResponse = await Client.GetAsync(loggedInLocation); 78var failedLogin = await SendLoginForm(userName, password); 87var loginAttempt = await SendLoginForm(userName, password); 92var lockedOutResponse = await Client.GetAsync(lockedOut); 97private async Task<HttpResponseMessage> SendLoginForm(string userName, string password) 108var loggedIn = await SendLoginForm(userName, password); 112var loginWithTwoFactorResponse = await Client.GetAsync(loggedInLocation);

Pages\Account\LoginWith2fa.cs (3)

28var response = await Client.SendAsync(_twoFactorForm, new Dictionary<string, string> 35var indexResponse = await Client.GetAsync(goToIndex); 43var goToLoginWithRecoveryCode = await Client.GetAsync(_loginWithRecoveryCodeLink.Href);

Pages\Account\LoginWithRecoveryCode.cs (2)

21var response = await Client.SendAsync(_loginWithRecoveryCodeForm, new Dictionary<string, string> 27var indexPage = await Client.GetAsync(goToIndex);

Pages\Account\Manage\DeleteUser.cs (3)

21var loggedIn = await SendDeleteForm(password); 25var indexResponse = await Client.GetAsync(deleteLocation); 30private async Task<HttpResponseMessage> SendDeleteForm(string password)

Pages\Account\Manage\Email.cs (4)

38var response = await Client.SendAsync(_changeEmailForm, _confirmEmailButton); 40var manageResponse = await Client.GetAsync(goToManage); 48var response = await Client.SendAsync(_changeEmailForm, _changeEmailButton, new Dictionary<string, string> 53var manageResponse = await Client.GetAsync(goToManage);

Pages\Account\Manage\EnableAuthenticator.cs (2)

34var sendCodeResponse = await Client.SendAsync(_sendCodeForm, new Dictionary<string, string> 40var showRecoveryCodesResponse = await Client.GetAsync(goToShowRecoveryCodes);

Pages\Account\Manage\Index.cs (9)

Pages\Account\Manage\LinkExternalLogin.cs (2)

24var linkExternalLogin = await Client.SendAsync(_linkLoginForm, _linkLoginButton); 26var externalLoginResponse = await Client.GetAsync(goToLinkExternalLogin);

Pages\Account\Manage\ManageExternalLogin.cs (3)

21var linkedExternalLogin = await Client.SendAsync(_externalLoginForm, new Dictionary<string, string> 27var externalLoginResponse = await Client.GetAsync(goToLinkedExternalLogin); 29var manageExternalLoginResponse = await Client.GetAsync(goToManageExternalLogin);

Pages\Account\Manage\PersonalData.cs (2)

23var goToDelete = await Client.GetAsync(_deleteLink.Href); 28internal async Task<HttpResponseMessage> SubmitDownloadForm()

Pages\Account\Manage\TwoFactorAuthentication.cs (2)

38var goToEnableAuthenticator = await Client.GetAsync(_enableAuthenticatorLink.Href); 46var goToResetAuthenticator = await Client.GetAsync(_resetAuthenticatorLink.Href);

Pages\Account\Register.cs (6)

28var externalFormResponse = await Client.SendAsync(_externalLoginForm, _contosoButton); 30var contosoLoginResponse = await Client.GetAsync(goToContosoLogin); 39var registered = await Client.SendAsync(_registerForm, new Dictionary<string, string>() 48var indexResponse = await Client.GetAsync(registeredLocation); 56var registered = await Client.SendAsync(_registerForm, new Dictionary<string, string>() 65var registerResponse = await Client.GetAsync(registeredLocation);

Pages\Account\ResendEmailConfirmation.cs (1)

18public Task<HttpResponseMessage> ResendAsync(string email)

Pages\Account\ResetPassword.cs (3)

20var resetPasswordResponse = await client.GetAsync(link.Href); 28var resetPasswordResponse = await Client.SendAsync(_resetPasswordForm, new Dictionary<string, string> 36var resetPasswordConfirmationResponse = await Client.GetAsync(goToResetPasswordConfirmation);

Pages\Contoso\Login.cs (3)

36var contosoResponse = await Client.SendAsync(_loginForm, new Dictionary<string, string> 42var externalLogInResponse = await Client.GetAsync(goToExternalLogin); 46var indexResponse = await Client.GetAsync(goToIndex);

Pages\Index.cs (5)

36var goToIndex = await client.GetAsync("/"); 46var goToRegister = await Client.GetAsync(_registerLink.Href); 56var goToLogin = await Client.GetAsync(_loginLink.Href); 66var goToManage = await Client.GetAsync(_manageLink.Href); 76var goToManage = await Client.GetAsync(_manageLink.Href);

Pages\RegisterConfirmation.cs (1)

33var goToConfirm = await Client.GetAsync(_confirmLink.Href);

UserStories.cs (3)

198var response = await reconfirm.ResendAsync(email); 269var download = await personalData.SubmitDownloadForm(); 276var goToPrivacy = await client.GetAsync("/Privacy");

FunctionalTest.cs (1)

466public HttpResponseMessage Response { get; set; }

RetryHandler.cs (2)

26protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 28HttpResponseMessage result = null;

LocalizationSampleTest.cs (1)

37var response = await client.SendAsync(request);

LocalizationTest.cs (1)

115var response = await client.SendAsync(request);

RouteDataRequestCultureProviderTest.cs (3)

84var response = await client.GetAsync(requestUrl); 130var response = await client.GetAsync("/page"); 206var response = await client.GetAsync(requestUrl);

AcceptLanguageHeaderRequestCultureProviderTest.cs (4)

51var response = await client.GetAsync(string.Empty); 92var response = await client.GetAsync(string.Empty); 132var response = await client.GetAsync(string.Empty); 178var response = await client.GetAsync(string.Empty);

CookieRequestCultureProviderTest.cs (5)

67var response = await client.GetAsync(string.Empty); 117var response = await client.GetAsync(string.Empty); 164var response = await client.GetAsync(string.Empty); 217var response = await client.GetAsync(string.Empty); 277var response = await client.GetAsync(string.Empty);

CustomRequestCultureProviderTest.cs (1)

60var response = await client.GetAsync("/ar/page");

QueryStringRequestCultureProviderTest.cs (8)

RequestLocalizationMiddlewareTest.cs (1)

69var response = await client.GetAsync(string.Empty);

AntiforgeryAuthTests.cs (4)

35var response = await Client.PostAsync("http://localhost/Home/AutoAntiforgery", null); 46var response = await Client.GetAsync("http://localhost/Home/Antiforgery"); 58var response = await Client.PostAsync("http://localhost/Antiforgery/Index", content: null); 68var response = await Client.PostAsync("http://localhost/IgnoreAntiforgery/Index", content: null);

AntiforgeryMiddlewareTest.cs (4)

50var result = await client.SendAsync(request); 91var result = await client.SendAsync(request); 166var result = await client.SendAsync(request); 198var result = await client.SendAsync(request);

AntiforgeryTestHelper.cs (1)

22public static CookieMetadata RetrieveAntiforgeryCookie(HttpResponseMessage response)

AntiforgeryTests.cs (11)

ApiBehaviorTest.cs (16)

ApiExplorerTest.cs (57)

ApplicationModelTest.cs (12)

AsyncActionsTests.cs (26)

AsyncDisposalTest.cs (3)

45var response = await Client.GetAsync("http://localhost/Disposal/DisposeMode/Async(false)/Throws(false)"); 57var response = await Client.GetAsync("http://localhost/Disposal/DisposeMode/Async(true)/Throws(true)"); 69var response = await Client.GetAsync("http://localhost/Disposal/DisposeMode/Async(false)/Throws(true)");

AsyncEnumerableTestBase.cs (3)

42var response = await Client.GetAsync($"asyncenumerable/{action}"); 60var response = await Client.GetAsync("asyncenumerable/GetAllProjectsWithError"); 79var response = await Client.SendAsync(request);

AuthMiddlewareAndFilterTestBase.cs (16)

AuthMiddlewareUsingRequireAuthTest.cs (4)

40var response = await Client.GetAsync(action); 59var response = await Client.GetAsync(action); 73private async Task AssertAuthorizeResponse(HttpResponseMessage response) 81var response = await Client.PostAsync($"Login/{action}", null);

BasicTests.cs (26)

ComponentRenderingFunctionalTests.cs (6)

39var response = await client.GetAsync("http://localhost/components"); 55var response = await client.GetAsync("http://localhost/components/routable"); 72var response = await client.GetAsync("http://localhost/components/Navigation"); 86var response = await client.GetAsync("http://localhost/components/routable"); 102var response = await client.GetAsync("http://localhost/components/throws"); 164var response = await client.GetAsync("http://localhost/components");

ConsumesAttributeEndpointRoutingTests.cs (1)

15var response = await Client.GetAsync("http://localhost/Routing/HasEndpointMatch");

ConsumesAttributeTests.cs (1)

15var response = await Client.GetAsync("http://localhost/Routing/HasEndpointMatch");

ConsumesAttributeTestsBase.cs (8)

52var response = await Client.SendAsync(request); 69var response = await Client.SendAsync(request); 86var response = await Client.SendAsync(request); 105var response = await Client.SendAsync(request); 127var response = await Client.SendAsync(request); 151var response = await Client.SendAsync(request); 171var response = await Client.SendAsync(request); 194var response = await Client.SendAsync(request);

ContentNegotiationTest.cs (28)

ControllerEndpointFiltersTest.cs (4)

41var response = await client.GetAsync("Items/Index"); 54var response = await client.GetAsync("Items/Index"); 67var response = await client.GetAsync("Items/IndexWithSelectiveFilter"); 79var response = await client.GetAsync("Items/IndexWithArgument/foobar");

ControllerFromServicesTests.cs (4)

39var response = await Client.SendAsync(request); 79var response = await Client.PutAsync( 95var response = await Client.PostAsync( 112var response = await Client.GetAsync("http://localhost/" + action);

CorsTests.cs (1)

21var response = await Client.SendAsync(request);

CorsTestsBase.cs (15)

CustomValueProviderTest.cs (4)

46var response = await Client.SendAsync(request); 63var response = await Client.SendAsync(request); 80var response = await Client.SendAsync(request); 97var response = await Client.SendAsync(request);

DataAnnotationTests.cs (1)

43var response = await Client.GetAsync(EnumUrl);

DoNotRespectBrowserAcceptHeaderTests.cs (4)

47var response = await Client.SendAsync(request); 75var response = await Client.SendAsync(request); 104var response = await Client.SendAsync(request); 135var response = await Client.SendAsync(request);

ErrorPageTests.cs (6)

63var response = await client.GetAsync("http://localhost/" + action); 98var response = await Client.GetAsync(action); 119var response = await Client.GetAsync("http://localhost/ErrorFromViewImports"); 139var response = await Client.GetAsync("http://localhost/RuntimeError"); 157var response = await Client.GetAsync("http://localhost/LoaderException"); 176var response = await Client.GetAsync("http://localhost/AggregateException");

FileResultTests.cs (39)

FiltersTest.cs (6)

36var response = await Client.GetAsync("AuthorizeUser/AdminRole"); 47var response = await Client.GetAsync("AuthorizeUser/ApiManagers"); 58var response = await Client.GetAsync("AuthorizeUser/Impossible"); 73var response = await Client.GetAsync($"{culture}/Filters/MiddlewareFilterTest"); 93var response = await Client.SendAsync(request); 120var response = await Client.GetAsync(url);

FormFileUploadTest.cs (2)

43var response = await Client.SendAsync(request); 71var response = await Client.SendAsync(request);

GlobalAuthorizationFilterTestBase.cs (3)

38var response = await Client.GetAsync("http://localhost/Administration/Index"); 52var response = await Client.GetAsync("http://localhost/Administration/AllowAnonymousAction"); 64var response = await Client.PostAsync("http://localhost/Administration/SignInCookie2", null);

HtmlGenerationTest.cs (9)

HttpActionResultTests.cs (2)

38var response = await Client.GetAsync(url); 52var response = await Client.GetAsync(url);

Infrastructure\HttpClientExtensions.cs (4)

16var response = await client.GetAsync(requestUri); 22public static async Task<IHtmlDocument> GetHtmlDocumentAsync(this HttpResponseMessage response) 35public static async Task<HttpResponseMessage> AssertStatusCodeAsync(this HttpResponseMessage response, HttpStatusCode expectedStatusCode)

InputFormatterTests.cs (18)

InputObjectValidationTests.cs (13)

InputParentValidationTests.cs (2)

51var response = await Client.PostAsync("http://localhost/Validation/CreateInvalidModel", content); 70var response = await Client.PostAsync("http://localhost/Validation/CreateInvalidModel", content);

InputValidationTests.cs (2)

50var response = await Client.PostAsync("http://localhost/TopLevelValidation", content); 85var response = await Client.PostAsync("http://localhost/TopLevelValidation", content);

JsonInputFormatterTestBase.cs (10)

JsonOutputFormatterTestBase.cs (11)

JsonPatchInputFormatterTest.cs (7)

41var response = await Client.SendAsync(request); 61var response = await Client.SendAsync(request); 81var response = await Client.SendAsync(request); 102var response = await Client.SendAsync(request); 123var response = await Client.SendAsync(request); 143var response = await Client.SendAsync(request); 157var response = await Client.SendAsync(request);

JsonResultWithNewtonsoftJsonTest.cs (6)

46var response = await Client.SendAsync(request); 68var response = await Client.SendAsync(request); 86var response = await Client.SendAsync(request); 104var response = await Client.SendAsync(request); 121var response = await Client.SendAsync(request); 137var response = await Client.SendAsync(request);

JsonResultWithSystemTextJsonTest.cs (6)

46var response = await Client.SendAsync(request); 68var response = await Client.SendAsync(request); 86var response = await Client.SendAsync(request); 104var response = await Client.SendAsync(request); 121var response = await Client.SendAsync(request); 137var response = await Client.SendAsync(request);

KeyedServicesTests.cs (6)

37var okResponse = await Client.SendAsync(okRequest); 38var notokResponse = await Client.SendAsync(notokRequest); 54var response = await Client.SendAsync(request); 68var response = await Client.SendAsync(request); 82var response = await Client.SendAsync(request); 96var response = await Client.SendAsync(request);

LinkGenerationTests.cs (2)

61var response = await Client.GetAsync(url); 83var response = await Client.GetAsync("http://localhost/Home/ActionLinkView");

LinkGeneratorTest.cs (18)

LinkParserTest.cs (2)

41var response = await Client.GetAsync("LinkParser/Index/18"); 71var response = await Client.GetAsync("LinkParser/Another?path=%2Fsome-path%2Fa%2Fb%2Fc");

MvcSandboxTest.cs (2)

34var response = await Client.GetAsync("http://localhost"); 44var response = await Client.GetAsync("http://localhost/PagesHome");

NewtonsoftJsonInputFormatterTest.cs (3)

19var response = await Client.PostAsync("http://localhost/JsonFormatter/ReturnInput/", content); 38var response = await Client.PostAsync("http://localhost/JsonFormatter/ReturnNonNullableInput/", content); 55var response = await Client.PostAsync("http://localhost/JsonFormatter/ReturnInput/", content);

NewtonsoftJsonOutputFormatterTest.cs (2)

31var response = await Client.GetAsync("http://localhost/JsonFormatter/ReturnsIndentedJson"); 43var response = await Client.GetAsync($"/JsonOutputFormatter/{nameof(JsonOutputFormatterController.SimpleModelResult)}");

NonNullableReferenceTypesTest.cs (3)

38var response = await Client.GetAsync("http://localhost/NonNullable"); 80var response = await Client.GetAsync("http://localhost/NonNullable"); 116var response = await Client.GetAsync("http://localhost/api/NonNullable");

OutputFormatterTest.cs (5)

43var response = await Client.GetAsync("http://localhost/TextPlain/" + actionName); 60var response = await Client.GetAsync("http://localhost/TextPlain/" + actionName); 72var response = await Client.GetAsync("http://localhost/NoContent/" + actionName); 90var response = await Client.GetAsync("http://localhost/NoContent/" + actionName); 109var response = await Client.GetAsync("http://localhost/NoContentDoNotTreatNullValueAsNoContent/" +

PageAsyncDisposalTest.cs (1)

43var response = await Client.GetAsync("http://localhost/AsyncDisposable");

RazorBuildTest.cs (6)

56var response = await Client.GetAsync("http://localhost/Rzc/Page"); 69var response = await Client.GetAsync("Fallback"); 81var response = await Client.GetAsync("http://localhost/Rzc/View"); 94var response = await Client.GetAsync("http://localhost/Common/View"); 180var response = await Client.PostAsync($"/UpdateableViews/Update", updateContent); 186var response = await Client.PostAsync($"/UpdateableViews/UpdateRazorPages", new StringContent(string.Empty));

RazorPageModelTest.cs (7)

51var response = await Client.SendAsync(request); 76var response = await Client.SendAsync(request); 101var response = await Client.SendAsync(request); 127var response = await Client.SendAsync(request); 152var response = await Client.SendAsync(request); 177var response = await Client.SendAsync(request); 189var getResponse = await Client.GetAsync(request.RequestUri);

RazorPagesTest.cs (65)

RazorPagesWithBasePathTest.cs (27)

RazorPagesWithEndpointRoutingTest.cs (4)

34var response = await Client.GetAsync("/Conventions/AuthFolder"); 45var response = await Client.GetAsync("/Conventions/AuthFolder/AnonymousViaModel"); 58var response = await Client.GetAsync("/ModelWithAuthFilter"); 69var response = await Client.GetAsync("/AuthorizedAction/Index");

RazorRuntimeCompilationHostingStartupTest.cs (2)

125var response = await Client.PostAsync($"/UpdateableViews/Update", updateContent); 131var response = await Client.PostAsync($"/UpdateableViews/UpdateRazorPages", new StringContent(string.Empty));

ReadFromDisconnectedClientTest.cs (2)

45var response = await Client.SendAsync(request); 62var response = await Client.SendAsync(request);

RemoteAttributeValidationTest.cs (3)

45var response = await Client.GetAsync(url); 70var response = await Client.GetAsync(url); 99var response = await Client.PostAsync(url, content);

RequestFormLimitsTest.cs (6)

48var response = await Client.PostAsync( 69var response = await Client.PostAsync( 95var response = await Client.PostAsync( 118var response = await Client.PostAsync( 144var response = await Client.PostAsync( 165var response = await Client.PostAsync(

RequestServicesEndpointRoutingTest.cs (1)

15var response = await Client.GetAsync("http://localhost/Routing/HasEndpointMatch");

RequestServicesTest.cs (1)

15var response = await Client.GetAsync("http://localhost/Routing/HasEndpointMatch");

RequestServicesTestBase.cs (4)

57var response = await Client.SendAsync(request); 79var response = await Client.SendAsync(request); 99var response1 = await Client.SendAsync(request1); 108var response2 = await Client.SendAsync(request2);

RequestSizeLimitTest.cs (3)

46var response = await Client.PostAsync( 68var response = await Client.PostAsync( 87var response = await Client.SendAsync(request);

RespectBrowserAcceptHeaderTests.cs (2)

47var response = await Client.SendAsync(request); 66var response = await Client.SendAsync(request);

RoutingAcrossPipelineBranchesTest.cs (12)

RoutingDynamicOrderTest.cs (6)

47var response = await client.SendAsync(request); 69var response = await client.SendAsync(request); 92var response = await client.SendAsync(request); 114var response = await client.SendAsync(request); 136var response = await client.SendAsync(request); 158var response = await client.SendAsync(request);

RoutingDynamicTest.cs (9)

43var response = await Client.SendAsync(request); 58var response = await Client.SendAsync(request); 73var response = await Client.SendAsync(request); 89var response = await Client.SendAsync(request); 103var response = await Client.SendAsync(request); 119var response = await Client.SendAsync(request); 135var response = await Client.SendAsync(request); 151var response = await client.GetAsync(url); 168var response = await client.GetAsync(url);

RoutingEndpointRoutingTest.cs (27)

RoutingFallbackTest.cs (7)

44var response = await Client.SendAsync(request); 59var response = await Client.SendAsync(request); 75var response = await Client.SendAsync(request); 91var response = await Client.SendAsync(request); 107var response = await Client.SendAsync(request); 123var response = await Client.SendAsync(request); 142var response = await Client.SendAsync(request);

RoutingGroupsTest.cs (2)

42var response = await client.GetAsync("controllers/contoso/Blog/ShowPosts"); 55var response = await client.GetAsync("pages/PageWithLinks");

RoutingGroupsWithMetadataTest.cs (1)

40var response = await client.GetAsync("group1/metadata");

RoutingTests.cs (4)

17var response = await Client.GetAsync("http://localhost/Routing/HasEndpointMatch"); 36var response = await Client.SendAsync(new HttpRequestMessage(new HttpMethod("POST"), url)); 46var response = await Client.GetAsync("http://localhost/RouteData/Conventional"); 68var response = await Client.GetAsync("http://localhost/RouteData/Attribute");

RoutingTestsBase.cs (74)

RoutingWithoutRazorPagesTestsBase.cs (2)

40var response = await Client.GetAsync("http://localhost/PageRoute/Attribute/pagevalue"); 61var response = await Client.GetAsync("http://localhost/PageRoute/ConventionalRoute/pagevalue");

SerializableErrorTests.cs (4)

55var response = await Client.SendAsync(request); 79var response = await Client.SendAsync(request); 125var response = await Client.SendAsync(request); 166var response = await Client.SendAsync(request);

SimpleWithWebApplicationBuilderTests.cs (11)

StreamOutputFormatterTest.cs (1)

38var response = await Client.GetAsync("http://localhost/Stream/" + actionName);

SystemTextJsonOutputFormatterTest.cs (4)

20var response = await Client.GetAsync($"/JsonOutputFormatter/{nameof(JsonOutputFormatterController.StringWithUnicodeResult)}"); 39var response = await client.GetAsync($"/JsonOutputFormatter/{nameof(JsonOutputFormatterController.StringWithNonAsciiContent)}"); 62var response = await Client.GetAsync($"/SystemTextJsonOutputFormatter/{nameof(SystemTextJsonOutputFormatterController.PolymorphicResult)}"); 77var response = await Client.GetAsync($"/SystemTextJsonOutputFormatter/{nameof(SystemTextJsonOutputFormatterController.AsyncEnumerable)}");

TagHelperComponentTagHelperTest.cs (3)

43var response = await Client.SendAsync(request); 63var response = await Client.SendAsync(request); 83var response = await Client.SendAsync(request);

TagHelpersFromServicesTest.cs (1)

37var response = await Client.SendAsync(request);

TagHelpersTest.cs (7)

58var response = await Client.GetAsync("http://localhost/Home/" + action); 95var response = await EncodedClient.GetAsync("http://localhost/Home/UnboundDynamicAttributes"); 115var response = await Client.GetAsync("http://localhost/Employee/DuplicateAntiforgeryTokenRegistration"); 213var response = await Client.GetAsync("http://localhost/Employee/Create"); 241var response = await Client.PostAsync("http://localhost/Employee/Create", postContent); 269var response = await Client.PostAsync("http://localhost/Employee/Create", postContent); 292var response = await Client.GetAsync($"/Encoders/{ actionName }");

TempDataInCookiesTest.cs (4)

65var response = await Client.GetAsync($"/TempData/SetLargeValueInTempData?size={size}&character={character}"); 124var response = await Client.PostAsync("/TempData/SetTempData", content); 139var redirectResponse = await Client.SendAsync(GetRequest("/TempData/GetTempDataAndRedirect", response)); 177var response = await Client.PostAsync($"{protocol}://localhost/TempData/SetTempData", content);

TempDataInCookiesUsingCookieConsentTest.cs (5)

46var response = await Client.GetAsync("/TempData/GrantConsent"); 80var response = await Client.PostAsync("/TempData/SetTempData", content); 92private HttpRequestMessage GetRequest(string path, HttpResponseMessage response) 99private HttpRequestMessage GetPostRequest(string path, HttpContent content, HttpResponseMessage response) 107private void SetCookieHeaders(HttpRequestMessage request, HttpResponseMessage response)

TempDataPropertyTest.cs (7)

45var redirectResponse = await Client.PostAsync("TempDataProperty/CreateForView", content); 51var response = await Client.SendAsync(GetRequest(redirectResponse.Headers.Location.ToString(), redirectResponse)); 73var redirectResponse = await Client.PostAsync("TempDataProperty/Create", content); 79var response = await Client.SendAsync(GetRequest(redirectResponse.Headers.Location.ToString(), redirectResponse)); 102var response = await Client.PostAsync("TempDataProperty/CreateNoRedirect", content); 139var response = await Client.PostAsync("TempDataProperty/CreateNoRedirect", content); 160private HttpRequestMessage GetRequest(string path, HttpResponseMessage response)

TempDataTestBase.cs (14)

TestingInfrastructureTests.cs (11)

61var response = await Client.SendAsync(request); 84var response = await Client.SendAsync(request); 103var response = await client.SendAsync(request); 119var response = await client.SendAsync(request); 133var response = await client.SendAsync(request); 146var response = await client.SendAsync(request); 157var acquireToken = await Client.GetAsync("Testing/AntiforgerySimulator/3"); 160var response = await Client.PostAsync( 175var response = await Client.PutAsync("Testing/Put/3", content: null); 238var response = await client.SendAsync(request); 272protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

UrlResolutionTest.cs (2)

47var response = await Client.GetAsync("http://localhost/UrlResolution/Index"); 64var response = await EncodedClient.GetAsync("http://localhost/UrlResolution/Index");

VersioningEndpointRoutingTests.cs (3)

16var response = await Client.GetAsync("http://localhost/Routing/HasEndpointMatch"); 37var response = await Client.SendAsync(message); 56var response = await Client.SendAsync(message);

VersioningTests.cs (1)

15var response = await Client.GetAsync("http://localhost/Routing/HasEndpointMatch");

VersioningTestsBase.cs (24)

ViewComponentFromServicesTests.cs (1)

38var response = await Client.SendAsync(request);

ViewEngineTests.cs (5)

78var response = await Client.GetAsync("http://localhost/ViewEngine/" + actionName); 168var response = await Client.SendAsync(request); 255var response = await Client.GetAsync("http://localhost/PartialViewEngine/" + actionName); 312var response = await Client.SendAsync(request); 428var response = await Client.GetAsync("http://localhost/PartialsWithLayout/PartialsRenderedViaPartial");

XmlDataContractSerializerFormattersWrappingTest.cs (12)

XmlDataContractSerializerInputFormatterTest.cs (3)

43var response = await Client.PostAsync("http://localhost/Home/Index", content); 63var response = await Client.SendAsync(request); 94var response = await Client.SendAsync(request);

XmlOutputFormatterTests.cs (10)

XmlSerializerFormattersWrappingTest.cs (12)

XmlSerializerInputFormatterTests.cs (2)

44var response = await Client.PostAsync("http://localhost/Home/Index", content); 61var response = await Client.PostAsync("http://localhost/Home/Index", content);

Handlers\CookieContainerHandler.cs (3)

12/// more pairs of <see cref="HttpRequestMessage"/> and <see cref="HttpResponseMessage"/>. 41protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 50var response = await base.SendAsync(request, cancellationToken);

Handlers\RedirectHandler.cs (5)

45protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 51var response = await base.SendAsync(request, cancellationToken); 133HttpResponseMessage response, 167private static bool ShouldKeepVerb(HttpResponseMessage response) => 171private static bool IsRedirect(HttpResponseMessage response) =>

OutputCacheTests.cs (89)

ResponseCachingTests.cs (85)

ResponseCompressionMiddlewareTest.cs (20)

ApacheModRewrite\ModRewriteMiddlewareTest.cs (4)

350var response = await server.CreateClient().GetAsync(input); 378var response = await server.CreateClient().GetAsync(input); 433var response = await server.CreateClient().GetAsync(""); 462var response = await server.CreateClient().GetAsync("/home?report_id=123");

IISUrlRewrite\MiddleWareTests.cs (11)

MiddlewareTests.cs (22)

Benchmarks\EndpointRoutingBenchmarkTest.cs (1)

46var response = await _client.GetAsync("/plaintext");

Benchmarks\RouterBenchmarkTest.cs (1)

47var response = await _client.GetAsync("/plaintext");

EndpointRoutingIntegrationTest.cs (6)

56var response = await server.CreateRequest("/").SendAsync("GET"); 88var response = await server.CreateRequest("/not-found").SendAsync("GET"); 120var response = await server.CreateRequest("/").SendAsync("GET"); 181var response = await server.CreateRequest("/not-found").SendAsync("GET"); 275var response = await server.CreateRequest("/").SendAsync("PUT"); 311var response = await request.SendAsync(HttpMethods.Options);

EndpointRoutingSampleTest.cs (13)

HostMatchingTests.cs (5)

36var response = await client.SendAsync(request); 54var response = await client.SendAsync(request); 72var response = await client.SendAsync(request); 90var response = await client.SendAsync(request); 108var response = await client.SendAsync(request);

MapFallbackTest.cs (5)

28var response = await _client.SendAsync(request); 45var response = await _client.SendAsync(request); 62var response = await _client.SendAsync(request); 79var response = await _client.SendAsync(request); 96var response = await _client.SendAsync(request);

MinimalFormTests.cs (11)

RouteHandlerTest.cs (2)

52var response = await client.PostAsJsonAsync("/EchoTodo/42", todo); 96var response = await client.GetAsync("/");

RouterSampleTest.cs (4)

37var response = await _client.SendAsync(message); 51var response = await _client.SendAsync(message); 65var response = await _client.SendAsync(message); 87var response = await _client.SendAsync(message);

ShortCircuitTests.cs (3)

52var response = await server.CreateRequest("/shortcircuit").SendAsync("GET"); 90var response1 = await server.CreateRequest("/shortcircuit").SendAsync("GET"); 94var response2 = await server.CreateRequest("/shortcircuit/whatever").SendAsync("GET");

WebHostBuilderExtensionsTest.cs (1)

97var response = await client.SendAsync(request);

AuthenticationTests.cs (19)

DelegateTests.cs (1)

278var response = await client.PostAsync(uri, content);

Http3Tests.cs (5)

78var response1 = await client.SendAsync(request); 116var response2 = await client.GetAsync(address); 148var response = await client.GetAsync(address); 206var response = await client.GetAsync(address, HttpCompletionOption.ResponseHeadersRead); 232var response = await client.GetAsync(address, HttpCompletionOption.ResponseHeadersRead);

HttpsTests.cs (1)

291HttpResponseMessage response = await client.PostAsync(uri, new StringContent(upload));

Listener\AuthenticationOnExistingQueueTests.cs (13)

60Task<HttpResponseMessage> responseTask = SendRequestAsync(address); 68var response = await responseTask; 83Task<HttpResponseMessage> responseTask = SendRequestAsync(address); 86var response = await responseTask; 101Task<HttpResponseMessage> responseTask = SendRequestAsync(address); 110var response = await responseTask; 126Task<HttpResponseMessage> responseTask = SendRequestAsync(address); 135var response = await responseTask; 151Task<HttpResponseMessage> responseTask = SendRequestAsync(address, useDefaultCredentials: true); 166var response = await responseTask; 181Task<HttpResponseMessage> responseTask = SendRequestAsync(address, useDefaultCredentials: true); 189var response = await responseTask; 219private async Task<HttpResponseMessage> SendRequestAsync(string uri, bool useDefaultCredentials = false)

Listener\RequestBodyTests.cs (1)

205HttpResponseMessage response = await client.PostAsync(uri, content);

Listener\ResponseBodyTests.cs (12)

Listener\ResponseHeaderTests.cs (22)

Listener\ServerOnExistingQueueTests.cs (1)

327HttpResponseMessage response = await client.PostAsync(uri, new StringContent(upload));

Listener\ServerTests.cs (1)

66var response = await responseTask;

OpaqueUpgradeTests.cs (5)

39HttpResponseMessage response = await SendRequestAsync(address); 67HttpResponseMessage response = await SendRequestAsync(address); 98HttpResponseMessage response = await SendRequestAsync(address); 300var response = await client.SendAsync(request); 369private async Task<HttpResponseMessage> SendRequestAsync(string uri)

RequestBodyLimitTests.cs (1)

415HttpResponseMessage response = await client.PostAsync(uri, content);

RequestBodyTests.cs (1)

303HttpResponseMessage response = await client.PostAsync(uri, content);

RequestHeaderTests.cs (1)

240var result = await client.GetAsync(uri);

ResponseBodyTests.cs (15)

ResponseCachingTests.cs (2)

473var response = await client.GetAsync(uri); 488var response = await client.GetAsync(uri);

ResponseHeaderTests.cs (9)

29HttpResponseMessage response = await SendRequestAsync(address); 130var response = await httpClient.GetAsync(address); 149HttpResponseMessage response = await SendRequestAsync(address); 174HttpResponseMessage response = await client.SendAsync(request); 201HttpResponseMessage response = await client.SendAsync(request); 233HttpResponseMessage response = await SendRequestAsync(address); 263HttpResponseMessage response = await SendRequestAsync(address); 286HttpResponseMessage response = await SendRequestAsync(address); 327private async Task<HttpResponseMessage> SendRequestAsync(string uri)

ResponseSendFileTests.cs (19)

ResponseTests.cs (10)

ResponseTrailersTests.cs (15)

ServerTests.cs (2)

372HttpResponseMessage response = await client4.GetAsync(address); 649HttpResponseMessage response = await client.PostAsync(uri, new StringContent(upload));

IISMiddlewareTests.cs (7)

56var response = await server.CreateClient().SendAsync(req); 93var response = await server.CreateClient().SendAsync(req); 137var response = await server.CreateClient().SendAsync(request); 196var response = await server.CreateClient().SendAsync(request); 241var response = await server.CreateClient().SendAsync(request); 286var response = await server.CreateClient().SendAsync(request); 385var response = await server.CreateClient().SendAsync(request);

Common\LoggingHandler.cs (2)

18protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 23var response = await base.SendAsync(request, cancellationToken);

Common\RetryHelper.cs (3)

19public static async Task<HttpResponseMessage> RetryRequest( 20Func<Task<HttpResponseMessage>> retryBlock, 36var response = await retryBlock().ConfigureAwait(false);

Deployers\NginxDeployer.cs (1)

81var response = await RetryHelper.RetryRequest(() =>

LoggingHandler.cs (3)

21protected override async Task<HttpResponseMessage> SendAsync( 26var response = await base.SendAsync(request, cancellationToken); 32private async Task LogResponse(LogLevel logLevel, HttpResponseMessage response)

RetryHandler.cs (2)

23protected override async Task<HttpResponseMessage> SendAsync( 27HttpResponseMessage response = null;

WebHostTests.cs (7)

84var response = await client.SendAsync(request); 248var response1 = await client.SendAsync(request1).DefaultTimeout(); 262var response2 = await client.SendAsync(request2).DefaultTimeout(); 319var response1 = await client.SendAsync(request1).DefaultTimeout(); 332var response2 = await client.SendAsync(request2).DefaultTimeout(); 357var response1 = await client.SendAsync(request1).DefaultTimeout(); 369var response2 = await client.SendAsync(request2).DefaultTimeout();

SessionTests.cs (21)

HubConnectionTests.cs (4)

1478var httpResponse = await new HttpClient().GetAsync(server.Url + "/generateJwtToken"); 2695var httpResponse = await new HttpClient().GetAsync(server.Url + $"/generateJwtToken/{userName}"); 2972public Task<HttpResponseMessage> ActivePoll { get; private set; } 2978protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

HttpConnectionFactoryTests.cs (1)

29testHandler.OnRequest((req, next, ct) => Task.FromException<HttpResponseMessage>(new Exception("BOOM")));

HttpConnectionTests.ConnectionLifecycle.cs (1)

293var longPollResult = new TaskCompletionSource<HttpResponseMessage>();

HttpConnectionTests.Negotiate.cs (3)

281var tcs = new TaskCompletionSource<HttpResponseMessage>(TaskCreationOptions.RunContinuationsAsynchronously); 385var tcs = new TaskCompletionSource<HttpResponseMessage>(TaskCreationOptions.RunContinuationsAsynchronously); 450var tcs = new TaskCompletionSource<HttpResponseMessage>(TaskCreationOptions.RunContinuationsAsynchronously);

HttpConnectionTests.Transport.cs (3)

207var resp = ResponseUtils.CreateResponse(HttpStatusCode.OK, messageFragments[requestCount]); 230var longPollTcs = new TaskCompletionSource<HttpResponseMessage>(); 375var resp = ResponseUtils.CreateResponse(HttpStatusCode.OK, messageFragments[pollCount / 2]);

LongPollingTransportTests.cs (19)

ResponseUtils.cs (4)

17public static HttpResponseMessage CreateResponse(HttpStatusCode statusCode) => 20public static HttpResponseMessage CreateResponse(HttpStatusCode statusCode, string payload) => 23public static HttpResponseMessage CreateResponse(HttpStatusCode statusCode, byte[] payload) => 26public static HttpResponseMessage CreateResponse(HttpStatusCode statusCode, HttpContent payload)

SendUtilsTests.cs (2)

20var responseTaskCompletionSource = new TaskCompletionSource<HttpResponseMessage>(TaskCreationOptions.RunContinuationsAsynchronously); 46var response = await responseTaskCompletionSource.Task.DefaultTimeout();

ServerSentEventsTransportTests.cs (12)

TestHttpMessageHandler.cs (24)

EndToEndTests.cs (6)

174.Setup<Task<HttpResponseMessage>>("SendAsync", ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>()) 176(request, cancellationToken) => Task.FromException<HttpResponseMessage>(new InvalidOperationException("HTTP requests should not be sent."))); 224.Setup<Task<HttpResponseMessage>>("SendAsync", ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>()) 226(request, cancellationToken) => Task.FromException<HttpResponseMessage>(new InvalidOperationException("HTTP requests should not be sent."))); 481var response = await client.GetAsync("generatetoken?user=bob"); 655var response = await client.GetAsync("generatetoken?user=bob");

SpaProxyLaunchManager.cs (2)

81var response = await httpClient.GetAsync(_options.ServerUrl, cancellationTokenSource.Token); 112var response = await httpClient.GetAsync(_options.ServerUrl, cancellationTokenSource.Token);

Proxying\SpaProxy.cs (2)

86using (var responseMessage = await httpClient.SendAsync( 165private static async Task CopyProxyHttpResponse(HttpContext context, HttpResponseMessage responseMessage, CancellationToken cancellationToken)

SpaProxyTests.cs (1)

23.Setup<Task<HttpResponseMessage>>("SendAsync",

StaticAssetsIntegrationTests.cs (46)

FallbackStaticFileTest.cs (2)

59var response = await client.GetAsync("hello"); 108var response = await client.GetAsync("hello");

StaticFileMiddlewareTests.cs (5)

38var response = await client.GetAsync("TestDocument.txt"); 83var response = await client.GetAsync("TestDocument.txt"); 109var response = await client.GetAsync("TestDocument.txt"); 159var response = await client.GetAsync(requestUrl); 202var response = await client.SendAsync(request);

CacheHeaderTests.cs (36)

DefaultFilesMiddlewareTests.cs (7)

26var response = await server.CreateClient().GetAsync("/"); 74var response = await server.CreateClient().GetAsync(requestUrl); 117var response = await server.CreateRequest("/SubFolder/").GetAsync(); 157var response = await server.CreateRequest("/SubFolder/").GetAsync(); 222var response = await server.CreateClient().GetAsync(requestUrl); 263var response = await server.CreateRequest(requestUrl + queryString).GetAsync(); 319var response = await server.CreateRequest(requestUrl).GetAsync();

DirectoryBrowserMiddlewareTests.cs (8)

RangeHeaderTests.cs (32)

StaticFileMiddlewareTests.cs (15)

ClientHandler.cs (4)

58protected override HttpResponseMessage Send( 73/// <returns>A <see cref="Task{TResult}"/> returning the <see cref="HttpResponseMessage"/>.</returns> 74protected override async Task<HttpResponseMessage> SendAsync( 192var response = new HttpResponseMessage();

RequestBuilder.cs (6)

71/// <returns>The resulting <see cref="HttpResponseMessage"/>.</returns> 72public Task<HttpResponseMessage> SendAsync(string method) 81/// <returns>The resulting <see cref="HttpResponseMessage"/>.</returns> 82public Task<HttpResponseMessage> GetAsync() 91/// <returns>The resulting <see cref="HttpResponseMessage"/>.</returns> 92public Task<HttpResponseMessage> PostAsync()

ClientHandlerTests.cs (11)

RequestLifetimeTests.cs (2)

63var response = await client.GetAsync("/", HttpCompletionOption.ResponseHeadersRead); 86using var response = await client.GetAsync("/", HttpCompletionOption.ResponseHeadersRead);

ResponseBodyTests.cs (5)

27var response = await host.GetTestServer().CreateClient().GetAsync("/"); 44var response = await host.GetTestServer().CreateClient().GetAsync("/"); 79var response = await client.GetAsync("/"); 118var response = await client.GetAsync("/"); 137var response = await client.GetAsync("/", HttpCompletionOption.ResponseHeadersRead);

ResponseResetTests.cs (5)

30var response = await client.GetAsync("/"); 46var response = await client.GetAsync("/"); 62var response = await client.GetAsync("/"); 122var response = await client.GetAsync("/", HttpCompletionOption.ResponseHeadersRead); 148var response = await client.GetAsync("/", HttpCompletionOption.ResponseHeadersRead);

TestClientTests.cs (15)

TestServerTests.cs (9)

39var response = await host.GetTestServer().CreateClient().GetAsync("/"); 55var response = await host.GetTestServer().CreateClient().GetAsync("/"); 71var response = await host.GetTestClient().GetAsync("/"); 225var response = await server.CreateClient().PostAsync("/", new StreamContent(stream)); 654HttpResponseMessage result = await server.CreateClient().GetAsync("/"); 672HttpResponseMessage result = await server.CreateClient().GetAsync("/"); 702HttpResponseMessage result = await server.CreateClient().GetAsync("/"); 715HttpResponseMessage result = await server.CreateClient().GetAsync("/"); 793var response = await client.SendAsync(request);

FakesExtensionsTests.cs (1)

89using var response = await client.SendAsync(new HttpRequestMessage());

TestResources\ReturningHttpClientHandler.cs (2)

14protected override HttpResponseMessage Send(HttpRequestMessage request, CancellationToken cancellationToken) 20protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

TestResources\TestHandler.cs (1)

13protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,

WebApplicationTests.cs (8)

WebHostTests.cs (1)

82var result = await client.GetAsync("http://localhost/");

Autobahn\AutobahnTester.cs (2)

88var resp = await deployment.HttpClient.GetAsync("/ping", token); 161var resp = await RetryHelper.RetryRequest(() =>

WebSocketCompressionMiddlewareTests.cs (3)

39var response = await client.SendAsync(request); 67var response = await client.SendAsync(request); 101var response = await client.SendAsync(request);

WebSocketMiddlewareTests.cs (4)

686var response = await client.SendAsync(request); 712var response = await client.SendAsync(request); 769var response = await client.SendAsync(request); 840var response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);

DownloadFile.cs (4)

153using (HttpResponseMessage response = await client.GetAsync(uri, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false)) 311/// <param name="response">The <see cref="HttpResponseMessage"/> with information about the response.</param> 314private bool TryGetFileName(HttpResponseMessage response, out string filename) 349private bool ShouldSkip(HttpResponseMessage response, FileInfo destinationFile)

DownloadFile_Tests.cs (4)

92using HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK) 391private readonly Func<HttpRequestMessage, CancellationToken, HttpResponseMessage> _func; 393public MockHttpMessageHandler(Func<HttpRequestMessage, CancellationToken, HttpResponseMessage> func) 398protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

src\DownloadFile.cs (1)

154var httpResponse = await httpClient.GetAsync(uri, _cancellationSource.Token).ConfigureAwait(false);

src\common\AzureStorageUtils.cs (1)

255using (HttpResponseMessage response = await client.GetAsync(packageContentUrl))

src\common\GeneralUtils.cs (1)

151HttpResponseMessage response = await httpClient.GetAsync(feedUrl);

src\CreateAzureDevOpsFeed.cs (1)

150using HttpResponseMessage createFeedResponse = await client.SendAsync(createFeedMessage);

GeneralTests.cs (1)

118var response = new HttpResponseMessage(feedResponseStatusCode);

PublishToSymbolServerTest.cs (2)

239var response = new HttpResponseMessage(HttpStatusCode.OK) 398var responses = new HttpResponseMessage(HttpStatusCode.OK)

src\AkaMSLinksManager.cs (3)

104var response = await client.DeleteAsync($"{ApiTargeturl}/harddelete/{link}"); 205var response = await client.GetAsync($"{ApiTargeturl}/{link.ShortUrl}"); 283using (HttpResponseMessage response = await client.SendAsync(requestMessage))

Clients\AzureDevOpsClient.cs (1)

35HttpResponseMessage response = await httpClient.SendAsync(getMessage);

AzureDevOpsTask.cs (2)

121protected async Task HandleFailedRequest(HttpRequestMessage req, HttpResponseMessage res) 146protected async Task<JObject> ParseResponseAsync(HttpRequestMessage req, HttpResponseMessage res)

CheckAzurePipelinesTestResults.cs (4)

61using HttpResponseMessage res = await client.SendAsync(req); 115using HttpResponseMessage res = await client.SendAsync(req); 169using (HttpResponseMessage res = await client.SendAsync(req)) 213using (HttpResponseMessage res = await client.SendAsync(req))

CreateFailedTestsForFailedWorkItems.cs (1)

68using (HttpResponseMessage res = await client.SendAsync(req))

FindDotNetCliPackage.cs (8)

ProvisioningProfileProvider.cs (1)

194HttpResponseMessage? response = null;

StartAzurePipelinesTestRun.cs (1)

53using (var res = await client.SendAsync(req))

StopAzurePipelinesTestRun.cs (1)

39using (var res = await client.SendAsync(req))

SymbolPromotionHelper.cs (3)

155using HttpResponseMessage regResponse = await s_client.SendAsync(registerRequest, ct); 208using HttpResponseMessage statusResponse = await s_client.SendAsync(statusRequest, ct); 271using HttpResponseMessage statusResponse = await s_client.SendAsync(statusRequest, ct);

SymbolUploadHelperFactory.cs (1)

155using HttpResponseMessage response = await s_symbolDownloadClient.SendAsync(getToolRequest, token).ConfigureAwait(false);

Automation\GitHubApi\GitHubClient.cs (17)

Automation\VstsApi\VstsAdapterClient.cs (10)

BuildInfo.cs (4)

55using (HttpResponseMessage response = await GetBuildInfoFileAsync( 68using (HttpResponseMessage response = await GetBuildInfoFileAsync( 192private static async Task<HttpResponseMessage> GetBuildInfoFileAsync( 197HttpResponseMessage response = await client.GetAsync(url);

HttpMessageHandlerBuilder.cs (1)

73/// of sending an <see cref="HttpRequestMessage"/> and receiving an <see cref="HttpResponseMessage"/>.

Logging\HttpClientLoggerHandler.cs (4)

25protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 30HttpResponseMessage? response = null; 65protected override HttpResponseMessage Send(HttpRequestMessage request, CancellationToken cancellationToken) 70HttpResponseMessage? response = null;

Logging\IHttpClientAsyncLogger.cs (3)

24/// <see cref="HttpResponseMessage"/> properties, such as reading from a content stream; if possible, such behavior should be avoided. 51ValueTask LogRequestStopAsync(object? context, HttpRequestMessage request, HttpResponseMessage response, TimeSpan elapsed, CancellationToken cancellationToken = default); 63ValueTask LogRequestFailedAsync(object? context, HttpRequestMessage request, HttpResponseMessage? response, Exception exception, TimeSpan elapsed, CancellationToken cancellationToken = default);

Logging\IHttpClientLogger.cs (3)

16/// <see cref="HttpResponseMessage"/> properties, such as reading from a content stream; if possible, such behavior should be avoided. 39void LogRequestStop(object? context, HttpRequestMessage request, HttpResponseMessage response, TimeSpan elapsed); 49void LogRequestFailed(object? context, HttpRequestMessage request, HttpResponseMessage? response, Exception exception, TimeSpan elapsed);

Logging\LoggingHttpMessageHandler.cs (5)

49private Task<HttpResponseMessage> SendCoreAsync(HttpRequestMessage request, bool useAsync, CancellationToken cancellationToken) 54async Task<HttpResponseMessage> Core(HttpRequestMessage request, bool useAsync, CancellationToken cancellationToken) 65HttpResponseMessage response = useAsync 86protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 92protected override HttpResponseMessage Send(HttpRequestMessage request, CancellationToken cancellationToken)

Logging\LoggingScopeHttpMessageHandler.cs (5)

48private Task<HttpResponseMessage> SendCoreAsync(HttpRequestMessage request, bool useAsync, CancellationToken cancellationToken) 53async Task<HttpResponseMessage> Core(HttpRequestMessage request, bool useAsync, CancellationToken cancellationToken) 65HttpResponseMessage response = useAsync 87protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 93protected override HttpResponseMessage Send(HttpRequestMessage request, CancellationToken cancellationToken)

Logging\LogHelper.cs (2)

114public static void LogRequestEnd(this ILogger logger, HttpResponseMessage response, TimeSpan duration, Func<string, bool> shouldRedactHeaderValue) 153public static void LogRequestPipelineEnd(this ILogger logger, HttpResponseMessage response, TimeSpan duration, Func<string, bool> shouldRedactHeaderValue)

Latency\Internal\HttpClientLatencyLogEnricher.cs (1)

35public void Enrich(IEnrichmentTagCollector collector, HttpRequestMessage request, HttpResponseMessage? response, Exception? exception)

Latency\Internal\HttpLatencyTelemetryHandler.cs (2)

43protected async override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 51var response = await base.SendAsync(request, cancellationToken).ConfigureAwait(false);

Logging\IHttpClientLogEnricher.cs (2)

20/// <param name="response"><see cref="HttpResponseMessage"/> object associated with the outgoing HTTP request.</param> 26void Enrich(IEnrichmentTagCollector collector, HttpRequestMessage request, HttpResponseMessage? response, Exception? exception);

Logging\Internal\HttpClientLogger.cs (6)

115HttpResponseMessage response, 123HttpResponseMessage? response, 132public void LogRequestStop(object? context, HttpRequestMessage request, HttpResponseMessage response, TimeSpan elapsed) 135public void LogRequestFailed(object? context, HttpRequestMessage request, HttpResponseMessage? response, Exception exception, TimeSpan elapsed) 156HttpResponseMessage? response, 224HttpRequestMessage request, HttpResponseMessage? response, Exception? exception)

Logging\Internal\HttpHeadersReader.cs (1)

55public void ReadResponseHeaders(HttpResponseMessage response, List<KeyValuePair<string, string>>? destination)

Logging\Internal\HttpRequestReader.cs (1)

116public async Task ReadResponseAsync(LogRecord logRecord, HttpResponseMessage response,

Logging\Internal\HttpResponseBodyReader.cs (3)

44public ValueTask<string> ReadAsync(HttpResponseMessage response, CancellationToken cancellationToken) 61private static async ValueTask<string> ReadFromStreamAsync(HttpResponseMessage response, int readSizeLimit, 125private static async ValueTask<string> ReadFromStreamWithTimeoutAsync(HttpResponseMessage response, TimeSpan readTimeout,

Logging\Internal\IHttpHeadersReader.cs (2)

24/// <param name="response">An instance of <see cref="HttpResponseMessage"/> to read headers from.</param> 26void ReadResponseHeaders(HttpResponseMessage response, List<KeyValuePair<string, string>>? destination);

Logging\Internal\IHttpRequestReader.cs (3)

12/// Methods to read <see cref="HttpResponseMessage"/> or <see cref="HttpRequestMessage"/>. 17/// Reads <see cref="HttpResponseMessage"/>. 24Task ReadResponseAsync(LogRecord record, HttpResponseMessage response,

Logging\Internal\Log.cs (1)

12/// Logs <see cref="HttpRequestMessage"/>, <see cref="HttpResponseMessage"/> and the exceptions due to errors of request/response.

BenchEnricher.cs (1)

15public void Enrich(IEnrichmentTagCollector collector, HttpRequestMessage request, HttpResponseMessage? response, Exception? exception)

Benchmarks\HugeHttpCLientLoggingBenchmark.cs (32)

Benchmarks\MediumHttpClientLoggingBenchmark.cs (32)

Benchmarks\SmallHttpClientLoggingBenchmark.cs (32)

NoRemoteCallHandler.cs (2)

35protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 37var response = new HttpResponseMessage

NoRemoteCallNotSeekableHandler.cs (2)

38protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 40var response = new HttpResponseMessage

Latency\Internal\HttpClientLatencyLogEnricherTest.cs (2)

45using HttpResponseMessage httpResponseMessage = new(); 65using HttpResponseMessage httpResponseMessage = new();

Latency\Internal\HttpLatencyTelemetryHandlerTest.cs (2)

63var resp = new Mock<HttpResponseMessage>(); 65mockHandler.Protected().Setup<Task<HttpResponseMessage>>(

Logging\AcceptanceTests.cs (7)

40using var _ = await httpClient.GetAsync(_unreachableRequestUri); 71using var _ = await httpClient.GetAsync(_unreachableRequestUri); 197using var content = await httpClient 251var content = await firstClient!.SendRequest(httpRequestMessage); 363using var _ = await httpClient.SendAsync(httpRequestMessage); 432using var _ = await httpClient.SendAsync(httpRequestMessage); 688var content = await client.SendAsync(httpRequestMessage, HttpCompletionOption.ResponseHeadersRead);

Logging\HttpClientLoggerTest.cs (21)

Logging\HttpHeadersReaderTest.cs (4)

24using var httpResponse = new HttpResponseMessage(); 42using var httpResponse = new HttpResponseMessage(); 145using var httpResponse = new HttpResponseMessage { Content = responseContent }; 178using var httpResponse = new HttpResponseMessage();

Logging\HttpRequestReaderTest.cs (7)

90using var httpResponseMessage = new HttpResponseMessage 150using var httpResponseMessage = new HttpResponseMessage 219using var httpResponseMessage = new HttpResponseMessage 294using var httpResponseMessage = new HttpResponseMessage 424using var httpResponseMessage = new HttpResponseMessage 491using var httpResponseMessage = new HttpResponseMessage 559using var httpResponseMessage = new HttpResponseMessage

Logging\HttpResponseBodyReaderTest.cs (6)

40using var httpResponse = new HttpResponseMessage 58using var httpResponse = new HttpResponseMessage 83using var httpResponse = new HttpResponseMessage 103using var httpResponse = new HttpResponseMessage 127using var httpResponse = new HttpResponseMessage 152using var httpResponse = new HttpResponseMessage

Logging\Internal\EmptyEnricher.cs (1)

12public void Enrich(IEnrichmentTagCollector collector, HttpRequestMessage request, HttpResponseMessage? response, Exception? exception)

Logging\Internal\EnricherWithCounter.cs (1)

14public void Enrich(IEnrichmentTagCollector collector, HttpRequestMessage request, HttpResponseMessage? response, Exception? exception)

Logging\Internal\ITestHttpClient1.cs (1)

11Task<HttpResponseMessage> SendRequest(HttpRequestMessage httpRequestMessage);

Logging\Internal\ITestHttpClient2.cs (1)

11Task<HttpResponseMessage> SendRequest(HttpRequestMessage httpRequestMessage);

Logging\Internal\MockedRequestReader.cs (1)

23HttpResponseMessage response,

Logging\Internal\NoRemoteCallHandler.cs (2)

29protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 31var response = new HttpResponseMessage

Logging\Internal\TestEnricher.cs (1)

29public void Enrich(IEnrichmentTagCollector tagCollector, HttpRequestMessage request, HttpResponseMessage? response, Exception? exception)

Logging\Internal\TestHttpClient1.cs (1)

18public Task<HttpResponseMessage> SendRequest(HttpRequestMessage httpRequestMessage)

Logging\Internal\TestHttpClient2.cs (1)

18public Task<HttpResponseMessage> SendRequest(HttpRequestMessage httpRequestMessage)

Logging\Internal\TestingHandlerStub.cs (3)

13private readonly Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> _handlerFunc; 15public TestingHandlerStub(Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> handlerFunc) 20protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) => _handlerFunc(request, cancellationToken);

DependencyInjection\PollyHttpClientBuilderExtensions.cs (10)

HttpRequestMessageExtensions.cs (2)

25/// The <see cref="PolicyHttpMessageHandler"/> will attach a context to the <see cref="HttpResponseMessage"/> prior 46/// The <see cref="PolicyHttpMessageHandler"/> will attach a context to the <see cref="HttpResponseMessage"/> prior

PolicyHttpMessageHandler.cs (12)

DependencyInjection\PollyHttpClientBuilderExtensionsTest.cs (23)

PolicyHttpMessageHandlerTest.cs (33)

Hedging\HttpClientHedgingResiliencePredicates.cs (3)

25public static bool IsTransient(Outcome<HttpResponseMessage> outcome) 34/// Determines whether an <see cref="HttpResponseMessage"/> should be treated by hedging as a transient failure. 40public static bool IsTransient(Outcome<HttpResponseMessage> outcome, CancellationToken cancellationToken)

Hedging\HttpHedgingStrategyOptions.cs (2)

13/// Implementation of the <see cref="HedgingStrategyOptions{TResult}"/> class for <see cref="HttpResponseMessage"/> results. 15public class HttpHedgingStrategyOptions : HedgingStrategyOptions<HttpResponseMessage>

Internal\RetryAfterHelper.cs (1)

16internal static bool TryParse(HttpResponseMessage response, TimeProvider timeProvider, out TimeSpan retryAfter)

Polly\HttpCircuitBreakerStrategyOptions.cs (2)

11/// Implementation of the <see cref="CircuitBreakerStrategyOptions{TResult}"/> for <see cref="HttpResponseMessage"/> results. 13public class HttpCircuitBreakerStrategyOptions : CircuitBreakerStrategyOptions<HttpResponseMessage>

Polly\HttpClientResiliencePredicates.cs (5)

25public static bool IsTransient(Outcome<HttpResponseMessage> outcome) => outcome switch 33/// Determines whether an <see cref="HttpResponseMessage"/> should be treated by resilience strategies as a transient failure. 39public static bool IsTransient(Outcome<HttpResponseMessage> outcome, CancellationToken cancellationToken) 53internal static bool IsHttpConnectionTimeout(in Outcome<HttpResponseMessage> outcome, in CancellationToken cancellationToken) 63internal static bool IsTransientHttpFailure(HttpResponseMessage response)

Polly\HttpRetryStrategyOptions.cs (3)

15/// Implementation of the <see cref="RetryStrategyOptions{TResult}"/> for <see cref="HttpResponseMessage"/> results. 17public class HttpRetryStrategyOptions : RetryStrategyOptions<HttpResponseMessage> 59HttpResponseMessage response when RetryAfterHelper.TryParse(response, TimeProvider.System, out var retryAfter) => new ValueTask<TimeSpan?>(retryAfter),

Resilience\Internal\HttpResilienceMetricsEnricher.cs (2)

14if (typeof(TResult) != typeof(HttpResponseMessage)) 19if (context.TelemetryEvent.Outcome.HasValue && context.TelemetryEvent.Outcome.Value.Result is HttpResponseMessage response)

Resilience\ResilienceHandler.cs (12)

Resilience\ResilienceHttpClientBuilderExtensions.Resilience.cs (7)

36Action<ResiliencePipelineBuilder<HttpResponseMessage>> configure) 59Action<ResiliencePipelineBuilder<HttpResponseMessage>, ResilienceHandlerContext> configure) 78private static Func<HttpRequestMessage, ResiliencePipeline<HttpResponseMessage>> CreatePipelineSelector(IServiceProvider serviceProvider, string pipelineName) 85var pipeline = resilienceProvider.GetPipeline<HttpResponseMessage>(new HttpKey(pipelineName, string.Empty)); 95return resilienceProvider.GetPipeline<HttpResponseMessage>(new HttpKey(pipelineName, key)); 113Action<ResiliencePipelineBuilder<HttpResponseMessage>, ResilienceHandlerContext> configure) 118_ = builder.Services.AddResiliencePipeline<HttpKey, HttpResponseMessage>(key, (builder, context) => configure(builder, new ResilienceHandlerContext(context)));

EmptyHandler.cs (1)

12protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

HedgingBenchmark.cs (1)

37public Task<HttpResponseMessage> HedgingCall() => _client.SendAsync(Request, CancellationToken.None);

HttpResilienceBenchmark.cs (5)

46public Task<HttpResponseMessage> DefaultClient() 52public Task<HttpResponseMessage> SingleHandler() 58public Task<HttpResponseMessage> StandardResilienceHandler() 64public Task<HttpResponseMessage> StandardHedgingHandler_RoutesFromRequest() 70public Task<HttpResponseMessage> StandardHedgingHandler_RoutesFromConfig()

NoRemoteCallHandler.cs (4)

12private readonly HttpResponseMessage _response; 13private readonly Task<HttpResponseMessage> _completedResponse; 26protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 33protected override HttpResponseMessage Send(HttpRequestMessage request, CancellationToken cancellationToken)

RetryBenchmark.cs (4)

48var builder = Policy.Handle<HttpRequestException>().Or<TimeoutRejectedException>().OrResult<HttpResponseMessage>(r => 69public Task<HttpResponseMessage> Retry_Polly_V7() 75public Task<HttpResponseMessage> Retry_Polly_V8() 81public HttpResponseMessage Retry_Polly_V8_Sync()

StandardResilienceBenchmark.cs (7)

43var builder = Policy.Handle<HttpRequestException>().Or<TimeoutRejectedException>().OrResult<HttpResponseMessage>(r => 53Policy.TimeoutAsync<HttpResponseMessage>(3), 56Policy.BulkheadAsync<HttpResponseMessage>(1000, 100), 57Policy.TimeoutAsync<HttpResponseMessage>(30)); 71public Task<HttpResponseMessage> StandardPipeline_Polly_V7() 77public Task<HttpResponseMessage> StandardPipeline_Polly_V8() 83public HttpResponseMessage StandardPipeline_Polly_V8_Sync()

Hedging\HedgingTests.cs (11)

37private readonly Queue<HttpResponseMessage> _responses = new(); 68foreach (var response in _responses) 107using var _ = await SendRequest(client, request, asynchronous, _cancellationTokenSource.Token); 127using var _ = await SendRequest(client, request, asynchronous, _cancellationTokenSource.Token); 200using var result = await SendRequest(client, request, asynchronous, _cancellationTokenSource.Token); 224using var _ = await SendRequest(client, request, asynchronous, _cancellationTokenSource.Token); 250using var _ = await SendRequest(client, request, asynchronous, _cancellationTokenSource.Token); 277using var _ = await SendRequest(client, request, asynchronous, _cancellationTokenSource.Token); 300using var result = await SendRequest(client, request, asynchronous, _cancellationTokenSource.Token); 308protected static Task<HttpResponseMessage> SendRequest( 348private Task<HttpResponseMessage> InnerHandlerFunction(HttpRequestMessage request, CancellationToken cancellationToken)

Hedging\HttpClientHedgingResiliencePredicatesTests.cs (6)

29Assert.True(HttpClientHedgingResiliencePredicates.IsTransient(Outcome.FromException<HttpResponseMessage>(new TimeoutRejectedException()))); 30Assert.True(HttpClientHedgingResiliencePredicates.IsTransient(Outcome.FromException<HttpResponseMessage>(new BrokenCircuitException()))); 31Assert.True(HttpClientHedgingResiliencePredicates.IsTransient(Outcome.FromException<HttpResponseMessage>(new HttpRequestException()))); 32Assert.False(HttpClientHedgingResiliencePredicates.IsTransient(Outcome.FromException<HttpResponseMessage>(new InvalidOperationException()))); 33Assert.False(HttpClientHedgingResiliencePredicates.IsTransient(Outcome.FromResult<HttpResponseMessage>(null))); 42using var response = new HttpResponseMessage(code);

Hedging\StandardHedgingTests.cs (14)

Helpers\TestHandlerStub.cs (4)

14private readonly Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> _handlerFunc; 21public TestHandlerStub(Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> handlerFunc) 26protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 32protected override HttpResponseMessage Send(HttpRequestMessage request, CancellationToken cancellationToken)

Internal\RequestMessageSnapshotStrategyTests.cs (1)

29return new ValueTask<HttpResponseMessage>(new HttpResponseMessage());

Internal\RetryAfterHelperTests.cs (4)

19using var response = new HttpResponseMessage(); 31using var response = new HttpResponseMessage(); 44using var response = new HttpResponseMessage(); 58using var response = new HttpResponseMessage();

Polly\HttpCircuitBreakerStrategyOptionsTests.cs (5)

59using var response = new HttpResponseMessage { StatusCode = statusCode }; 72private CircuitBreakerPredicateArguments<HttpResponseMessage> CreateArgs(Exception error) 73=> new(_context, Outcome.FromException<HttpResponseMessage>(error)); 75private CircuitBreakerPredicateArguments<HttpResponseMessage> CreateArgs(HttpResponseMessage response)

Polly\HttpClientResiliencePredicatesTests.cs (2)

39isTransientHttpException = HttpClientResiliencePredicates.IsTransient(Outcome.FromException<HttpResponseMessage>(ex)); 55var response = new HttpResponseMessage { StatusCode = statusCode };

Polly\HttpRetryStrategyOptionsTests.cs (10)

58var response = new HttpResponseMessage { StatusCode = statusCode }; 69var args = CreateArgs(Outcome.FromException<HttpResponseMessage>(exception), token ?? default); 83var response = new HttpResponseMessage { StatusCode = statusCode }; 93var args = CreateArgs(Outcome.FromException<HttpResponseMessage>(exception), token ?? default); 102using var responseMessage = new HttpResponseMessage(); 115Outcome.FromResult<HttpResponseMessage>(null), 121Outcome.FromException<HttpResponseMessage>(new InvalidOperationException()), 130using var responseMessage = new HttpResponseMessage 159private static RetryPredicateArguments<HttpResponseMessage> CreateArgs( 160Outcome<HttpResponseMessage> outcome,

Resilience\HttpClientBuilderExtensionsTests.BySelector.cs (2)

132.Setup(p => p.GetPipeline<HttpResponseMessage>(new HttpKey(pipelineName, expectedPipelineKey))) 133.Returns(ResiliencePipeline<HttpResponseMessage>.Empty);

Resilience\HttpClientBuilderExtensionsTests.Resilience.cs (10)

35Assert.Throws<ArgumentNullException>(() => builder.AddResilienceHandler("dummy", (Action<ResiliencePipelineBuilder<HttpResponseMessage>>)null!)); 36Assert.Throws<ArgumentNullException>(() => builder.AddResilienceHandler("dummy", (Action<ResiliencePipelineBuilder<HttpResponseMessage>, ResilienceHandlerContext>)null!)); 134using var response = await SendRequest(client, "https://dummy", asynchronous); 219.Setup(v => v.GetPipeline<HttpResponseMessage>(new HttpKey(expectedPipelineKey, "https://dummy1"))) 220.Returns(ResiliencePipeline<HttpResponseMessage>.Empty); 225.Setup(v => v.GetPipeline<HttpResponseMessage>(new HttpKey(expectedPipelineKey, string.Empty))) 226.Returns(ResiliencePipeline<HttpResponseMessage>.Empty); 259.Setup(v => v.GetPipeline<HttpResponseMessage>(new HttpKey(pipelineName, string.Empty))) 260.Returns(ResiliencePipeline<HttpResponseMessage>.Empty) 289private void ConfigureBuilder(ResiliencePipelineBuilder<HttpResponseMessage> builder) => builder.AddTimeout(TimeSpan.FromSeconds(1));

Resilience\HttpClientBuilderExtensionsTests.Standard.cs (4)

39private static Task<HttpResponseMessage> SendRequest(HttpClient client, string url, bool asynchronous) 165var descriptor = provider.GetPipeline<HttpResponseMessage>(new HttpKey("test-standard", string.Empty)).GetPipelineDescriptor(); 295private static ResiliencePipeline<HttpResponseMessage> GetPipeline(IServiceCollection services, string name) 299return provider.GetPipeline<HttpResponseMessage>(new HttpKey(name, string.Empty));

Resilience\HttpResilienceMetricsEnricherTests.cs (4)

34var context = new EnrichmentContext<HttpResponseMessage, string>(default, tags); 46using var response = new HttpResponseMessage(System.Net.HttpStatusCode.InternalServerError); 47var args = new TelemetryEventArguments<HttpResponseMessage, string>(default!, default!, default!, default!, Outcome.FromResult(response)); 48var context = new EnrichmentContext<HttpResponseMessage, string>(args, tags);

Resilience\ResilienceHandlerTest.cs (8)

28using var handler = new ResilienceHandler(ResiliencePipeline<HttpResponseMessage>.Empty); 66using var handler = new ResilienceHandler(_ => ResiliencePipeline<HttpResponseMessage>.Empty); 98using var handler = new ResilienceHandler(_ => ResiliencePipeline<HttpResponseMessage>.Empty); 115var response = await InvokeHandler(invoker, request, asynchronous); 129using var handler = new ResilienceHandler(_ => ResiliencePipeline<HttpResponseMessage>.Empty); 140var response = await InvokeHandler(invoker, request, asynchronous, source.Token); 153using var handler = new ResilienceHandler(_ => ResiliencePipeline<HttpResponseMessage>.Empty); 162private static Task<HttpResponseMessage> InvokeHandler(

BlobAppendReferenceWrapper.cs (2)

33Task<HttpResponseMessage> AppendDataAsync() 44var response = await AppendDataAsync().ConfigureAwait(false);

ModelLoaders\UriModelLoader.cs (2)

110var resp = await client.SendAsync(headRequest); 143var resp = await client.GetAsync(_uri);

Http\ResolvingHttpClientHandler.cs (1)

17protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

Http\ResolvingHttpDelegatingHandler.cs (1)

41protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

StreamWrapper.cs (1)

95 var response = await client.GetAsync(uri, cancellationToken).ConfigureAwait(false);

DatasetUtil.cs (1)

210var response = await client.GetAsync(url).ConfigureAwait(false);

Utilities\ResourceManagerUtils.cs (1)

268var response = await httpClient.GetAsync(uri, ct).ConfigureAwait(false);

ImageClassificationBench.cs (3)

163var headerResponse = client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead).Result; 171var response = client.GetAsync(url).Result; 180var response = client.GetAsync(url).Result;

Utils\Helpers.netcoreapp.cs (1)

27HttpResponseMessage response = client.Send(new HttpRequestMessage(HttpMethod.Get, url), HttpCompletionOption.ResponseHeadersRead);

test\Microsoft.ML.Tokenizers.Tests\Utils.cs (1)

21var response = await client.GetAsync(url);

Utils.cs (1)

21var response = await client.GetAsync(url);

Controllers\AuthTestController.cs (8)

34var result = await client.GetAsync("auth/Unrestricted"); 55var result = await client.GetAsync("auth/Authorized"); 83var result = await client.GetAsync("auth/Authorized"); 106var result = await client.GetAsync("auth/Authorized"); 139var result = await client.GetAsync("auth/Authorized"); 172var result = await client.GetAsync("auth/Authorized"); 203var result = await client.GetAsync("auth/Unauthorized"); 229var result = await client.GetAsync("auth/Authorized");

netstandard.cs (1)

1132[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Net.Http.HttpResponseMessage))]

Startup.cs (1)

261var tokenResponse = await options.Backchannel.PostAsync(metadata.TokenEndpoint, content, context.RequestAborted);

HelloWorldTest.cs (2)

64var response = await RetryHelper.RetryRequest(() => 150using (var response = await RetryHelper.RetryRequest(() =>

NtlmAuthenticationTest.cs (1)

51var response = await RetryHelper.RetryRequest(() =>

ResponseCompressionTests.cs (4)

142var response = await RetryHelper.RetryRequest(() => 169var response = await client.SendAsync(request); 201var response = await client.SendAsync(request); 218private static string GetContentLength(HttpResponseMessage response)

ResponseTests.cs (8)

104var response = await RetryHelper.RetryRequest(() => 134var response = await client.SendAsync(requestMessage); 154var response = await client.GetAsync("connectionclose"); 179var response = await client.SendAsync(requestMessage); 204var response = await client.SendAsync(requestMessage); 229var response = await client.SendAsync(requestMessage); 249var response = await client.GetAsync("manuallychunkedandclose"); 266private static string GetContentLength(HttpResponseMessage response)

Startup.cs (3)

141var response = await context.Backchannel.SendAsync(request, context.HttpContext.RequestAborted); 202var response = await context.Backchannel.SendAsync(request, context.HttpContext.RequestAborted); 330var refreshResponse = await options.Backchannel.PostAsync(options.TokenEndpoint, content, context.RequestAborted);

SocketTransportTests.cs (1)

55var response = await client.GetAsync($"http://127.0.0.1:{host.GetPort()}/");

src\Servers\Kestrel\test\FunctionalTests\RequestTests.cs (2)

187var response = await client.GetAsync($"http://127.0.0.1:{host.GetPort()}/"); 1123var response = await client.GetAsync($"http://{requestAddress}:{host.GetPort()}/");

src\Servers\Kestrel\test\FunctionalTests\ResponseTests.cs (2)

78var response = await client.GetAsync($"http://127.0.0.1:{host.GetPort()}/"); 127var response = await client.GetAsync($"http://127.0.0.1:{host.GetPort()}/");

Program.cs (1)

94var response = await client.GetAsync(url);

ResourceBuilderExtensions.cs (1)

66var response = await httpClient.SendAsync(request, context.CancellationToken);

System\Net\Http\DelegatingHandler.cs (2)

45protected internal override HttpResponseMessage Send(HttpRequestMessage request, CancellationToken cancellationToken) 53protected internal override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

System\Net\Http\DiagnosticsHandler.cs (11)

76internal override ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken) 85new ValueTask<HttpResponseMessage>(_innerHandler.SendAsync(request, cancellationToken)) : 86new ValueTask<HttpResponseMessage>(_innerHandler.Send(request, cancellationToken)); 90private async ValueTask<HttpResponseMessage> SendAsyncCore(HttpRequestMessage request, bool async, CancellationToken cancellationToken) 160HttpResponseMessage? response = null; 271internal ActivityStopData(HttpResponseMessage? response, HttpRequestMessage request, TaskStatus requestTaskStatus) 278public HttpResponseMessage? Response { get; } 329[DynamicDependency(nameof(HttpResponseMessage.StatusCode), typeof(HttpResponseMessage))] 330internal ResponseData(HttpResponseMessage? response, Guid loggingRequestId, long timestamp, TaskStatus requestTaskStatus) 338public HttpResponseMessage? Response { get; }

System\Net\Http\DiagnosticsHelper.cs (1)

62public static bool TryGetErrorType(HttpResponseMessage? response, Exception? exception, out string? errorType)

System\Net\Http\HttpClient.cs (41)

System\Net\Http\HttpClientHandler.cs (2)

354protected internal override HttpResponseMessage Send(HttpRequestMessage request, CancellationToken cancellationToken) 364protected internal override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

System\Net\Http\HttpMessageHandler.cs (2)

22protected internal virtual HttpResponseMessage Send(HttpRequestMessage request, CancellationToken cancellationToken) 27protected internal abstract Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken);

System\Net\Http\HttpMessageInvoker.cs (5)

32public virtual HttpResponseMessage Send(HttpRequestMessage request, CancellationToken cancellationToken) 42HttpResponseMessage? response = null; 64public virtual Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 77static async Task<HttpResponseMessage> SendAsyncWithTelemetry(HttpMessageHandler handler, HttpRequestMessage request, CancellationToken cancellationToken) 81HttpResponseMessage? response = null;

System\Net\Http\HttpResponseMessage.cs (1)

161public HttpResponseMessage EnsureSuccessStatusCode()

System\Net\Http\HttpTelemetry.cs (1)

68public void RequestStop(HttpResponseMessage? response)

System\Net\Http\MessageProcessingHandler.cs (10)

27protected abstract HttpResponseMessage ProcessResponse(HttpResponseMessage response, 30protected internal sealed override HttpResponseMessage Send(HttpRequestMessage request, 37HttpResponseMessage response = base.Send(newRequestMessage, cancellationToken); 38HttpResponseMessage newResponseMessage = ProcessResponse(response, cancellationToken); 42protected internal sealed override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, 56Task<HttpResponseMessage> sendAsyncTask = base.SendAsync(newRequestMessage, cancellationToken); 86HttpResponseMessage responseMessage = self.ProcessResponse(task.Result, token); 118TaskCompletionSource<HttpResponseMessage> tcs, OperationCanceledException e) 136private sealed class SendState : TaskCompletionSource<HttpResponseMessage>

System\Net\Http\Metrics\HttpMetricsEnrichmentContext.cs (3)

26private HttpResponseMessage? _response; 46public HttpResponseMessage? Response => _response; 102HttpResponseMessage? response,

System\Net\Http\Metrics\MetricsHandler.cs (6)

36internal override ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken) 45new ValueTask<HttpResponseMessage>(_innerHandler.SendAsync(request, cancellationToken)) : 46new ValueTask<HttpResponseMessage>(_innerHandler.Send(request, cancellationToken)); 50private async ValueTask<HttpResponseMessage> SendAsyncWithMetrics(HttpRequestMessage request, bool async, CancellationToken cancellationToken) 53HttpResponseMessage? response = null; 97private void RequestStop(HttpRequestMessage request, HttpResponseMessage? response, Exception? exception, long startTimestamp, bool recordCurrentRequests)

System\Net\Http\SocketsHttpHandler\AuthenticationHelper.cs (10)

System\Net\Http\SocketsHttpHandler\AuthenticationHelper.NtAuth.cs (6)

51private static Task<HttpResponseMessage> InnerSendAsync(HttpRequestMessage request, bool async, bool isProxyAuth, HttpConnectionPool pool, HttpConnection connection, CancellationToken cancellationToken) 58private static bool ProxySupportsConnectionAuth(HttpResponseMessage response) 76private static async Task<HttpResponseMessage> SendWithNtAuthAsync(HttpRequestMessage request, Uri authUri, bool async, ICredentials credentials, TokenImpersonationLevel impersonationLevel, bool isProxyAuth, HttpConnection connection, HttpConnectionPool connectionPool, CancellationToken cancellationToken) 78HttpResponseMessage response = await InnerSendAsync(request, async, isProxyAuth, connectionPool, connection, cancellationToken).ConfigureAwait(false); 235public static Task<HttpResponseMessage> SendWithNtProxyAuthAsync(HttpRequestMessage request, Uri proxyUri, bool async, ICredentials proxyCredentials, TokenImpersonationLevel impersonationLevel, HttpConnection connection, HttpConnectionPool connectionPool, CancellationToken cancellationToken) 240public static Task<HttpResponseMessage> SendWithNtConnectionAuthAsync(HttpRequestMessage request, bool async, ICredentials credentials, TokenImpersonationLevel impersonationLevel, HttpConnection connection, HttpConnectionPool connectionPool, CancellationToken cancellationToken)

System\Net\Http\SocketsHttpHandler\ChunkedEncodingReadStream.cs (2)

21private readonly HttpResponseMessage _response; 23public ChunkedEncodingReadStream(HttpConnection connection, HttpResponseMessage response) : base(connection)

System\Net\Http\SocketsHttpHandler\ConnectionPool\HttpConnectionPool.cs (7)

354public ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool async, bool doRequestAuth, CancellationToken cancellationToken) 373public ValueTask<HttpResponseMessage> SendWithProxyAuthAsync(HttpRequestMessage request, bool async, bool doRequestAuth, CancellationToken cancellationToken) 383private Task<HttpResponseMessage> SendWithNtConnectionAuthAsync(HttpConnection connection, HttpRequestMessage request, bool async, bool doRequestAuth, CancellationToken cancellationToken) 393public Task<HttpResponseMessage> SendWithNtProxyAuthAsync(HttpConnection connection, HttpRequestMessage request, bool async, CancellationToken cancellationToken) 403public async ValueTask<HttpResponseMessage> SendWithVersionDetectionAndRetryAsync(HttpRequestMessage request, bool async, bool doRequestAuth, CancellationToken cancellationToken) 415HttpResponseMessage? response = null; 792HttpResponseMessage tunnelResponse = await _poolManager.SendProxyConnectAsync(tunnelRequest, _proxyUri!, async, cancellationToken).ConfigureAwait(false);

System\Net\Http\SocketsHttpHandler\ConnectionPool\HttpConnectionPool.Http3.cs (3)

68private async ValueTask<HttpResponseMessage?> TrySendUsingHttp3Async(HttpRequestMessage request, CancellationToken cancellationToken) 114HttpResponseMessage response = await connection.SendAsync(request, queueStartingTimestamp, waitForConnectionActivity, cancellationToken).ConfigureAwait(false); 642private void ProcessAltSvc(HttpResponseMessage response)

System\Net\Http\SocketsHttpHandler\CookieHelper.cs (1)

12public static void ProcessReceivedCookies(HttpResponseMessage response, CookieContainer cookieContainer)

System\Net\Http\SocketsHttpHandler\DecompressionHandler.cs (2)

52internal override async ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken) 69HttpResponseMessage response = await _innerHandler.SendAsync(request, async, cancellationToken).ConfigureAwait(false);

System\Net\Http\SocketsHttpHandler\Http2Connection.cs (1)

1983public async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken)

System\Net\Http\SocketsHttpHandler\Http2Stream.cs (9)

System\Net\Http\SocketsHttpHandler\Http3Connection.cs (2)

244public async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, long queueStartingTimestamp, Activity? waitForConnectionActivity, CancellationToken cancellationToken) 318Task<HttpResponseMessage> responseTask = requestStream.SendAsync(cancellationToken);

System\Net\Http\SocketsHttpHandler\Http3RequestStream.cs (8)

System\Net\Http\SocketsHttpHandler\HttpAuthenticatedConnectionHandler.cs (1)

18internal override ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken)

System\Net\Http\SocketsHttpHandler\HttpConnection.cs (8)

532public async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken) 663var response = new HttpResponseMessage() { RequestMessage = request, Content = new HttpConnectionResponseContent() }; 1027private bool ParseStatusLine(HttpResponseMessage response) 1056private static void ParseStatusLineCore(Span<byte> line, HttpResponseMessage response) 1129private bool ParseHeaders(HttpResponseMessage? response, bool isFromTrailer) 1148private (bool finished, int bytesConsumed) ParseHeadersCore(Span<byte> buffer, HttpResponseMessage? response, bool isFromTrailer) 1227private void AddResponseHeader(ReadOnlySpan<byte> name, ReadOnlySpan<byte> value, HttpResponseMessage response, bool isFromTrailer) 2067public async ValueTask DrainResponseAsync(HttpResponseMessage response, CancellationToken cancellationToken)

System\Net\Http\SocketsHttpHandler\HttpConnectionHandler.cs (1)

18internal override ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken)

System\Net\Http\SocketsHttpHandler\HttpConnectionPoolManager.cs (4)

330public ValueTask<HttpResponseMessage> SendAsyncCore(HttpRequestMessage request, Uri? proxyUri, bool async, bool doRequestAuth, bool isProxyConnect, CancellationToken cancellationToken) 369public ValueTask<HttpResponseMessage> SendProxyConnectAsync(HttpRequestMessage request, Uri proxyUri, bool async, CancellationToken cancellationToken) 374public ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool async, bool doRequestAuth, CancellationToken cancellationToken) 427private async ValueTask<HttpResponseMessage> SendAsyncMultiProxy(HttpRequestMessage request, bool async, bool doRequestAuth, MultiProxy multiProxy, Uri? firstProxy, CancellationToken cancellationToken)

System\Net\Http\SocketsHttpHandler\HttpMessageHandlerStage.cs (4)

11protected internal sealed override HttpResponseMessage Send(HttpRequestMessage request, 14ValueTask<HttpResponseMessage> sendTask = SendAsync(request, async: false, cancellationToken); 20protected internal sealed override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) => 23internal abstract ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken);

System\Net\Http\SocketsHttpHandler\RedirectHandler.cs (3)

28internal override async ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken) 30HttpResponseMessage response = await _initialInnerHandler.SendAsync(request, async, cancellationToken).ConfigureAwait(false); 91private Uri? GetUriForRedirect(Uri requestUri, HttpResponseMessage response)

System\Net\Http\SocketsHttpHandler\SocketsHttpHandler.cs (4)

578protected internal override HttpResponseMessage Send(HttpRequestMessage request, 609protected internal override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 617return Task.FromCanceled<HttpResponseMessage>(cancellationToken); 625return Task.FromException<HttpResponseMessage>(error);

System\Net\Http\Json\HttpClientJsonExtensions.cs (9)

System\Net\Http\Json\HttpClientJsonExtensions.Delete.cs (1)

18private static readonly Func<HttpClient, Uri?, CancellationToken, Task<HttpResponseMessage>> s_deleteAsync =

System\Net\Http\Json\HttpClientJsonExtensions.Get.AsyncEnumerable.cs (1)

162using HttpResponseMessage response = await client.GetAsync(requestUri, HttpCompletionOption.ResponseHeadersRead, cancellationToken)

System\Net\Http\Json\HttpClientJsonExtensions.Get.cs (1)

18private static readonly Func<HttpClient, Uri?, CancellationToken, Task<HttpResponseMessage>> s_getAsync =

System\Net\Http\Json\HttpClientJsonExtensions.Patch.cs (6)

27public static Task<HttpResponseMessage> PatchAsJsonAsync<TValue>(this HttpClient client, [StringSyntax(StringSyntaxAttribute.Uri)] string? requestUri, TValue value, JsonSerializerOptions? options = null, CancellationToken cancellationToken = default) 51public static Task<HttpResponseMessage> PatchAsJsonAsync<TValue>(this HttpClient client, Uri? requestUri, TValue value, JsonSerializerOptions? options = null, CancellationToken cancellationToken = default) 74public static Task<HttpResponseMessage> PatchAsJsonAsync<TValue>(this HttpClient client, [StringSyntax(StringSyntaxAttribute.Uri)] string? requestUri, TValue value, CancellationToken cancellationToken) 89public static Task<HttpResponseMessage> PatchAsJsonAsync<TValue>(this HttpClient client, Uri? requestUri, TValue value, CancellationToken cancellationToken) 103public static Task<HttpResponseMessage> PatchAsJsonAsync<TValue>(this HttpClient client, [StringSyntax(StringSyntaxAttribute.Uri)] string? requestUri, TValue value, JsonTypeInfo<TValue> jsonTypeInfo, CancellationToken cancellationToken = default) 125public static Task<HttpResponseMessage> PatchAsJsonAsync<TValue>(this HttpClient client, Uri? requestUri, TValue value, JsonTypeInfo<TValue> jsonTypeInfo, CancellationToken cancellationToken = default)

System\Net\Http\Json\HttpClientJsonExtensions.Post.cs (6)

16public static Task<HttpResponseMessage> PostAsJsonAsync<TValue>(this HttpClient client, [StringSyntax(StringSyntaxAttribute.Uri)] string? requestUri, TValue value, JsonSerializerOptions? options = null, CancellationToken cancellationToken = default) 29public static Task<HttpResponseMessage> PostAsJsonAsync<TValue>(this HttpClient client, Uri? requestUri, TValue value, JsonSerializerOptions? options = null, CancellationToken cancellationToken = default) 42public static Task<HttpResponseMessage> PostAsJsonAsync<TValue>(this HttpClient client, [StringSyntax(StringSyntaxAttribute.Uri)] string? requestUri, TValue value, CancellationToken cancellationToken) 47public static Task<HttpResponseMessage> PostAsJsonAsync<TValue>(this HttpClient client, Uri? requestUri, TValue value, CancellationToken cancellationToken) 50public static Task<HttpResponseMessage> PostAsJsonAsync<TValue>(this HttpClient client, [StringSyntax(StringSyntaxAttribute.Uri)] string? requestUri, TValue value, JsonTypeInfo<TValue> jsonTypeInfo, CancellationToken cancellationToken = default) 61public static Task<HttpResponseMessage> PostAsJsonAsync<TValue>(this HttpClient client, Uri? requestUri, TValue value, JsonTypeInfo<TValue> jsonTypeInfo, CancellationToken cancellationToken = default)

System\Net\Http\Json\HttpClientJsonExtensions.Put.cs (6)

16public static Task<HttpResponseMessage> PutAsJsonAsync<TValue>(this HttpClient client, [StringSyntax(StringSyntaxAttribute.Uri)] string? requestUri, TValue value, JsonSerializerOptions? options = null, CancellationToken cancellationToken = default) 29public static Task<HttpResponseMessage> PutAsJsonAsync<TValue>(this HttpClient client, Uri? requestUri, TValue value, JsonSerializerOptions? options = null, CancellationToken cancellationToken = default) 42public static Task<HttpResponseMessage> PutAsJsonAsync<TValue>(this HttpClient client, [StringSyntax(StringSyntaxAttribute.Uri)] string? requestUri, TValue value, CancellationToken cancellationToken) 47public static Task<HttpResponseMessage> PutAsJsonAsync<TValue>(this HttpClient client, Uri? requestUri, TValue value, CancellationToken cancellationToken) 50public static Task<HttpResponseMessage> PutAsJsonAsync<TValue>(this HttpClient client, [StringSyntax(StringSyntaxAttribute.Uri)] string? requestUri, TValue value, JsonTypeInfo<TValue> jsonTypeInfo, CancellationToken cancellationToken = default) 61public static Task<HttpResponseMessage> PutAsJsonAsync<TValue>(this HttpClient client, Uri? requestUri, TValue value, JsonTypeInfo<TValue> jsonTypeInfo, CancellationToken cancellationToken = default)

artifacts\obj\System.Net.Http.WinHttpHandler\Debug\net10.0\System.Net.Http.WinHttpHandler.notsupported.cs (1)

52protected override System.Threading.Tasks.Task<System.Net.Http.HttpResponseMessage> SendAsync(System.Net.Http.HttpRequestMessage request, System.Threading.CancellationToken cancellationToken) { throw new System.PlatformNotSupportedException(System.SR.PlatformNotSupported_WinHttpHandler); }

System\Net\HttpWebRequest.cs (3)

48private Task<HttpResponseMessage>? _sendRequestTask; 1168private Task<HttpResponseMessage> SendRequest(bool async, HttpContent? content = null) 1255HttpResponseMessage responseMessage = await _sendRequestTask.ConfigureAwait(false);

System\Net\HttpWebResponse.cs (3)

24private HttpResponseMessage _httpResponseMessage = null!; 58internal HttpWebResponse(HttpResponseMessage _message, Uri requestUri, CookieContainer? cookieContainer) 369var httpResponseMessage = _httpResponseMessage;

System\Net\WebSockets\WebSocketHandle.Managed.cs (3)

67HttpResponseMessage? response = null; 127Task<HttpResponseMessage> sendTask = invoker is HttpClient client 447private static void ValidateResponse(HttpResponseMessage response, string? secValue)

BlazorWebTemplateTest.cs (1)

83var response = await aspNetProcess.SendRequest(() =>

src\ProjectTemplates\Shared\AspNetProcess.cs (5)

180var result = await RetryHelper.RetryRequest(async () => 243private static bool IsSuccessStatusCode(HttpResponseMessage response) 254internal Task<HttpResponseMessage> SendRequest(string path) => 257internal Task<HttpResponseMessage> SendRequest(Func<HttpRequestMessage> requestFactory) 262var response = await RetryHelper.RetryRequest(() =>

src\ProjectTemplates\Shared\AspNetProcess.cs (5)

180var result = await RetryHelper.RetryRequest(async () => 243private static bool IsSuccessStatusCode(HttpResponseMessage response) 254internal Task<HttpResponseMessage> SendRequest(string path) => 257internal Task<HttpResponseMessage> SendRequest(Func<HttpRequestMessage> requestFactory) 262var response = await RetryHelper.RetryRequest(() =>

src\Shared\E2ETesting\SauceConnectServer.cs (1)

159var response = await httpClient.GetAsync(uri);

src\ProjectTemplates\Shared\AspNetProcess.cs (5)

180var result = await RetryHelper.RetryRequest(async () => 243private static bool IsSuccessStatusCode(HttpResponseMessage response) 254internal Task<HttpResponseMessage> SendRequest(string path) => 257internal Task<HttpResponseMessage> SendRequest(Func<HttpRequestMessage> requestFactory) 262var response = await RetryHelper.RetryRequest(() =>

src\Shared\E2ETesting\SauceConnectServer.cs (1)

159var response = await httpClient.GetAsync(uri);

BlazorTemplateTest.cs (1)

110var response = await process.SendRequest(BlazorTemplatePages.Auth);

src\ProjectTemplates\Shared\AspNetProcess.cs (5)

180var result = await RetryHelper.RetryRequest(async () => 243private static bool IsSuccessStatusCode(HttpResponseMessage response) 254internal Task<HttpResponseMessage> SendRequest(string path) => 257internal Task<HttpResponseMessage> SendRequest(Func<HttpRequestMessage> requestFactory) 262var response = await RetryHelper.RetryRequest(() =>

src\Shared\E2ETesting\SauceConnectServer.cs (1)

159var response = await httpClient.GetAsync(uri);

IdentityUIPackageTest.cs (3)

131var response = await aspNetProcess.SendRequest("/Identity/lib/bootstrap/dist/css/bootstrap.css"); 143var response = await aspNetProcess.SendRequest("/Identity/lib/bootstrap/dist/css/bootstrap.css"); 154var response = await aspNetProcess.SendRequest(file);

src\ProjectTemplates\Shared\AspNetProcess.cs (5)

180var result = await RetryHelper.RetryRequest(async () => 243private static bool IsSuccessStatusCode(HttpResponseMessage response) 254internal Task<HttpResponseMessage> SendRequest(string path) => 257internal Task<HttpResponseMessage> SendRequest(Func<HttpRequestMessage> requestFactory) 262var response = await RetryHelper.RetryRequest(() =>

src\Shared\E2ETesting\SauceConnectServer.cs (1)

159var response = await httpClient.GetAsync(uri);