public void Should_call_onFallback_with_independent_context_for_independent_calls() { Action fallbackAction = () => { }; IDictionary <Type, object> contextData = new Dictionary <Type, object>(); Action <Exception, Context> onFallback = (ex, ctx) => { contextData[ex.GetType()] = ctx["key"]; }; FallbackPolicy fallbackPolicy = Policy .Handle <ArgumentNullException>() .Or <DivideByZeroException>() .Fallback(fallbackAction, onFallback); fallbackPolicy.Invoking( p => p.Execute(() => { throw new ArgumentNullException(); }, new { key = "value1" }.AsDictionary())) .ShouldNotThrow(); fallbackPolicy.Invoking( p => p.Execute(() => { throw new DivideByZeroException(); }, new { key = "value2" }.AsDictionary())) .ShouldNotThrow(); contextData.Count.Should().Be(2); contextData.Keys.Should().Contain(typeof(ArgumentNullException)); contextData.Keys.Should().Contain(typeof(DivideByZeroException)); contextData[typeof(ArgumentNullException)].Should().Be("value1"); contextData[typeof(DivideByZeroException)].Should().Be("value2"); }
public void Should_report_unhandled_fault_and_not_execute_fallback_if_action_execution_raises_unhandled_fault_and_user_delegate_does_not_observe_the_set_cancellationtoken() { bool fallbackActionExecuted = false; Action fallbackAction = () => { fallbackActionExecuted = true; }; FallbackPolicy policy = Policy .Handle <DivideByZeroException>() .Fallback(fallbackAction); CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); CancellationToken cancellationToken = cancellationTokenSource.Token; int attemptsInvoked = 0; Action onExecute = () => attemptsInvoked++; Scenario scenario = new Scenario { NumberOfTimesToRaiseException = 1, AttemptDuringWhichToCancel = 1, ActionObservesCancellation = false }; policy.Invoking(x => x.RaiseExceptionAndOrCancellation <NullReferenceException>(scenario, cancellationTokenSource, onExecute)) .ShouldThrow <NullReferenceException>(); attemptsInvoked.Should().Be(1); fallbackActionExecuted.Should().BeFalse(); }
public void Should_report_cancellation_and_not_execute_fallback_during_otherwise_non_faulting_action_execution_when_user_delegate_observes_cancellationtoken_and_fallback_does_not_handle_cancellations() { bool fallbackActionExecuted = false; Action fallbackAction = () => { fallbackActionExecuted = true; }; FallbackPolicy policy = Policy .Handle <DivideByZeroException>() .Fallback(fallbackAction); CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); CancellationToken cancellationToken = cancellationTokenSource.Token; int attemptsInvoked = 0; Action onExecute = () => attemptsInvoked++; Scenario scenario = new Scenario { NumberOfTimesToRaiseException = 0, AttemptDuringWhichToCancel = 1, ActionObservesCancellation = true }; policy.Invoking(x => x.RaiseExceptionAndOrCancellation <DivideByZeroException>(scenario, cancellationTokenSource, onExecute)) .ShouldThrow <OperationCanceledException>() .And.CancellationToken.Should().Be(cancellationToken); attemptsInvoked.Should().Be(1); fallbackActionExecuted.Should().BeFalse(); }
public void Should_not_execute_action_when_cancellationtoken_cancelled_before_execute() { bool fallbackActionExecuted = false; Action fallbackAction = () => { fallbackActionExecuted = true; }; FallbackPolicy policy = Policy .Handle <DivideByZeroException>() .Fallback(fallbackAction); CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); CancellationToken cancellationToken = cancellationTokenSource.Token; int attemptsInvoked = 0; Action onExecute = () => attemptsInvoked++; Scenario scenario = new Scenario { NumberOfTimesToRaiseException = 1, AttemptDuringWhichToCancel = null, // Cancellation token cancelled manually below - before any scenario execution. }; cancellationTokenSource.Cancel(); policy.Invoking(x => x.RaiseExceptionAndOrCancellation <DivideByZeroException>(scenario, cancellationTokenSource, onExecute)) .ShouldThrow <OperationCanceledException>() .And.CancellationToken.Should().Be(cancellationToken); attemptsInvoked.Should().Be(0); fallbackActionExecuted.Should().BeFalse(); }
public void Should_execute_action_when_non_faulting_and_cancellationtoken_not_cancelled() { bool fallbackActionExecuted = false; Action fallbackAction = () => { fallbackActionExecuted = true; }; FallbackPolicy policy = Policy .Handle <DivideByZeroException>() .Fallback(fallbackAction); CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); CancellationToken cancellationToken = cancellationTokenSource.Token; int attemptsInvoked = 0; Action onExecute = () => attemptsInvoked++; Scenario scenario = new Scenario { NumberOfTimesToRaiseException = 0, AttemptDuringWhichToCancel = null, }; policy.Invoking(x => x.RaiseExceptionAndOrCancellation <DivideByZeroException>(scenario, cancellationTokenSource, onExecute)) .ShouldNotThrow(); attemptsInvoked.Should().Be(1); fallbackActionExecuted.Should().BeFalse(); }
public void Should_not_execute_action_when_cancellationtoken_cancelled_before_execute() { bool fallbackActionExecuted = false; Func <ResultPrimitive> fallbackAction = () => { fallbackActionExecuted = true; return(ResultPrimitive.Substitute); }; FallbackPolicy <ResultPrimitive> policy = Policy .HandleResult(ResultPrimitive.Fault) .OrResult(ResultPrimitive.FaultAgain) .Fallback(fallbackAction); CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); CancellationToken cancellationToken = cancellationTokenSource.Token; int attemptsInvoked = 0; Action onExecute = () => attemptsInvoked++; Scenario scenario = new Scenario { AttemptDuringWhichToCancel = null, // Cancellation token cancelled manually below - before any scenario execution. }; cancellationTokenSource.Cancel(); policy.Invoking(x => x.RaiseResultSequenceAndOrCancellation(scenario, cancellationTokenSource, onExecute, ResultPrimitive.Fault)) .ShouldThrow <OperationCanceledException>() .And.CancellationToken.Should().Be(cancellationToken); attemptsInvoked.Should().Be(0); fallbackActionExecuted.Should().BeFalse(); }
public void Should_handle_handled_fault_and_execute_fallback_following_faulting_action_execution_when_user_delegate_does_not_observe_cancellationtoken() { bool fallbackActionExecuted = false; Action fallbackAction = () => { fallbackActionExecuted = true; }; CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); CancellationToken cancellationToken = cancellationTokenSource.Token; FallbackPolicy policy = Policy .Handle <DivideByZeroException>() .Fallback(fallbackAction); int attemptsInvoked = 0; Action onExecute = () => attemptsInvoked++; Scenario scenario = new Scenario { NumberOfTimesToRaiseException = 1, AttemptDuringWhichToCancel = 1, ActionObservesCancellation = false }; policy.Invoking(x => x.RaiseExceptionAndOrCancellation <DivideByZeroException>(scenario, cancellationTokenSource, onExecute)) .ShouldNotThrow(); attemptsInvoked.Should().Be(1); fallbackActionExecuted.Should().BeTrue(); }
public void Should_report_cancellation_and_not_execute_fallback_during_otherwise_non_faulting_action_execution_when_user_delegate_observes_cancellationtoken_and_fallback_does_not_handle_cancellations() { bool fallbackActionExecuted = false; Func <ResultPrimitive> fallbackAction = () => { fallbackActionExecuted = true; return(ResultPrimitive.Substitute); }; FallbackPolicy <ResultPrimitive> policy = Policy .HandleResult(ResultPrimitive.Fault) .OrResult(ResultPrimitive.FaultAgain) .Fallback(fallbackAction); CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); CancellationToken cancellationToken = cancellationTokenSource.Token; int attemptsInvoked = 0; Action onExecute = () => attemptsInvoked++; Scenario scenario = new Scenario { AttemptDuringWhichToCancel = 1, ActionObservesCancellation = true }; policy.Invoking(x => x.RaiseResultSequenceAndOrCancellation(scenario, cancellationTokenSource, onExecute, ResultPrimitive.Good)) .ShouldThrow <OperationCanceledException>() .And.CancellationToken.Should().Be(cancellationToken); attemptsInvoked.Should().Be(1); fallbackActionExecuted.Should().BeFalse(); }
public void Should_execute_fallback_when_exception_thrown_matches_handling_predicates() { bool fallbackActionExecuted = false; Action fallbackAction = () => { fallbackActionExecuted = true; }; FallbackPolicy fallbackPolicy = Policy .Handle <DivideByZeroException>(e => true) .Fallback(fallbackAction); fallbackPolicy.Invoking(x => x.RaiseException <DivideByZeroException>()).ShouldNotThrow(); fallbackActionExecuted.Should().BeTrue(); }
public void Should_execute_fallback_when_execute_delegate_throws_exception_handled_by_policy() { bool fallbackActionExecuted = false; Action fallbackAction = () => { fallbackActionExecuted = true; }; FallbackPolicy fallbackPolicy = Policy .Handle <DivideByZeroException>() .Fallback(fallbackAction); fallbackPolicy.Invoking(x => x.RaiseException <DivideByZeroException>()).ShouldNotThrow(); fallbackActionExecuted.Should().BeTrue(); }
public void Should_not_execute_fallback_when_exception_thrown_does_not_match_any_of_handling_predicates() { bool fallbackActionExecuted = false; Action fallbackAction = () => { fallbackActionExecuted = true; }; FallbackPolicy fallbackPolicy = Policy .Handle <DivideByZeroException>(e => false) .Or <ArgumentNullException>(e => false) .Fallback(fallbackAction); fallbackPolicy.Invoking(x => x.RaiseException <DivideByZeroException>()).ShouldThrow <DivideByZeroException>(); fallbackActionExecuted.Should().BeFalse(); }
public void Should_not_execute_fallback_when_execute_delegate_throws_exception_not_one_of_exceptions_handled_by_policy() { bool fallbackActionExecuted = false; Action fallbackAction = () => { fallbackActionExecuted = true; }; FallbackPolicy fallbackPolicy = Policy .Handle <DivideByZeroException>() .Or <NullReferenceException>() .Fallback(fallbackAction); fallbackPolicy.Invoking(x => x.RaiseException <ArgumentNullException>()).ShouldThrow <ArgumentNullException>(); fallbackActionExecuted.Should().BeFalse(); }
public void Should_call_fallbackAction_with_the_exception_when_execute_and_capture() { Exception fallbackException = null; Action <Exception, Context, CancellationToken> fallbackAction = (ex, ctx, ct) => { fallbackException = ex; }; Action <Exception, Context> onFallback = (ex, ctx) => { }; FallbackPolicy fallbackPolicy = Policy .Handle <ArgumentNullException>() .Fallback(fallbackAction, onFallback); fallbackPolicy.Invoking(p => p.ExecuteAndCapture(() => { throw new ArgumentNullException(); })) .ShouldNotThrow(); fallbackException.Should().NotBeNull() .And.BeOfType(typeof(ArgumentNullException)); }
public void Should_not_call_fallbackAction_with_the_exception_if_exception_unhandled() { Exception fallbackException = null; Action <Exception, Context, CancellationToken> fallbackAction = (ex, ctx, ct) => { fallbackException = ex; }; Action <Exception, Context> onFallback = (ex, ctx) => { }; FallbackPolicy fallbackPolicy = Policy .Handle <DivideByZeroException>() .Fallback(fallbackAction, onFallback); fallbackPolicy.Invoking(p => p.Execute(() => { throw new ArgumentNullException(); })) .ShouldThrow <ArgumentNullException>(); fallbackException.Should().BeNull(); }
public void Should_call_fallbackAction_with_the_exception() { Exception fallbackException = null; Action <Exception, Context, CancellationToken> fallbackAction = (ex, ctx, ct) => { fallbackException = ex; }; Action <Exception, Context> onFallback = (ex, ctx) => { }; FallbackPolicy fallbackPolicy = Policy .Handle <ArgumentNullException>() .Fallback(fallbackAction, onFallback); Exception instanceToThrow = new ArgumentNullException("myParam"); fallbackPolicy.Invoking(p => p.RaiseException(instanceToThrow)) .ShouldNotThrow(); fallbackException.Should().Be(instanceToThrow); }
public void Should_call_onFallback_with_the_passed_context_when_execute_and_capture() { Action fallbackAction = () => { }; IDictionary <string, object> contextData = null; Action <Exception, Context> onFallback = (ex, ctx) => { contextData = ctx; }; FallbackPolicy fallbackPolicy = Policy .Handle <ArgumentNullException>() .Fallback(fallbackAction, onFallback); fallbackPolicy.Invoking(p => p.ExecuteAndCapture(() => { throw new ArgumentNullException(); }, new { key1 = "value1", key2 = "value2" }.AsDictionary())) .ShouldNotThrow(); contextData.Should() .ContainKeys("key1", "key2").And .ContainValues("value1", "value2"); }
public void Should_not_handle_exception_thrown_by_fallback_delegate_even_if_is_exception_handled_by_policy() { bool fallbackActionExecuted = false; Action fallbackAction = () => { fallbackActionExecuted = true; throw new DivideByZeroException() { HelpLink = "FromFallbackAction" }; }; FallbackPolicy fallbackPolicy = Policy .Handle <DivideByZeroException>() .Fallback(fallbackAction); fallbackPolicy.Invoking(x => x.RaiseException <DivideByZeroException>((e, i) => e.HelpLink = "FromExecuteDelegate")) .ShouldThrow <DivideByZeroException>().And.HelpLink.Should().Be("FromFallbackAction"); fallbackActionExecuted.Should().BeTrue(); }