public async Task RetryingEmitsEventSourceEvent()
{
var listener = new TestEventListener();
listener.EnableEvents(HttpPipelineEventSource.Singleton, EventLevel.Informational);
var policy = new FixedRetryPolicyMock(retriableCodes: new [] { 500 }, delay: TimeSpan.FromSeconds(3), maxRetries: 2);
var mockTransport = new MockTransport();
var task = SendRequest(mockTransport, policy);
var request = await mockTransport.RequestGate.Cycle(new MockResponse(500));
for (int i = 0; i < 2; i++)
{
var delay = await policy.DelayGate.Cycle();
Assert.AreEqual(delay, TimeSpan.FromSeconds(3));
await mockTransport.RequestGate.Cycle(new MockResponse(500));
}
await task.TimeoutAfterDefault();
AssertRetryEvent(listener, request, 1);
AssertRetryEvent(listener, request, 2);
}
public async Task RethrowsAggregateExceptionAfterMaxRetryCount()
{
var policy = new FixedRetryPolicyMock(retriableCodes: new [] { 500 }, exceptionFilter: ex => ex is InvalidOperationException, delay: TimeSpan.FromSeconds(3), maxRetries: 3);
var mockTransport = new MockTransport();
var task = SendRequest(mockTransport, policy);
var exceptions = new List <Exception>();
exceptions.Add(new InvalidOperationException());
await mockTransport.RequestGate.CycleWithException(exceptions.Last());
for (int i = 0; i < 3; i++)
{
var delay = await policy.DelayGate.Cycle();
Assert.AreEqual(delay, TimeSpan.FromSeconds(3));
exceptions.Add(new InvalidOperationException());
await mockTransport.RequestGate.CycleWithException(exceptions.Last());
}
var exception = Assert.ThrowsAsync <AggregateException>(async() => await task.TimeoutAfterDefault());
StringAssert.StartsWith("Retry failed after 4 tries.", exception.Message);
CollectionAssert.AreEqual(exceptions, exception.InnerExceptions);
}
public void DoesntMutateOriginalArray()
{
var codes = new[] { 1, 500, 0 };
_ = new FixedRetryPolicyMock(retriableCodes: codes);
CollectionAssert.AreEqual(new[] { 1, 500, 0 }, codes);
}
public async Task RetriesOnlyFilteredExceptionFirst()
{
var policy = new FixedRetryPolicyMock(retriableCodes: new [] { 500 }, exceptionFilter: ex => ex is InvalidOperationException, delay: TimeSpan.FromSeconds(3));
var mockTransport = new MockTransport();
var task = SendRequest(mockTransport, policy);
await mockTransport.RequestGate.CycleWithException(new IOException());
Assert.ThrowsAsync <IOException>(async() => await task.TimeoutAfterDefault());
}
private static Task <Response> SendRequest(MockTransport mockTransport, FixedRetryPolicyMock policy)
{
var options = new HttpPipelineOptions(mockTransport);
options.RetryPolicy = policy;
var pipeline = options.Build(typeof(FixedRetryPolicyTests).Assembly);
var httpPipelineRequest = pipeline.CreateRequest();
httpPipelineRequest.SetRequestLine(HttpVerb.Get, new Uri("http://example.com/"));
return(pipeline.SendRequestAsync(httpPipelineRequest, CancellationToken.None));
}
public async Task WaitsBetweenRetries()
{
var policy = new FixedRetryPolicyMock(retriableCodes: new [] { 500 }, delay: TimeSpan.FromSeconds(3));
var mockTransport = new MockTransport();
var task = SendRequest(mockTransport, policy);
await mockTransport.RequestGate.Cycle(new MockResponse(500));
var delay = await policy.DelayGate.Cycle();
Assert.AreEqual(delay, TimeSpan.FromSeconds(3));
await mockTransport.RequestGate.Cycle(new MockResponse(200));
var response = await task.TimeoutAfterDefault();
Assert.AreEqual(200, response.Status);
}
public async Task RetriesOnException()
{
var policy = new FixedRetryPolicyMock(retriableCodes: new [] { 500 }, exceptionFilter: ex => ex is InvalidOperationException, delay: TimeSpan.FromSeconds(3));
var mockTransport = new MockTransport();
var task = SendRequest(mockTransport, policy);
await mockTransport.RequestGate.CycleWithException(new InvalidOperationException());
var delay = await policy.DelayGate.Cycle();
Assert.AreEqual(delay, TimeSpan.FromSeconds(3));
await mockTransport.RequestGate.Cycle(new MockResponse(200));
var response = await task.TimeoutAfterDefault();
Assert.AreEqual(200, response.Status);
}
public async Task RetriesOnlyFilteredException()
{
var policy = new FixedRetryPolicyMock(retriableCodes: new [] { 500 }, exceptionFilter: ex => ex is InvalidOperationException, delay: TimeSpan.FromSeconds(3));
var mockTransport = new MockTransport();
var task = SendRequest(mockTransport, policy);
await mockTransport.RequestGate.CycleWithException(new InvalidOperationException());
var delay = await policy.DelayGate.Cycle();
Assert.AreEqual(delay, TimeSpan.FromSeconds(3));
await mockTransport.RequestGate.CycleWithException(new IOException());
var exception = Assert.ThrowsAsync <AggregateException>(async() => await task.TimeoutAfterDefault());
StringAssert.StartsWith("Retry failed after 2 tries.", exception.Message);
Assert.IsInstanceOf <InvalidOperationException>(exception.InnerExceptions[0]);
Assert.IsInstanceOf <IOException>(exception.InnerExceptions[1]);
}
public async Task WaitsSameAmountEveryTime()
{
var policy = new FixedRetryPolicyMock(retriableCodes: new [] { 500 }, delay: TimeSpan.FromSeconds(3), maxRetries: 3);
var mockTransport = new MockTransport();
var task = SendRequest(mockTransport, policy);
await mockTransport.RequestGate.Cycle(new MockResponse(500));
for (int i = 0; i < 3; i++)
{
var delay = await policy.DelayGate.Cycle();
Assert.AreEqual(delay, TimeSpan.FromSeconds(3));
await mockTransport.RequestGate.Cycle(new MockResponse(500));
}
var response = await task.TimeoutAfterDefault();
Assert.AreEqual(500, response.Status);
}
public async Task UsesLargerOfDelayAndServerDelay(int delay, int retryAfter, int expected)
{
var responseClassifier = new MockResponseClassifier(retriableCodes: new [] { 500 });
var policy = new FixedRetryPolicyMock(delay: TimeSpan.FromSeconds(delay));
var mockTransport = CreateMockTransport();
var task = SendGetRequest(mockTransport, policy, responseClassifier);
MockResponse mockResponse = new MockResponse(500);
mockResponse.AddHeader(new HttpHeader("Retry-After", retryAfter.ToString()));
await mockTransport.RequestGate.Cycle(mockResponse);
var retryDelay = await policy.DelayGate.Cycle();
await mockTransport.RequestGate.Cycle(new MockResponse(501));
var response = await task.TimeoutAfterDefault();
Assert.AreEqual(TimeSpan.FromSeconds(expected), retryDelay);
Assert.AreEqual(501, response.Status);
}
protected override (HttpPipelinePolicy, AsyncGate <TimeSpan, object>) CreateRetryPolicy(int[] retriableCodes, Func <Exception, bool> exceptionFilter = null, int maxRetries = 3)
{
var policy = new FixedRetryPolicyMock(retriableCodes, exceptionFilter, maxRetries, TimeSpan.FromSeconds(3));
return(policy, policy.DelayGate);
}
protected override (HttpPipelinePolicy, AsyncGate <TimeSpan, object>) CreateRetryPolicy(int maxRetries = 3)
{
var policy = new FixedRetryPolicyMock(maxRetries, TimeSpan.FromSeconds(3));
return(policy, policy.DelayGate);
}
