Fixes issue ReactiveX#6: The CB changes to OPEN state when the failure rate is above (>) the threshold, but it should be above or equal (>=).

Author: Robert Winkler

README.adoc

@@ -47,7 +47,7 @@ After the time duration has elapsed, the CircuitBreaker state changes from `OPEN
 
 == Usage guide
 
-See http://javaslang.github.io/javaslang-circuitbreaker/0.4.0/[User Guide].
+See http://javaslang.github.io/javaslang-circuitbreaker/0.5.0/[User Guide].
 
 == Companies who use javaslang-circuitbreaker
 

RELEASENOTES.adoc

@@ -45,5 +45,9 @@
 === Version 0.3.4
 * Added a Metrics interface to the CircuitBreaker which allows to retrieve current statistics like failureRate and number of buffer calls.
 
-== Version 0.40
-* Updated javaslang from 2.0.0-RC4 to 2.0.1
+== Version 0.4.0
+* Updated javaslang from 2.0.0-RC4 to 2.0.1
+
+== Version 0.5.0
+* Updated javaslang from 2.0.1 to 2.0.2
+* Fixed issue #6: The CB changes to OPEN state when the failure rate is above (>) the threshold, but it should be above or equal (>=).

build.gradle

@@ -29,7 +29,7 @@ apply plugin: 'org.ajoberstar.github-pages'
 
 group = 'io.github.robwin'
 description = 'A CircuitBreaker pattern implementation for Java 8 and functional programming.'
-version = '0.4.0'
+version = '0.5.0'
 
 tasks.withType(JavaCompile) {
     sourceCompatibility = "1.8"
@@ -60,7 +60,7 @@ jmh {
 }
 
 dependencies {
-    compile "io.javaslang:javaslang:2.0.1"
+    compile "io.javaslang:javaslang:2.0.2"
     compile "org.slf4j:slf4j-api:1.7.13"
     testCompile "io.dropwizard.metrics:metrics-core:3.1.2"
     testCompile "junit:junit:4.11"

src/main/java/javaslang/circuitbreaker/internal/ClosedState.java

@@ -58,7 +58,7 @@ void recordSuccess() {
      * @param currentFailureRate the current failure rate
      */
     private void checkFailureRate(float currentFailureRate) {
-        if (currentFailureRate > failureRateThreshold) {
+        if (currentFailureRate >= failureRateThreshold) {
             // Transition the state machine to OPEN state, because the failure rate is above the threshold
             stateMachine.transitionToOpenState(CircuitBreaker.StateTransition.CLOSED_TO_OPEN, circuitBreakerMetrics);
         }

src/main/java/javaslang/circuitbreaker/internal/HalfOpenState.java

@@ -62,7 +62,7 @@ void recordSuccess() {
      */
     private void checkFailureRate(float currentFailureRate) {
         if(currentFailureRate != -1){
-            if(currentFailureRate > failureRateThreshold) {
+            if(currentFailureRate >= failureRateThreshold) {
                 stateMachine.transitionToOpenState(CircuitBreaker.StateTransition.HALF_OPEN_TO_OPEN, circuitBreakerMetrics);
             }else{
                 stateMachine.transitionToClosedState(CircuitBreaker.StateTransition.HALF_OPEN_TO_CLOSED);

src/test/java/javaslang/circuitbreaker/internal/CircuitBreakerStateMachineTest.java

@@ -20,13 +20,17 @@
 
 import javaslang.circuitbreaker.CircuitBreaker;
 import javaslang.circuitbreaker.CircuitBreakerConfig;
+import javaslang.circuitbreaker.CircuitBreakerRegistry;
 import org.junit.Before;
 import org.junit.Test;
 
 import java.time.Duration;
+import java.util.concurrent.TimeUnit;
 
 import static java.lang.Thread.sleep;
 import static org.assertj.core.api.BDDAssertions.assertThat;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 
 public class CircuitBreakerStateMachineTest {
 
@@ -37,7 +41,7 @@ public void setUp(){
         circuitBreaker = new CircuitBreakerStateMachine("testName", CircuitBreakerConfig.custom()
                 .failureRateThreshold(50)
                 .ringBufferSizeInClosedState(5)
-                .ringBufferSizeInHalfOpenState(2)
+                .ringBufferSizeInHalfOpenState(3)
                 .waitDurationInOpenState(Duration.ofSeconds(1))
                 .build());
     }
@@ -121,13 +125,16 @@ public void testCircuitBreakerStateMachine() throws InterruptedException {
 
         // Call 2 is a failure
         circuitBreaker.recordFailure(new RuntimeException());
+        // Call 3 is a success
+        circuitBreaker.recordSuccess();
+
         // The ring buffer is filled and the failure rate is above 50%
         // The state machine transitions back to OPEN state
         assertThat(circuitBreaker.isCallPermitted()).isEqualTo(false);
         assertThat(circuitBreaker.getState()).isEqualTo(CircuitBreaker.State.OPEN);
-        assertThat(circuitBreaker.getMetrics().getNumberOfBufferedCalls()).isEqualTo(2);
+        assertThat(circuitBreaker.getMetrics().getNumberOfBufferedCalls()).isEqualTo(3);
         assertThat(circuitBreaker.getMetrics().getNumberOfFailedCalls()).isEqualTo(2);
-        assertThat(circuitBreaker.getMetrics().getFailureRate()).isEqualTo(100f);
+        assertThat(circuitBreaker.getMetrics().getFailureRate()).isGreaterThan(50f);
 
         sleep(1300);
 
@@ -145,12 +152,33 @@ public void testCircuitBreakerStateMachine() throws InterruptedException {
 
         // Call 2 is a success
         circuitBreaker.recordSuccess();
-        // The ring buffer is filled and the failure rate is equal to 50%
+        // Call 3 is a success
+        circuitBreaker.recordSuccess();
+
+        // The ring buffer is filled and the failure rate is below 50%
         // The state machine transitions back to CLOSED state
         assertThat(circuitBreaker.isCallPermitted()).isEqualTo(true);
         assertThat(circuitBreaker.getState()).isEqualTo(CircuitBreaker.State.CLOSED);
         assertThat(circuitBreaker.getMetrics().getNumberOfBufferedCalls()).isEqualTo(0);
         assertThat(circuitBreaker.getMetrics().getNumberOfFailedCalls()).isEqualTo(0);
         assertThat(circuitBreaker.getMetrics().getFailureRate()).isEqualTo(-1f);
     }
+
+    @Test
+    public void testCircuitBreakerBehaviour() throws InterruptedException {
+        CircuitBreakerRegistry registry = CircuitBreakerRegistry.ofDefaults();
+        int times = 3;
+        int waitSeconds = 2;
+        CircuitBreakerConfig config = CircuitBreakerConfig.custom().ringBufferSizeInHalfOpenState(times)
+                .failureRateThreshold(100).ringBufferSizeInClosedState(times)
+                .waitDurationInOpenState(Duration.ofSeconds(waitSeconds)).build();
+        CircuitBreaker circuitBreaker = registry.circuitBreaker("something", config);
+        for (int i = 0; i < times; i++) {
+            assertTrue("Circuit-breaker call should be permitted", circuitBreaker.isCallPermitted());
+            circuitBreaker.recordFailure(new RuntimeException("Fail! " + i));
+        }
+        assertFalse("Circuit-breaker call should not be permitted", circuitBreaker.isCallPermitted());
+        Thread.sleep(TimeUnit.SECONDS.toMillis(waitSeconds));
+        assertTrue("Circuit-breaker call should be permitted", circuitBreaker.isCallPermitted());
+    }
 }