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();
}