public async Task DispatchAsync_Should_Invoke_ProcessAsync()
{
// Arrange
var command = new BasicCommand();
var progress = new QuidjiboProgress();
var handler = Substitute.For <IQuidjiboHandler <BasicCommand> >();
_resolver.Resolve(typeof(IQuidjiboHandler <BasicCommand>)).Returns(handler);
// Act
await _sut.DispatchAsync(command, progress, CancellationToken.None);
// Assert
_resolver.Received(1).Resolve(typeof(IQuidjiboHandler <BasicCommand>));
await handler.Received(1).ProcessAsync(command, progress, CancellationToken.None);
}
private async Task InvokePipelineAsync(IWorkProvider provider, WorkItem item)
{
using (var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(_cts.Token))
{
var progress = new QuidjiboProgress();
progress.ProgressChanged += async(sender, tracker) =>
{
var progressProvider = await _progressProviderFactory.CreateAsync(item.Queue, _cts.Token);
var progressItem = new ProgressItem
{
Id = Guid.NewGuid(),
CorrelationId = item.CorrelationId,
RecordedOn = DateTime.UtcNow,
Name = item.Name,
Queue = item.Queue,
Note = tracker.Text,
Value = tracker.Value,
WorkId = item.Id
};
await progressProvider.ReportAsync(progressItem, _cts.Token);
};
var renewTask = RenewAsync(provider, item, linkedTokenSource.Token);
var context = new QuidjiboContext
{
Item = item,
WorkProvider = provider,
Progress = progress,
State = new PipelineState()
};
try
{
await _quidjiboPipeline.StartAsync(context, linkedTokenSource.Token);
if (context.State.Success)
{
await provider.CompleteAsync(item, linkedTokenSource.Token);
_logger.LogDebug("Completed : {0}", item.Id);
}
else
{
await provider.FaultAsync(item, linkedTokenSource.Token);
_logger.LogError("Faulted : {0}", item.Id);
}
}
catch (Exception exception)
{
_logger.LogError("Faulted : {0}, {1}", item.Id, exception);
await provider.FaultAsync(item, linkedTokenSource.Token);
}
finally
{
_logger.LogDebug("Release : {0}", item.Id);
linkedTokenSource.Cancel();
await renewTask;
await _quidjiboPipeline.EndAsync(context);
}
}
}
