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));
}
}
internal async static Task ConsoleTask(string[] arguments)
{
var verbCommand = new VerbCommands();
string invokedVerb = string.Empty;;
object invokedVerbInstance = new object();
if (!Parser.Default.ParseArguments(arguments, verbCommand, (verb, subObtions) =>
{
invokedVerb = verb;
invokedVerbInstance = subObtions;
}))
{
Environment.Exit(Parser.DefaultExitCodeFail);
}
else
{
try
{
ConsoleProgress <Dictionary <ProgressType, string> > progressDictionary = new ConsoleProgress <Dictionary <ProgressType, string> >(value =>
{
if (value.ContainsKey(ProgressType.Output) && !string.IsNullOrWhiteSpace(value[ProgressType.Output]))
{
Log.Info(value[ProgressType.Output]);
}
if (value.ContainsKey(ProgressType.Error))
{
Log.Error(value[ProgressType.Error]);
}
if (value.ContainsKey(ProgressType.Warning))
{
Log.Warn(value[ProgressType.Warning]);
}
});
CancelSource = new CancellationTokenSource();
var cancelToken = CancelSource.Token;
ConsoleCommands parsedVerb;
var taskWatcher = new TaskWatcher();
if (Enum.TryParse(invokedVerb, true, out parsedVerb))
{
Log.Warn(MessageStrings.CmdCancelMessage);
Console.CancelKeyPress += (sender, eventargs) =>
{
CancelSource.Cancel();
eventargs.Cancel = true;
};
switch (parsedVerb)
{
case ConsoleCommands.Retry:
var retry = (RetryCommands)invokedVerbInstance;
try
{
retry.OctRepository = new OctopusConnectionWorker((IOctopusConnectionSettings)retry).UserConnection();
var retryWorker = new RetryWorker((IOctopusSettings)retry, (IRetrySettings)retry);
await retryWorker.RetryTasks(progressDictionary, taskWatcher, cancelToken);
}
catch (Exception ex)
{
Log.Error(ex.Message);
Log.Error(retry.GetUsage());
Environment.Exit(1);
}
break;
case ConsoleCommands.Cancel:
var cancel = (CancelCommands)invokedVerbInstance;
try
{
cancel.OctRepository = new OctopusConnectionWorker((IOctopusConnectionSettings)cancel).UserConnection();
var cancelWorker = new CancelWorker((IOctopusSettings)cancel, (ICancelSettings)cancel);
await cancelWorker.CancelTasks(progressDictionary, taskWatcher, cancelToken);
}
catch (Exception ex)
{
Log.Error(ex.Message);
Log.Error(cancel.GetUsage());
Environment.Exit(1);
}
break;
default:
Log.Info(verbCommand.GetUsage());
break;
}
}
else
{
Log.Error(verbCommand.GetUsage());
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
