public void Should_throw_for_generic_method_execution_on_non_generic_policy() { FallbackPolicy fallbackPolicy = Policy .Handle <DivideByZeroException>() .FallbackAsync(_ => TaskHelper.EmptyTask); fallbackPolicy.Awaiting(p => p.ExecuteAsync <int>(() => TaskHelper.FromResult(0))).ShouldThrow <InvalidOperationException>(); }
public void Should_execute_fallback_when_exception_thrown_matches_handling_predicates() { bool fallbackActionExecuted = false; Func <CancellationToken, Task> fallbackActionAsync = _ => { fallbackActionExecuted = true; return(TaskHelper.EmptyTask); }; FallbackPolicy fallbackPolicy = Policy .Handle <DivideByZeroException>(e => true) .FallbackAsync(fallbackActionAsync); fallbackPolicy.Awaiting(async x => await x.RaiseExceptionAsync <DivideByZeroException>()).ShouldNotThrow(); fallbackActionExecuted.Should().BeTrue(); }
public void Should_not_execute_fallback_when_execute_delegate_throws_exception_not_handled_by_policy() { bool fallbackActionExecuted = false; Func <CancellationToken, Task> fallbackActionAsync = _ => { fallbackActionExecuted = true; return(TaskHelper.EmptyTask); }; FallbackPolicy fallbackPolicy = Policy .Handle <DivideByZeroException>() .FallbackAsync(fallbackActionAsync); fallbackPolicy.Awaiting(async x => await x.RaiseExceptionAsync <ArgumentNullException>()).ShouldThrow <ArgumentNullException>(); fallbackActionExecuted.Should().BeFalse(); }
public void Should_not_call_fallbackAction_with_the_exception_if_exception_unhandled() { Exception fallbackException = null; Func <Exception, Context, CancellationToken, Task> fallbackFunc = (ex, ctx, ct) => { fallbackException = ex; return(TaskHelper.EmptyTask); }; Func <Exception, Context, Task> onFallback = (ex, ctx) => { return(TaskHelper.EmptyTask); }; FallbackPolicy fallbackPolicy = Policy .Handle <DivideByZeroException>() .FallbackAsync(fallbackFunc, onFallback); fallbackPolicy.Awaiting(async p => await p.ExecuteAsync(() => { throw new ArgumentNullException(); })) .ShouldThrow <ArgumentNullException>(); fallbackException.Should().BeNull(); }
public void Should_call_fallbackAction_with_the_exception_when_execute_and_capture() { Exception fallbackException = null; Func <Exception, Context, CancellationToken, Task> fallbackFunc = (ex, ctx, ct) => { fallbackException = ex; return(TaskHelper.EmptyTask); }; Func <Exception, Context, Task> onFallback = (ex, ctx) => { return(TaskHelper.EmptyTask); }; FallbackPolicy fallbackPolicy = Policy .Handle <ArgumentNullException>() .FallbackAsync(fallbackFunc, onFallback); fallbackPolicy.Awaiting(async p => await p.ExecuteAndCaptureAsync(() => { throw new ArgumentNullException(); })) .ShouldNotThrow(); fallbackException.Should().NotBeNull() .And.BeOfType(typeof(ArgumentNullException)); }
public void Should_call_fallbackAction_with_the_exception() { Exception fallbackException = null; Func <Exception, Context, CancellationToken, Task> fallbackFunc = (ex, ctx, ct) => { fallbackException = ex; return(TaskHelper.EmptyTask); }; Func <Exception, Context, Task> onFallback = (ex, ctx) => { return(TaskHelper.EmptyTask); }; FallbackPolicy fallbackPolicy = Policy .Handle <ArgumentNullException>() .FallbackAsync(fallbackFunc, onFallback); Exception instanceToThrow = new ArgumentNullException("myParam"); fallbackPolicy.Awaiting(p => p.RaiseExceptionAsync(instanceToThrow)) .ShouldNotThrow(); fallbackException.Should().Be(instanceToThrow); }
public void Should_call_fallbackAction_with_the_passed_context_when_execute_and_capture() { IDictionary <string, object> contextData = null; Func <Context, CancellationToken, Task <ResultPrimitive> > fallbackActionAsync = (ctx, ct) => { contextData = ctx; return(Task.FromResult(ResultPrimitive.Substitute)); }; Func <Exception, Context, Task> onFallbackAsync = (ex, ctx) => TaskHelper.EmptyTask; FallbackPolicy fallbackPolicy = Policy .Handle <ArgumentNullException>() .FallbackAsync(fallbackActionAsync, onFallbackAsync); fallbackPolicy.Awaiting(async p => await p.ExecuteAndCaptureAsync(ctx => { throw new ArgumentNullException(); }, new { key1 = "value1", key2 = "value2" }.AsDictionary())) .ShouldNotThrow(); contextData.Should() .ContainKeys("key1", "key2").And .ContainValues("value1", "value2"); }
public void Should_call_onFallback_with_the_passed_context() { Func <Context, CancellationToken, Task> fallbackActionAsync = (_, __) => TaskHelper.EmptyTask; IDictionary <string, object> contextData = null; Func <Exception, Context, Task> onFallbackAsync = (ex, ctx) => { contextData = ctx; return(TaskHelper.EmptyTask); }; FallbackPolicy fallbackPolicy = Policy .Handle <ArgumentNullException>() .FallbackAsync(fallbackActionAsync, onFallbackAsync); fallbackPolicy.Awaiting(async p => await p.ExecuteAsync(() => { 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; Func <CancellationToken, Task> fallbackActionAsync = _ => { fallbackActionExecuted = true; throw new DivideByZeroException() { HelpLink = "FromFallbackAction" }; }; FallbackPolicy fallbackPolicy = Policy .Handle <DivideByZeroException>() .FallbackAsync(fallbackActionAsync); fallbackPolicy.Awaiting(async x => await x.RaiseExceptionAsync <DivideByZeroException>((e, i) => e.HelpLink = "FromExecuteDelegate")) .ShouldThrow <DivideByZeroException>().And.HelpLink.Should().Be("FromFallbackAction"); fallbackActionExecuted.Should().BeTrue(); }