public async Task AttemptsOnceAndReturnsCorrectResultWhenNoException()
{
// ARRANGE
var worker = new RetryWorker(new LocalWorker(), MaxRetries);
var workItem = new TestWorkItem(false);
// ACT
var result = await worker.DoWorkAsync(workItem, new CancellationToken());
// ASSERT
Assert.That(result, Is.EqualTo(SuccessValue));
Assert.That(workItem.AttemptCount, Is.EqualTo(1));
}
public async Task WorkExceptionInnerExceptionIsAggregateException()
{
// ARRANGE
var worker = new RetryWorker(new LocalWorker(), MaxRetries);
var workItem = new TestWorkItem(true);
try
{
// ACT
await worker.DoWorkAsync(workItem, new CancellationToken());
}
catch (Exception ex)
{
// ASSERT
Assert.That(ex.InnerException, Is.TypeOf <AggregateException>());
}
}
public async Task ThrowsWorkExceptionAfterMaximumAttempts()
{
// ARRANGE
var worker = new RetryWorker(new LocalWorker(), MaxRetries);
var workItem = new TestWorkItem(true);
// ACT
try
{
await worker.DoWorkAsync(workItem, new CancellationToken());
}
catch (Exception)
{
// ASSERT
Assert.That(workItem.AttemptCount, Is.EqualTo(MaxRetries + 1));
throw;
}
}
public async Task ShouldRetryPredicateLimitsRetriesCorrectly()
{
// ARRANGE
var worker = new RetryWorker(new LocalWorker(), MaxRetries, e => e.InnerException is CommunicationException);
var workItem = new TestWorkItem(true);
try
{
// ACT
await worker.DoWorkAsync(workItem, new CancellationToken());
}
catch
{
}
// ASSERT
Assert.That(workItem.AttemptCount, Is.EqualTo(2));
}
public async Task RetryWorkExceptionInnerAggregateExceptionCountMatchesNumberOfAttempts()
{
// ARRANGE
var worker = new RetryWorker(new LocalWorker(), MaxRetries);
var workItem = new TestWorkItem(true);
try
{
// ACT
await worker.DoWorkAsync(workItem, new CancellationToken());
}
catch (Exception ex)
{
// ASSERT
Assert.That(
((AggregateException)ex.InnerException).InnerExceptions.Count,
Is.EqualTo(MaxRetries + 1));
}
}
