public async Task Specified_Action_Is_Executed_Once_Breaker_Duration_Has_Expired_On_Open_Breaker()
{
// Arrange
const int exceptionsAllowedBeforeBreaking = 5;
var breakDuration = TimeSpan.FromSeconds(1);
var configuration = new PollyCircuitBreakerConfiguration
{
ExceptionsAllowedBeforeBreaking = exceptionsAllowedBeforeBreaking,
DurationOfBreak = breakDuration
};
var testCircuitBreaker = new PollyCircuitBreaker(configuration);
OpenCircuitBreaker(_circuitBreaker);
var testActionExecuted = false;
Task TestAction(CancellationToken token)
{
testActionExecuted = true;
return(Task.CompletedTask);
}
// Act
Thread.Sleep(breakDuration);
await testCircuitBreaker.ExecuteAsync(TestAction, exception => Task.CompletedTask, _cts.Token);
// Assert
Assert.That(testActionExecuted, Is.True);
}
public async Task OnReset_Event_Is_Raised_When_ExecuteAction_Completes_Successfully_After_Break_Duration_Has_Expired()
{
// Arrange
const int exceptionsAllowedThreshold = 1;
TimeSpan breakDuration = TimeSpan.FromSeconds(1);
var configuration = new PollyCircuitBreakerConfiguration
{
ExceptionsAllowedBeforeBreaking = exceptionsAllowedThreshold,
DurationOfBreak = breakDuration
};
var circuitResetEventTriggered = false;
var circuitBreaker = new PollyCircuitBreaker(configuration);
circuitBreaker.CircuitBreakerReset += (sender, args) => circuitResetEventTriggered = true;
// Act
await ThrowExceptionsInCircuitBreaker(circuitBreaker, numberOfExceptions : exceptionsAllowedThreshold);
Thread.Sleep(breakDuration);
await circuitBreaker.ExecuteAsync(
token => Task.CompletedTask,
exception => Task.CompletedTask,
_cts.Token);
// Assert
Assert.That(circuitResetEventTriggered, Is.True, "the Circuit Breaker Reset Event should be triggered");
}
public async Task Circuit_Breaker_Runs_FailureAction_When_Exception_Occurs_In_Specified_Action()
{
// Arrange
var allowedExceptionCount = 2;
var breakerDuration = TimeSpan.FromSeconds(2);
Task TestAction(CancellationToken token)
{
throw new ApplicationException();
}
Exception receivedException = null;
Task TestFailureAction(Exception ex)
{
receivedException = ex;
return(Task.CompletedTask);
}
var configuration = new PollyCircuitBreakerConfiguration
{
ExceptionsAllowedBeforeBreaking = allowedExceptionCount,
DurationOfBreak = breakerDuration
};
var testCircuitBreaker = new PollyCircuitBreaker(configuration);
// Act
await testCircuitBreaker.ExecuteAsync(TestAction, TestFailureAction, _cts.Token);
// Assert
Assert.That(receivedException, Is.Not.Null);
Assert.That(receivedException, Is.TypeOf <ApplicationException>());
}
public void should_call_a_500_page_twice_then_break_the_circuit()
{
var sut = new PollyCircuitBreaker(2, 3);
var exceptions = 0;
for (int i = 0; i < 2; i++)
{
try
{
sut.Execute(Do("http://httpstat.us/500"));
}
catch (Exception)
{
exceptions++;
}
}
try
{
sut.Execute(Do("http://httpstat.us/500"));
}
catch (Exception ex)
{
this.exception = ex;
}
Assert.AreEqual(2, exceptions);
this.mock.Verify(x => x.Bar(), Times.Exactly(2));
if (this.exception != null)
{
throw this.exception;
}
}
public void should_successfully_call_a_200_page_through_the_breaker()
{
var sut = new PollyCircuitBreaker(2, 3);
sut.Execute(Do("http://httpstat.us/200"));
this.mock.Verify(x => x.Bar(), Times.Once);
}
public void Default_Constructor()
{
// Act
var circuitBreaker = new PollyCircuitBreaker();
// Assert
Assert.That(circuitBreaker, Is.Not.Null);
}
public void Separate_Configuration_Item_Constructor()
{
// arrange
const int testNumberOfPermittedExceptions = 5;
var testBreakerDuration = TimeSpan.FromSeconds(1);
var configuration = new PollyCircuitBreakerConfiguration
{
ExceptionsAllowedBeforeBreaking = testNumberOfPermittedExceptions,
DurationOfBreak = testBreakerDuration
};
// Act
var circuitBreaker = new PollyCircuitBreaker(configuration);
// Assert
Assert.That(circuitBreaker, Is.Not.Null);
}
public void should_reset_the_breaker_after_3s()
{
var sut = new PollyCircuitBreaker(2, 3);
for (int i = 0; i < 2; i++)
{
try
{
sut.Execute(Do("http://httpstat.us/500"));
}
catch (Exception)
{
}
}
Thread.Sleep(TimeSpan.FromSeconds(3));
sut.Execute(Do("http://httpstat.us/200"));
this.mock.Verify(x => x.Bar(), Times.Exactly(3));
}
public async Task OnBreak_Event_Is_Raised_When_Circuit_Breaker_Opens()
{
// Arrange
const int exceptionsAllowedThreshold = 1;
var breakDuration = TimeSpan.FromSeconds(1);
var circuitOpenEventTriggered = false;
var configuration = new PollyCircuitBreakerConfiguration
{
ExceptionsAllowedBeforeBreaking = exceptionsAllowedThreshold,
DurationOfBreak = breakDuration
};
var circuitBreaker = new PollyCircuitBreaker(configuration);
circuitBreaker.CircuitBreakerOpened += (sender, args) => circuitOpenEventTriggered = true;
// Act
await ThrowExceptionsInCircuitBreaker(circuitBreaker, numberOfExceptions : exceptionsAllowedThreshold);
// Assert
Assert.That(circuitOpenEventTriggered, Is.True, "the circuit open event should be triggered");
}
