public async Task Should_return_fallback_value_when_executed_delegate_raises_fault_handled_by_policy() { FallbackPolicy <ResultPrimitive> fallbackPolicy = Policy .HandleResult(ResultPrimitive.Fault) .FallbackAsync(ResultPrimitive.Substitute); (await fallbackPolicy.RaiseResultSequenceAsync(ResultPrimitive.Fault).ConfigureAwait(false)) .Should().Be(ResultPrimitive.Substitute); }
public async Task Should_execute_fallback_when_result_raised_matches_handling_predicates() { bool fallbackActionExecuted = false; Func <CancellationToken, Task <ResultPrimitive> > fallbackAction = ct => { fallbackActionExecuted = true; return(Task.FromResult(ResultPrimitive.Substitute)); }; FallbackPolicy <ResultPrimitive> fallbackPolicy = Policy .HandleResult <ResultPrimitive>(r => true) .FallbackAsync(fallbackAction); (await fallbackPolicy.RaiseResultSequenceAsync(ResultPrimitive.Undefined).ConfigureAwait(false)) .Should().Be(ResultPrimitive.Substitute); fallbackActionExecuted.Should().BeTrue(); }
public async Task Should_execute_fallback_when_executed_delegate_raises_fault_handled_by_policy() { bool fallbackActionExecuted = false; Func <CancellationToken, Task <ResultPrimitive> > fallbackAction = ct => { fallbackActionExecuted = true; return(Task.FromResult(ResultPrimitive.Substitute)); }; FallbackPolicy <ResultPrimitive> fallbackPolicy = Policy .HandleResult(ResultPrimitive.Fault) .FallbackAsync(fallbackAction); (await fallbackPolicy.RaiseResultSequenceAsync(ResultPrimitive.Fault).ConfigureAwait(false)) .Should().Be(ResultPrimitive.Substitute); fallbackActionExecuted.Should().BeTrue(); }
public async void Should_not_execute_fallback_when_execute_delegate_raises_fault_not_handled_by_any_of_predicates() { bool fallbackActionExecuted = false; Func <CancellationToken, Task <ResultPrimitive> > fallbackAction = ct => { fallbackActionExecuted = true; return(Task.FromResult(ResultPrimitive.Substitute)); }; FallbackPolicy <ResultPrimitive> fallbackPolicy = Policy .HandleResult <ResultPrimitive>(r => r == ResultPrimitive.Fault) .OrResult(r => r == ResultPrimitive.FaultAgain) .FallbackAsync(fallbackAction); (await fallbackPolicy.RaiseResultSequenceAsync(ResultPrimitive.FaultYetAgain).ConfigureAwait(false)) .Should().Be(ResultPrimitive.FaultYetAgain); fallbackActionExecuted.Should().BeFalse(); }
public async Task Should_not_handle_result_raised_by_fallback_delegate_even_if_is_result_handled_by_policy() { bool fallbackActionExecuted = false; Func <CancellationToken, Task <ResultClass> > fallbackAction = ct => { fallbackActionExecuted = true; return(Task.FromResult(new ResultClass(ResultPrimitive.Fault, "FromFallbackAction"))); }; FallbackPolicy <ResultClass> fallbackPolicy = Policy .HandleResult <ResultClass>(r => r.ResultCode == ResultPrimitive.Fault) .FallbackAsync(fallbackAction); (await fallbackPolicy.RaiseResultSequenceAsync(new ResultClass(ResultPrimitive.Fault, "FromExecuteDelegate")).ConfigureAwait(false)) .Should().Match <ResultClass>(r => r.ResultCode == ResultPrimitive.Fault && r.SomeString == "FromFallbackAction"); fallbackActionExecuted.Should().BeTrue(); }
public async Task Context_should_be_empty_if_execute_not_called_with_any_context_data() { Context capturedContext = null; bool onFallbackExecuted = false; Func <Context, CancellationToken, Task <ResultPrimitive> > fallbackAction = (_, __) => Task.FromResult(ResultPrimitive.Substitute); Func <DelegateResult <ResultPrimitive>, Context, Task> onFallbackAsync = (ex, ctx) => { onFallbackExecuted = true; capturedContext = ctx; return(TaskHelper.EmptyTask); }; FallbackPolicy <ResultPrimitive> fallbackPolicy = Policy .HandleResult(ResultPrimitive.Fault) .OrResult(ResultPrimitive.FaultAgain) .FallbackAsync(fallbackAction, onFallbackAsync); (await fallbackPolicy.RaiseResultSequenceAsync(ResultPrimitive.Fault).ConfigureAwait(false)) .Should().Be(ResultPrimitive.Substitute); onFallbackExecuted.Should().BeTrue(); capturedContext.Should().BeEmpty(); }