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