public async Task Client_with_retry_and_timeout_policy_should_properly_apply_policies_with_multiple_middlewares()
{
var visitedMiddleware = new List <string>();
var trafficRecorderMessageHandler = new TrafficRecorderMessageHandler(visitedMiddleware);
var eventMessageHandler = new EventMessageHandler(visitedMiddleware);
//timeout after 2 seconds, then retry
var clientWithRetry = HttpClientFactory.Create()
.WithPolicy(
Policy <HttpResponseMessage>
.Handle <HttpRequestException>()
.OrResult(result => result.StatusCode >= HttpStatusCode.InternalServerError || result.StatusCode == HttpStatusCode.RequestTimeout)
.WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(1)))
.WithPolicy(
Policy.TimeoutAsync <HttpResponseMessage>(TimeSpan.FromSeconds(4), TimeoutStrategy.Optimistic))
.WithMessageHandler(eventMessageHandler)
.WithMessageHandler(trafficRecorderMessageHandler)
.Build();
Task <HttpResponseMessage> responseTask = null;
var raisedEvent = await Assert.RaisesAsync <EventMessageHandler.RequestEventArgs>(
h => eventMessageHandler.Request += h,
h => eventMessageHandler.Request -= h,
() => responseTask = clientWithRetry.GetAsync($"{_server.Urls[0]}{_endpointUriTimeout}"));
var responseWithTimeout = await responseTask;
Assert.True(raisedEvent.Arguments.Request.Headers.Contains("foobar"));
Assert.Equal("foobar", raisedEvent.Arguments.Request.Headers.GetValues("foobar").FirstOrDefault());
Assert.Single(trafficRecorderMessageHandler.Traffic);
Assert.Equal(4, _server.LogEntries.Count());
Assert.Equal(HttpStatusCode.RequestTimeout, responseWithTimeout.StatusCode);
}
public async Task Exception_translator_without_errors_should_not_affect_anything()
{
var requestEventHandler = A.Fake <EventHandler <EventMessageHandler.RequestEventArgs> >();
var responseEventHandler = A.Fake <EventHandler <EventMessageHandler.ResponseEventArgs> >();
var requestExceptionEventHandler = A.Fake <EventHandler <HttpRequestException> >();
var transformedRequestExceptionEventHandler = A.Fake <EventHandler <Exception> >();
var visitedMiddleware = new List <string>();
var trafficRecorderMessageHandler = new TrafficRecorderMessageHandler(visitedMiddleware);
var eventMessageHandler = new EventMessageHandler(visitedMiddleware);
eventMessageHandler.Request += requestEventHandler;
eventMessageHandler.Response += responseEventHandler;
var client = HttpClientFactory.Create()
.WithMessageExceptionHandler(ex => true, ex => ex, requestExceptionEventHandler, transformedRequestExceptionEventHandler)
.WithMessageHandler(eventMessageHandler)
.WithMessageHandler(trafficRecorderMessageHandler)
.Build();
await client.GetAsync($"{_server.Urls[0]}{_endpointUri}");
A.CallTo(() => requestEventHandler.Invoke(A <EventMessageHandler> .That.IsSameAs(eventMessageHandler), A <EventMessageHandler.RequestEventArgs> .That.Matches(e => e.Request.Headers.Single(h => h.Key == "foobar").Value.FirstOrDefault() == "foobar"))).MustHaveHappenedOnceExactly()
.Then(A.CallTo(() => responseEventHandler.Invoke(A <EventMessageHandler> .That.IsSameAs(eventMessageHandler), A <EventMessageHandler.ResponseEventArgs> .That.Matches(e => e.Response.Headers.Single(h => h.Key == "foobar").Value.FirstOrDefault() == "foobar"))).MustHaveHappenedOnceExactly());
A.CallTo(() => requestExceptionEventHandler.Invoke(A <ExceptionTranslatorRequestMiddleware> ._, A <HttpRequestException> ._)).MustNotHaveHappened();
A.CallTo(() => transformedRequestExceptionEventHandler.Invoke(A <ExceptionTranslatorRequestMiddleware> ._, A <Exception> ._)).MustNotHaveHappened();
var traffic = Assert.Single(trafficRecorderMessageHandler.Traffic);
Assert.Equal(HttpStatusCode.OK, traffic.Item2.StatusCode);
Assert.Equal(new [] { nameof(TrafficRecorderMessageHandler), nameof(EventMessageHandler) }, visitedMiddleware);
}
private static async Task SingleMiddlewareHandler(string endpoint, Func <TrafficRecorderMessageHandler, IHttpClientBuilder> factory)
{
var trafficRecorderMessageHandler = new TrafficRecorderMessageHandler(new List <string>());
var client = factory(trafficRecorderMessageHandler).Build();
var _ = await client.GetAsync(endpoint);
Assert.Single(trafficRecorderMessageHandler.Traffic);
Assert.Equal(HttpStatusCode.OK, trafficRecorderMessageHandler.Traffic[0].Item2.StatusCode);
}
private static async Task MultipleMiddlewareHandlers(string endpoint, Func <TrafficRecorderMessageHandler, EventMessageHandler, IHttpClientBuilder> factory, IEnumerable <string> expectedVisitedMiddleware)
{
var actuallyVisitedMiddleware = new List <string>();
var trafficRecorderMessageHandler = new TrafficRecorderMessageHandler(actuallyVisitedMiddleware);
var eventMessageHandler = new EventMessageHandler(actuallyVisitedMiddleware);
var client = factory(trafficRecorderMessageHandler, eventMessageHandler).Build();
var raisedEvent = await Assert.RaisesAsync <EventMessageHandler.RequestEventArgs>(
h => eventMessageHandler.Request += h,
h => eventMessageHandler.Request -= h,
() => client.GetAsync(endpoint));
Assert.True(raisedEvent.Arguments.Request.Headers.Contains("foobar"));
Assert.Equal("foobar", raisedEvent.Arguments.Request.Headers.GetValues("foobar").FirstOrDefault());
Assert.Single(trafficRecorderMessageHandler.Traffic);
Assert.Equal(HttpStatusCode.OK, trafficRecorderMessageHandler.Traffic[0].Item2.StatusCode);
Assert.Equal(expectedVisitedMiddleware, actuallyVisitedMiddleware);
}
public async Task Will_send_default_headers()
{
const string headerName = "foobar";
const string headerValue = "xyz123";
var trafficRecorder = new TrafficRecorderMessageHandler(new List <string>());
var client = HttpClientFactory
.Create()
.WithDefaultHeaders(new Dictionary <string, string> {
[headerName] = headerValue
})
.WithMessageHandler(trafficRecorder)
.Build();
_ = await client.GetAsync($"{_server.Urls[0]}{_endpointUri}");
var traffic = Assert.Single(trafficRecorder.Traffic); //sanity check
Assert.True(traffic.Item1.Headers.TryGetValues(headerName, out var headerValues));
Assert.Equal(headerValue, headerValues.FirstOrDefault());
}
public async Task Retry_policy_should_work_with_multiple_middleware()
{
var visitedMiddleware = new List <string>();
var trafficRecorderMessageHandler = new TrafficRecorderMessageHandler(visitedMiddleware);
var eventMessageHandler = new EventMessageHandler(visitedMiddleware);
var clientWithRetry = HttpClientFactory.Create()
.WithPolicy(
Policy <HttpResponseMessage>
.Handle <HttpRequestException>()
.OrResult(result => result.StatusCode >= HttpStatusCode.InternalServerError || result.StatusCode == HttpStatusCode.RequestTimeout)
.WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(1)))
.WithMessageHandler(eventMessageHandler)
.WithMessageHandler(trafficRecorderMessageHandler)
.Build();
Task <HttpResponseMessage> responseTask = null;
var raisedEvent = await Assert.RaisesAsync <EventMessageHandler.RequestEventArgs>(
h => eventMessageHandler.Request += h,
h => eventMessageHandler.Request -= h,
() => responseTask = clientWithRetry.GetAsync($"{_server.Urls[0]}{_endpointUri}"));
var response = await responseTask;
Assert.True(raisedEvent.Arguments.Request.Headers.Contains("foobar"));
Assert.Equal("foobar", raisedEvent.Arguments.Request.Headers.GetValues("foobar").FirstOrDefault());
Assert.Single(trafficRecorderMessageHandler.Traffic);
Assert.Equal(2, _server.LogEntries.Count());
Assert.Single(_server.LogEntries, le => (HttpStatusCode)le.ResponseMessage.StatusCode == HttpStatusCode.OK);
Assert.Single(_server.LogEntries, le => (HttpStatusCode)le.ResponseMessage.StatusCode == HttpStatusCode.RequestTimeout);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("Hello world!", await response.Content.ReadAsStringAsync());
}
