public async Task Outermost_policy_not_handling_exception_even_if_inner_policies_do_should_report_as_unhandled_exception() { CircuitBreakerPolicy innerHandlingDBZE = Policy .Handle <DivideByZeroException>() .CircuitBreakerAsync(1, TimeSpan.Zero); CircuitBreakerPolicy outerHandlingANE = Policy .Handle <ArgumentNullException>() .CircuitBreakerAsync(1, TimeSpan.Zero); PolicyWrap wrap = outerHandlingANE.WrapAsync(innerHandlingDBZE); PolicyResult executeAndCaptureResultOnPolicyWrap = await wrap.ExecuteAndCaptureAsync(() => { throw new DivideByZeroException(); }); executeAndCaptureResultOnPolicyWrap.Outcome.Should().Be(OutcomeType.Failure); executeAndCaptureResultOnPolicyWrap.FinalException.Should().BeOfType <DivideByZeroException>(); executeAndCaptureResultOnPolicyWrap.ExceptionType.Should().Be(ExceptionType.Unhandled); }
public async Task Outermost_generic_policy_not_handling_result_even_if_inner_policies_do_should_not_report_as_handled() { CircuitBreakerPolicy <ResultPrimitive> innerHandlingFaultAgain = Policy .HandleResult(ResultPrimitive.FaultAgain) .CircuitBreakerAsync(1, TimeSpan.Zero); CircuitBreakerPolicy <ResultPrimitive> outerHandlingFault = Policy .HandleResult(ResultPrimitive.Fault) .CircuitBreakerAsync(1, TimeSpan.Zero); PolicyWrap <ResultPrimitive> wrap = outerHandlingFault.WrapAsync(innerHandlingFaultAgain); PolicyResult <ResultPrimitive> executeAndCaptureResultOnPolicyWrap = await wrap.ExecuteAndCaptureAsync(() => TaskHelper.FromResult(ResultPrimitive.FaultAgain)); executeAndCaptureResultOnPolicyWrap.Outcome.Should().Be(OutcomeType.Successful); executeAndCaptureResultOnPolicyWrap.FinalHandledResult.Should().Be(default(ResultPrimitive)); executeAndCaptureResultOnPolicyWrap.FaultType.Should().BeNull(); executeAndCaptureResultOnPolicyWrap.FinalException.Should().BeNull(); executeAndCaptureResultOnPolicyWrap.ExceptionType.Should().BeNull(); }
public async Task Outermost_generic_policy_handling_result_should_report_as_PolicyWrap_handled_result() { CircuitBreakerPolicy <ResultPrimitive> innerHandlingFaultAgain = Policy .HandleResult(ResultPrimitive.FaultAgain) .CircuitBreakerAsync(1, TimeSpan.Zero); CircuitBreakerPolicy <ResultPrimitive> outerHandlingFault = Policy .HandleResult(ResultPrimitive.Fault) .CircuitBreakerAsync(1, TimeSpan.Zero); PolicyWrap <ResultPrimitive> wrap = outerHandlingFault.WrapAsync(innerHandlingFaultAgain); PolicyResult <ResultPrimitive> executeAndCaptureResultOnPolicyWrap = await wrap.ExecuteAndCaptureAsync(() => TaskHelper.FromResult(ResultPrimitive.Fault)); executeAndCaptureResultOnPolicyWrap.Outcome.Should().Be(OutcomeType.Failure); executeAndCaptureResultOnPolicyWrap.FaultType.Should().Be(FaultType.ResultHandledByThisPolicy); executeAndCaptureResultOnPolicyWrap.FinalHandledResult.Should().Be(ResultPrimitive.Fault); executeAndCaptureResultOnPolicyWrap.FinalException.Should().BeNull(); executeAndCaptureResultOnPolicyWrap.ExceptionType.Should().BeNull(); }
public async Task Outermost_generic_policy_handling_exception_should_report_as_PolicyWrap_handled_exception() { CircuitBreakerPolicy <ResultPrimitive> innerHandlingDBZE = Policy <ResultPrimitive> .Handle <DivideByZeroException>() .CircuitBreakerAsync(1, TimeSpan.Zero); CircuitBreakerPolicy <ResultPrimitive> outerHandlingANE = Policy <ResultPrimitive> .Handle <ArgumentNullException>() .CircuitBreakerAsync(1, TimeSpan.Zero); PolicyWrap <ResultPrimitive> wrap = outerHandlingANE.WrapAsync(innerHandlingDBZE); PolicyResult <ResultPrimitive> executeAndCaptureResultOnPolicyWrap = await wrap.ExecuteAndCaptureAsync(() => { throw new ArgumentNullException(); }); executeAndCaptureResultOnPolicyWrap.Outcome.Should().Be(OutcomeType.Failure); executeAndCaptureResultOnPolicyWrap.FinalException.Should().BeOfType <ArgumentNullException>(); executeAndCaptureResultOnPolicyWrap.ExceptionType.Should().Be(ExceptionType.HandledByThisPolicy); executeAndCaptureResultOnPolicyWrap.FaultType.Should().Be(FaultType.ExceptionHandledByThisPolicy); }
public async Task Wrapping_two_generic_policies_by_instance_syntax_and_executing_should_wrap_outer_then_inner_around_delegate() { RetryPolicy <ResultPrimitive> retry = Policy.HandleResult(ResultPrimitive.Fault).RetryAsync(1); // Two tries in total: first try, plus one retry. CircuitBreakerPolicy <ResultPrimitive> breaker = Policy.HandleResult(ResultPrimitive.Fault).CircuitBreakerAsync(2, TimeSpan.MaxValue); var retryWrappingBreaker = retry.WrapAsync(breaker); var breakerWrappingRetry = breaker.WrapAsync(retry); // When the retry wraps the breaker, the retry (being outer) should cause the call to be put through the breaker twice - causing the breaker to break. breaker.Reset(); (await retryWrappingBreaker.RaiseResultSequenceAsync(ResultPrimitive.Fault, ResultPrimitive.Fault).ConfigureAwait(false)) .Should().Be(ResultPrimitive.Fault); breaker.CircuitState.Should().Be(CircuitState.Open); // When the breaker wraps the retry, the retry (being inner) should retry twice before throwing the exception back on the breaker - the exception only hits the breaker once - so the breaker should not break. breaker.Reset(); (await breakerWrappingRetry.RaiseResultSequenceAsync(ResultPrimitive.Fault, ResultPrimitive.Fault).ConfigureAwait(false)) .Should().Be(ResultPrimitive.Fault); breaker.CircuitState.Should().Be(CircuitState.Closed); }
public void Wrapping_two_policies_by_instance_syntax_and_executing_should_wrap_outer_then_inner_around_delegate() { RetryPolicy retry = Policy.Handle <Exception>().RetryAsync(1); // Two tries in total: first try, plus one retry. CircuitBreakerPolicy breaker = Policy.Handle <Exception>().CircuitBreakerAsync(2, TimeSpan.MaxValue); PolicyWrap retryWrappingBreaker = retry.WrapAsync(breaker); PolicyWrap breakerWrappingRetry = breaker.WrapAsync(retry); // When the retry wraps the breaker, the retry (being outer) should cause the call to be put through the breaker twice - causing the breaker to break. breaker.Reset(); retryWrappingBreaker.Awaiting(async x => await x.RaiseExceptionAsync <DivideByZeroException>(2)) .ShouldThrow <DivideByZeroException>(); breaker.CircuitState.Should().Be(CircuitState.Open); // When the breaker wraps the retry, the retry (being inner) should retry twice before throwing the exception back on the breaker - the exception only hits the breaker once - so the breaker should not break. breaker.Reset(); breakerWrappingRetry.Awaiting(async x => await x.RaiseExceptionAsync <DivideByZeroException>(2)) .ShouldThrow <DivideByZeroException>(); breaker.CircuitState.Should().Be(CircuitState.Closed); }