public void Should_open_circuit_and_block_calls_if_manual_override_open()
{
var time = 1.January(2000);
SystemClock.UtcNow = () => time;
var durationOfBreak = TimeSpan.FromMinutes(1);
CircuitBreakerPolicy breaker = Policy
.Handle <DivideByZeroException>()
.CircuitBreaker(2, durationOfBreak);
breaker.CircuitState.Should().Be(CircuitState.Closed);
// manually break circuit
breaker.Isolate();
breaker.CircuitState.Should().Be(CircuitState.Isolated);
// circuit manually broken: execution should be blocked; even non-exception-throwing executions should not reset circuit
breaker.Invoking(x => x.Execute(() => { }))
.ShouldThrow <IsolatedCircuitException>();
breaker.CircuitState.Should().Be(CircuitState.Isolated);
}
public void Should_set_LastHandledResult_and_LastException_to_default_on_circuit_reset()
{
CircuitBreakerPolicy <ResultPrimitive> breaker = Policy
.Handle <DivideByZeroException>()
.OrResult(ResultPrimitive.Fault)
.CircuitBreaker(2, TimeSpan.FromMinutes(1));
breaker.Invoking(b => b.RaiseResultAndOrExceptionSequence(new DivideByZeroException()))
.ShouldThrow <DivideByZeroException>();
breaker.RaiseResultSequence(ResultPrimitive.Fault)
.Should().Be(ResultPrimitive.Fault);
breaker.CircuitState.Should().Be(CircuitState.Open);
breaker.LastHandledResult.Should().Be(ResultPrimitive.Fault);
breaker.LastException.Should().BeNull();
breaker.Reset();
breaker.LastHandledResult.Should().Be(default(ResultPrimitive));
breaker.LastException.Should().BeNull();
}
public void Should_call_onbreak_with_the_last_raised_exception()
{
Exception lastException = null;
Action <DelegateResult <ResultPrimitive>, TimeSpan, Context> onBreak = (outcome, _, __) => { lastException = outcome.Exception; };
Action <Context> onReset = _ => { };
TimeSpan durationOfBreak = TimeSpan.FromMinutes(1);
CircuitBreakerPolicy <ResultPrimitive> breaker = Policy
.Handle <DivideByZeroException>()
.OrResult(ResultPrimitive.Fault)
.CircuitBreaker(2, durationOfBreak, onBreak, onReset);
breaker.RaiseResultSequence(ResultPrimitive.Fault)
.Should().Be(ResultPrimitive.Fault);
breaker.Invoking(b => b.RaiseResultAndOrExceptionSequence(new DivideByZeroException()))
.ShouldThrow <DivideByZeroException>();
breaker.CircuitState.Should().Be(CircuitState.Open);
lastException.Should().BeOfType <DivideByZeroException>();
}
public void Should_execute_action_when_non_faulting_and_cancellationtoken_not_cancelled()
{
var durationOfBreak = TimeSpan.FromMinutes(1);
CircuitBreakerPolicy breaker = Policy
.Handle <DivideByZeroException>()
.CircuitBreaker(2, durationOfBreak);
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;
int attemptsInvoked = 0;
Action onExecute = () => attemptsInvoked++;
PolicyExtensions.ExceptionAndOrCancellationScenario scenario = new PolicyExtensions.ExceptionAndOrCancellationScenario
{
NumberOfTimesToRaiseException = 0,
AttemptDuringWhichToCancel = null,
};
breaker.Invoking(x => x.RaiseExceptionAndOrCancellation <DivideByZeroException>(scenario, cancellationTokenSource, onExecute))
.ShouldNotThrow();
attemptsInvoked.Should().Be(1);
}
