public void ExecuteAsync_HandlesExceptionThrownInCompletedTaskCallback() { // ARRANGE var mockOperation = new Mock <IPipelineOperationAsync <TestPipelineContext> >(); mockOperation .Setup(o => o.Dependencies) .Returns(new List <Type>()); mockOperation .Setup(o => o.ExecuteAsync()) .Returns(Task.CompletedTask); mockOperation .Setup(o => o.CompletedTaskCallback(It.IsAny <Task>())) .Throws(new OperationExecutionException("Unit test exception")); var asyncOperations = new ReadOnlyDictionary <Type, IPipelineOperationAsync <TestPipelineContext> >( new Dictionary <Type, IPipelineOperationAsync <TestPipelineContext> > { { typeof(TestOperationAsync), mockOperation.Object } } ); var opManager = new TestBasePipelineCoordinator(_operations, asyncOperations); // ACTION opManager.ExecuteAsync <TestOperationAsync>(); // ASSERT Assert.False(opManager.Context.Successful); Assert.NotEmpty(opManager.Context.Exceptions); Assert.IsType <OperationExecutionException>(opManager.Context.Exceptions[0]); Assert.Contains(typeof(TestOperationAsync), opManager.OperationsExecuted); }
public void Execute_HandlesExceptionThrownByOperation() { // ARRANGE var mockOperation = new Mock <IPipelineOperation <TestPipelineContext> >(); mockOperation .Setup(o => o.Dependencies) .Returns(new List <Type>()); mockOperation .Setup(o => o.Execute(It.IsAny <TestPipelineContext>())) .Throws <OperationExecutionException>(); var operations = new ReadOnlyDictionary <Type, IPipelineOperation <TestPipelineContext> >( new Dictionary <Type, IPipelineOperation <TestPipelineContext> > { { typeof(TestOperation), mockOperation.Object } } ); var opManager = new TestBasePipelineCoordinator(operations, _asyncOperations); // ACTION opManager.Execute <TestOperation>(); // ASSERT Assert.False(opManager.Context.Successful); Assert.NotEmpty(opManager.Context.Exceptions); Assert.IsType <OperationExecutionException>(opManager.Context.Exceptions[0]); Assert.Contains(typeof(TestOperation), opManager.OperationsExecuted); }
public void OperationTasks_Property_IsNotNull() { // ARRANGE / ACTION var opManager = new TestBasePipelineCoordinator(_operations, _asyncOperations); // ASSERT Assert.NotNull(opManager.OperationTasks); }
public void AddAsyncOperation_ThrowsArgExceptionOnNullContextParameter() { // ARRANGE var opManager = new TestBasePipelineCoordinator(_operations, _asyncOperations); // ACTION / ASSERT Assert.Throws <ArgumentException>(() => opManager.AddAsyncOperation <TestOperationAsync>(null)); }
public void Execute_ThrowsArgExceptionOnNullContextProperty() { // ARRANGE var opManager = new TestBasePipelineCoordinator(_operations, _asyncOperations); opManager.Context = null; // ACTION / ASSERT Assert.Throws <ArgumentException>(() => opManager.Execute <TestOperation>()); }
public void ExecuteAsync_ThrowsOpExceptionWhenOtherTasksArePending() { // ARRANGE var opManager = new TestBasePipelineCoordinator(_operations, _asyncOperations); var task = Task.CompletedTask; opManager.OperationTasks.Add(task); // ACTION / ASSERT Assert.Throws <OperationExecutionException>(() => opManager.ExecuteAsync <TestOperationAsync>()); }
public void WhenAll_DoesNothingWhenEndProcessingInContextIsTrue() { // ARRANGE var opManager = new TestBasePipelineCoordinator(_operations, _asyncOperations); opManager.Context.EndProcessing = true; // ACTION opManager.WhenAll(); // ASSERT Assert.True(opManager.Context.Successful); Assert.Empty(opManager.Context.Exceptions); Assert.Empty(opManager.OperationsExecuted); }
public void WhenAll_AwaitsPendingTasksInContextParameter() { // ARRANGE var mockOperation1 = new Mock <IPipelineOperationAsync <TestPipelineContext> >(); mockOperation1 .Setup(o => o.Dependencies) .Returns(new List <Type>()); mockOperation1 .Setup(o => o.ExecuteAsync()) .Returns(() => Task.CompletedTask); var mockOperation2 = new Mock <IPipelineOperationAsync <TestPipelineContext> >(); mockOperation2 .Setup(o => o.Dependencies) .Returns(new List <Type>()); mockOperation2 .Setup(o => o.ExecuteAsync()) .Returns(() => Task.CompletedTask); var asyncOperations = new ReadOnlyDictionary <Type, IPipelineOperationAsync <TestPipelineContext> >( new Dictionary <Type, IPipelineOperationAsync <TestPipelineContext> > { { typeof(TestDependencyOperationAsync), mockOperation1.Object }, { typeof(TestOperationAsync), mockOperation2.Object } } ); var context = new TestPipelineContext(); var opManager = new TestBasePipelineCoordinator(_operations, asyncOperations); // ACTION opManager .AddAsyncOperation <TestDependencyOperationAsync>(context) .AddAsyncOperation <TestOperationAsync>(context) .WhenAll(context); // ASSERT Assert.True(context.Successful); Assert.Empty(context.Exceptions); Assert.Contains(typeof(TestDependencyOperationAsync), opManager.OperationsExecuted); Assert.Contains(typeof(TestOperationAsync), opManager.OperationsExecuted); }
public void AddAsyncOperation_DoesNothingWhenEndProcessingInContextIsTrue() { // ARRANGE var opManager = new TestBasePipelineCoordinator(_operations, _asyncOperations); opManager.Context.EndProcessing = true; // ACTION opManager.AddAsyncOperation <TestDependencyOperationAsync>(); // ASSERT Assert.True(opManager.Context.Successful); Assert.Empty(opManager.Context.Exceptions); Assert.Empty(opManager.OperationsExecuted); Assert.Single(opManager.Context.ResultMessages); Assert.Contains("Not Executed", opManager.Context.ResultMessages[0]); }
public void AddAsyncOperation_ThrowsExceptionOnMissingDependency() { // ARRANGE var asyncOperations = new ReadOnlyDictionary <Type, IPipelineOperationAsync <TestPipelineContext> >( new Dictionary <Type, IPipelineOperationAsync <TestPipelineContext> > { { typeof(TestOperationAsync), new TestOperationAsync() } } ); var opManager = new TestBasePipelineCoordinator(_operations, asyncOperations); // ACTION opManager.AddAsyncOperation <TestOperationAsync>(); // ASSERT Assert.True(opManager.Context.EndProcessing); Assert.Single(opManager.Context.Exceptions); }
public void ExecuteAsync_RunsOperationSuccessfully() { // ARRANGE var asyncOperations = new ReadOnlyDictionary <Type, IPipelineOperationAsync <TestPipelineContext> >( new Dictionary <Type, IPipelineOperationAsync <TestPipelineContext> > { { typeof(TestDependencyOperationAsync), new TestDependencyOperationAsync() } } ); var opManager = new TestBasePipelineCoordinator(_operations, asyncOperations); // ACTION opManager.ExecuteAsync <TestDependencyOperationAsync>(); // ASSERT Assert.True(opManager.Context.Successful); Assert.Empty(opManager.Context.Exceptions); Assert.Contains(typeof(TestDependencyOperationAsync), opManager.OperationsExecuted); }
public void Execute_ThrowsExceptionOnMissingDependency() { // ARRANGE var testOperation = new TestOperation(); var operations = new ReadOnlyDictionary <Type, IPipelineOperation <TestPipelineContext> >( new Dictionary <Type, IPipelineOperation <TestPipelineContext> > { { typeof(TestOperation), testOperation } } ); var opManager = new TestBasePipelineCoordinator(operations, _asyncOperations); // ACTION opManager.Execute <TestOperation>(); // ASSERT Assert.True(opManager.Context.EndProcessing); Assert.Single(opManager.Context.Exceptions); }