repositories {
  mavenCentral()
}
 
extra["springCloudVersion"] = "2023.0.0"
 
dependencies {
  implementation("org.springframework.cloud:spring-cloud-starter-circuitbreaker-resilience4j")
  testImplementation("org.springframework.boot:spring-boot-starter-test")
}
 
dependencyManagement {
  imports {
    mavenBom("org.springframework.cloud:spring-cloud-dependencies:${property("springCloudVersion")}")
  }
}

@Bean
public Customizer<ReactiveResilience4JCircuitBreakerFactory> foobarCircuitBreaker(){
  var circuitBreakerConfig = CircuitBreakerConfig
      .custom()
      .slidingWindowSize(10)
      .failureRateThreshold(75)
      .enableAutomaticTransitionFromOpenToHalfOpen()
      .waitDurationInOpenState(Duration.ofSeconds(5))
      .permittedNumberOfCallsInHalfOpenState(6)
      .ignoreExceptions(ArithmeticException.class)
      .maxWaitDurationInHalfOpenState(Duration.ofSeconds(30))
      .build();
 
  var timeLimiterConfig = TimeLimiterConfig.custom()
      .cancelRunningFuture(true)
      .timeoutDuration(Duration.ofSeconds(3))
      .build();
 
  var circuitBreakerId = "foobar";
 
  return factory -> {
    factory.addCircuitBreakerCustomizer(loggingCustomizer(), circuitBreakerId);
    factory.configure(builder -> {
      builder
          .circuitBreakerConfig(circuitBreakerConfig)
          .timeLimiterConfig(timeLimiterConfig);
    }, circuitBreakerId);
  };
}

  var circuitBreakerConfig = CircuitBreakerConfig
      .custom()
      .slidingWindowSize(10)
      .failureRateThreshold(75)
      .enableAutomaticTransitionFromOpenToHalfOpen()
      .waitDurationInOpenState(Duration.ofSeconds(5))
      .permittedNumberOfCallsInHalfOpenState(6)
      .ignoreExceptions(ArithmeticException.class)
      .maxWaitDurationInHalfOpenState(Duration.ofSeconds(30))
      .build();

    var timeLimiterConfig = TimeLimiterConfig.custom()
        .cancelRunningFuture(true)
        .timeoutDuration(Duration.ofSeconds(3))
        .build();

  return factory -> {
    factory.addCircuitBreakerCustomizer(loggingCustomizer(), circuitBreakerId);
    factory.configure(builder -> {
      builder
          .circuitBreakerConfig(circuitBreakerConfig)
          .timeLimiterConfig(timeLimiterConfig);
    }, circuitBreakerId);
  };

resilience4j:
  circuitbreaker:
    instances:
      basic:
        sliding-window-size: 10
        failure-rate-threshold: 70
        automatic-transition-from-open-to-half-open-enabled: true
        wait-duration-in-open-state:
          seconds: 5s
        permitted-number-of-calls-in-half-open-state: 6
        ignore-exceptions:
          - java.lang.IllegalCallerException
        max-wait-duration-in-half-open-state:
          seconds: 30s
    configs:
      default:
        register-health-indicator: true
        sliding-window-size: 50
  timelimiter:
    instances:
      basic:
        timeout-duration:
          seconds: 1
        cancel-running-future: true

resilience4j:
  circuitbreaker:
    instances:
      basic:
        sliding-window-size: 10
        failure-rate-threshold: 70
        automatic-transition-from-open-to-half-open-enabled: true
        wait-duration-in-open-state:
          seconds: 5s
        permitted-number-of-calls-in-half-open-state: 6
        ignore-exceptions:
          - java.lang.IllegalCallerException
        max-wait-duration-in-half-open-state:
          seconds: 30s
    configs:
    # ... 
  timelimiter:
    # ... 

resilience4j:
  circuitbreaker:
    # ... 
  timelimiter:
    instances:
      basic:
        timeout-duration:
          seconds: 1
        cancel-running-future: true

resilience4j:
  circuitbreaker:
    # ...
    configs:
      default:
        register-health-indicator: true
        sliding-window-size: 50
  timelimiter:
    # ...

package io.chagchagchag.example.foobar.reactive_circuit_breaker;
 
import io.chagchagchag.example.foobar.reactive_circuit_breaker.common.Ready;
import java.time.Duration;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.client.circuitbreaker.ReactiveCircuitBreakerFactory;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Mono;
 
@Slf4j
@RequiredArgsConstructor
@Service
public class ReactiveHealthcheckService {
  private final ReactiveCircuitBreakerFactory healthCheckCircuitBreaker;
  private final Ready ready;
 
  private final String fallbackMessage = "FoobarHealthCircuitBreaker Fallback";
 
  /**
   * health 체크를 위한 "OK (ServiceName)" 문자열을 Mono 기반의 동시성 코드로 생성하는 공통 코드입니다.
   * @param from SERVICE 명
   * @param delayMs 지연할 시간
   * @return
   */
  public Mono<String> delayedOk(String from, Long delayMs){
    var duration = Duration.ofMillis(delayMs);
    return Mono.delay(duration)
        .then()
        .then(Mono.fromCallable(() -> ready.ok(from)));
  }
 
  /**
   * 다른 설정이 되지 않은 기본설정이 되어 있는 circuitBreaker 를 기반으로 ready() 함수에 대해 회로차단기를 걸어두었습니다.
   * "OK" 신호를 내보내는 데에 delayMs 로 들어온 지연 시간이 걸리도록 합니다.
   * 이때 CircuitBreaker 내의 허용된 지연시간, 실패 횟수, 슬라이딩윈도우, 실패율 등에 따라
   * CircuitBreaker 가 이 기능을 차단할지, 차단하지 않을지를 결정하게 됩니다.
   * @param from SERVICE 명
   * @param delayMs 지연할 시간
   * @return
   */
  public Mono<String> ready(String from, Long delayMs){
    return delayedOk(from, delayMs)
        .transform(it -> {
          var cb = healthCheckCircuitBreaker.create("normal");
          return cb.run(it, throwable -> Mono.just(fallbackMessage));
        });
  }
 
  /**
   * "OK"신호를 내보낼 때 exception 이 발생하는 경우를 가정합니다.
   * @param from SERVICE 명
   * @return
   */
  public Mono<String> readyWithException(String from){
    Mono<String> mono = Mono.error(new RuntimeException("Err"));
 
    return mono.transform(it -> {
      var circuitBreaker = healthCheckCircuitBreaker.create("exception");
      return circuitBreaker
          .run(it, throwable -> Mono.just(fallbackMessage));
    });
  }
 
  /**
   * "OK" 신호를 내보내는 기능을 특정 ID를 가진 서킷브레이커로 감쌉니다.
   * @param id
   * @param from SERVICE 명
   * @param delayMs 지연할 시간
   * @return
   */
  public Mono<String> readyWithId(String id, String from, Long delayMs){
    return delayedOk(from, delayMs)
        .transform(it -> {
          var cb = healthCheckCircuitBreaker.create(id);
          return cb.run(it, throwable -> Mono.just(fallbackMessage));
        });
  }
 
  public Mono<String> readyWithIdAndGroup(
      String id, String group, String from, Long delayMs
  ){
    return delayedOk(from, delayMs)
        .transform(it -> {
          var cb = healthCheckCircuitBreaker.create(id, group);
          return cb.run(it, throwable -> Mono.just(fallbackMessage));
        });
  }
}
 

package io.chagchagchag.example.foobar.reactive_circuit_breaker;
 
import io.github.resilience4j.circuitbreaker.CircuitBreaker;
import io.github.resilience4j.circuitbreaker.CircuitBreakerConfig;
import io.github.resilience4j.timelimiter.TimeLimiterConfig;
import java.time.Duration;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.cloud.circuitbreaker.resilience4j.ReactiveResilience4JCircuitBreakerFactory;
import org.springframework.cloud.circuitbreaker.resilience4j.Resilience4JConfigBuilder;
import org.springframework.cloud.client.circuitbreaker.Customizer;
import org.springframework.context.annotation.Bean;
 
@Slf4j
@TestConfiguration
public class TestCircuitBreakerConfig {
  @Bean
  public Customizer<ReactiveResilience4JCircuitBreakerFactory> healthCheck(){
    var circuitBreakerConfig = CircuitBreakerConfig.custom()
        .slidingWindowSize(10)
        .failureRateThreshold(75)
        .enableAutomaticTransitionFromOpenToHalfOpen()
        .waitDurationInOpenState(Duration.ofSeconds(5))
        .permittedNumberOfCallsInHalfOpenState(6)
        .ignoreExceptions(ArithmeticException.class)
        .maxWaitDurationInHalfOpenState(Duration.ofSeconds(30))
        .build();
 
    var timeLimiterConfig = TimeLimiterConfig.custom()
        .cancelRunningFuture(true)
        .timeoutDuration(Duration.ofSeconds(3))
        .build();
 
    var circuitBreakerId = "healthCheck";
 
    return factory -> {
      factory.addCircuitBreakerCustomizer(loggingCustomizer(), circuitBreakerId);
      factory.configure(builder -> {
        builder
            .circuitBreakerConfig(circuitBreakerConfig)
            .timeLimiterConfig(timeLimiterConfig);
      }, circuitBreakerId);
    };
  }
 
  private Customizer<CircuitBreaker> loggingCustomizer(){
    return Customizer.once(circuitBreaker -> {
      var cbName = circuitBreaker.getName();
      circuitBreaker.getEventPublisher()
          .onSuccess(event -> log.info("circuit breaker ({}) success", cbName))
          .onError(event -> log.info("circuit breaker ({}) error ===> {}", cbName, event.getThrowable().toString()))
          .onStateTransition(event -> {
            log.info("circuit breaker ({}) changed from {} to {}",
                cbName,
                event.getStateTransition().getFromState(),
                event.getStateTransition().getToState());
          })
          .onSlowCallRateExceeded(event ->
              log.info("circuit breaker ({}) slow call rate exceeded ===> {}",
                  cbName, event.getSlowCallRate()))
          .onFailureRateExceeded(event ->
              log.info("circuit breaker ({}) failure rate exceeded ===> {}",
                  cbName, event.getFailureRate()));
 
    }, CircuitBreaker::getName);
  }
 
  @Bean
  public Customizer<ReactiveResilience4JCircuitBreakerFactory> defaultCustomizer(){
    return factory -> {
      factory.configureDefault(id -> {
        factory.addCircuitBreakerCustomizer(loggingCustomizer(), id);
        return new Resilience4JConfigBuilder(id)
            .circuitBreakerConfig(CircuitBreakerConfig.ofDefaults())
            .build();
      });
    };
  }
 
  @Bean
  public Customizer<ReactiveResilience4JCircuitBreakerFactory> tinyCustomizer(){
    var cbConfig = CircuitBreakerConfig.custom()
        .failureRateThreshold(50)
        .slidingWindowSize(3)
        .build();
 
    var targets = new String[]{"tiny"};
    return factory -> {
      factory.addCircuitBreakerCustomizer(loggingCustomizer(), targets);
      factory.configure(
          builder -> builder.circuitBreakerConfig(cbConfig),
          targets
      );
    };
  }
 
  @Bean
  public Customizer<ReactiveResilience4JCircuitBreakerFactory> autoHalf(){
    var cbConfig = CircuitBreakerConfig.custom()
        .failureRateThreshold(50)
        .slidingWindowSize(3)
        .enableAutomaticTransitionFromOpenToHalfOpen() // auto half 설정
        .waitDurationInOpenState(Duration.ofSeconds(5))
        .build();
 
    var targets = new String[]{"autoHalf"};
    return factory -> {
      factory.addCircuitBreakerCustomizer(
          loggingCustomizer(), targets);
      factory.configure(builder -> {
        builder.circuitBreakerConfig(cbConfig);
      }, targets);
    };
  }
 
  @Bean
  public Customizer<ReactiveResilience4JCircuitBreakerFactory> halfOpen() {
    var cbConfig = CircuitBreakerConfig.custom()
        .failureRateThreshold(50)
        .slidingWindowSize(3)
        .enableAutomaticTransitionFromOpenToHalfOpen()
        .waitDurationInOpenState(Duration.ofSeconds(3))
        .permittedNumberOfCallsInHalfOpenState(6) //
        .build();
 
    var targets = new String[]{"halfOpen"};
 
    return factory -> {
      factory.addCircuitBreakerCustomizer(loggingCustomizer(), targets);
      factory.configure(
          builder -> builder.circuitBreakerConfig(cbConfig),
          targets
      );
    };
  }
}

@Slf4j
@Import(TestCircuitBreakerConfig.class)
@ImportAutoConfiguration(
    classes = {
        ReactiveResilience4JAutoConfiguration.class,
        Resilience4JAutoConfiguration.class,
        CircuitBreakerAutoConfiguration.class,
        TimeLimiterAutoConfiguration.class
    }
)
@SpringBootTest
public class HealthCheckCircuitBreakerTest {
  @Autowired
  private ReactiveHealthcheckService reactiveHealthcheckService;
  @Autowired
  private CircuitBreakerRegistry circuitBreakerRegistry;
  @SpyBean
  private Ready ready;
 
  String fallbackMessage = "FoobarHealthCircuitBreaker Fallback";
    
  @DisplayName("READY_WITHOUT_DELAY")
  @Test
  public void TEST_READY_WITHOUT_DELAY(){
    // given
    var serviceName = "order-service";
    var expectedMessage = String.format("OK (%s)", serviceName);
 
    // when
    var mono = reactiveHealthcheckService.ready(serviceName, 0L);
 
    // then
    StepVerifier.create(mono)
        .expectNext(expectedMessage)
        .verifyComplete();
 
    Mockito.verify(ready).ok(serviceName);
  }
  
  // ...
 
}

@Slf4j
@TestConfiguration
public class TestCircuitBreakerConfig {
  // ...
  
  @Bean
  public Customizer<ReactiveResilience4JCircuitBreakerFactory> tinyCustomizer(){
    var cbConfig = CircuitBreakerConfig.custom()
        .failureRateThreshold(50)
        .slidingWindowSize(3)
        .build();
 
    var targets = new String[]{"tiny"};
    return factory -> {
      factory.addCircuitBreakerCustomizer(loggingCustomizer(), targets);
      factory.configure(
          builder -> builder.circuitBreakerConfig(cbConfig),
          targets
      );
    };
  }
    
  // ...
    
}

@Slf4j
@Import(TestCircuitBreakerConfig.class)
@ImportAutoConfiguration(
    classes = {
        ReactiveResilience4JAutoConfiguration.class,
        Resilience4JAutoConfiguration.class,
        CircuitBreakerAutoConfiguration.class,
        TimeLimiterAutoConfiguration.class
    }
)
@SpringBootTest
public class HealthCheckCircuitBreakerTest {
  @Autowired
  private ReactiveHealthcheckService reactiveHealthcheckService;
  @Autowired
  private CircuitBreakerRegistry circuitBreakerRegistry;
  @SpyBean
  private Ready ready;
 
  String fallbackMessage = "FoobarHealthCircuitBreaker Fallback";
  
  // ...
  
  // tiny 회로차단기 ON 되는 테스트 케이스
  @DisplayName("READY_METHOD_MAKE_CB_STATE_OPEN")
  @Test
  public void TEST_READY_METHOD_MAKE_CB_STATE_OPEN(){
    // given
    String serviceName = "order-service";
    String successMessage = String.format("OK (%s)", serviceName);
    String expectedMessage = fallbackMessage;
 
    // when (delay 없는 call 은 성공, 3개의 call 실행, Sliding Window 채우기 위한 용도)
    for(int i=0; i<3; i++){
      StepVerifier.create(reactiveHealthcheckService.readyWithId("tiny", serviceName, 0L))
          .expectNext(successMessage)
          .verifyComplete();
    }
 
    // then (5s delay call 을 2번 실행 -> 50% 실패 -> circuit breaker closed)
    for(int i=0; i<2; i++){
      StepVerifier
          .withVirtualTime(()->reactiveHealthcheckService.readyWithId("tiny", serviceName, 7000L))
          .thenAwait(Duration.ofSeconds(2))
          .expectNext(expectedMessage)
          .verifyComplete();
    }
 
    for(int i=0; i<100; i++){
      StepVerifier
          .create(reactiveHealthcheckService.readyWithId("tiny", serviceName, 0L))
          .expectNext(expectedMessage)
          .verifyComplete();
    }
 
    Mockito.verify(ready, Mockito.times(3)).ok(serviceName);
  }
  
  // ...
 
}

@Slf4j
@TestConfiguration
public class TestCircuitBreakerConfig {
  // ...
  
  @Bean
  public Customizer<ReactiveResilience4JCircuitBreakerFactory> tinyCustomizer(){
    var cbConfig = CircuitBreakerConfig.custom()
        .failureRateThreshold(50)
        .slidingWindowSize(3)
        .build();
 
    var targets = new String[]{"tiny"};
    return factory -> {
      factory.addCircuitBreakerCustomizer(loggingCustomizer(), targets);
      factory.configure(
          builder -> builder.circuitBreakerConfig(cbConfig),
          targets
      );
    };
  }
    
  // ...
    
}

@Slf4j
@Import(TestCircuitBreakerConfig.class)
@ImportAutoConfiguration(
    classes = {
        ReactiveResilience4JAutoConfiguration.class,
        Resilience4JAutoConfiguration.class,
        CircuitBreakerAutoConfiguration.class,
        TimeLimiterAutoConfiguration.class
    }
)
@SpringBootTest
public class HealthCheckCircuitBreakerTest {
  @Autowired
  private ReactiveHealthcheckService reactiveHealthcheckService;
  @Autowired
  private CircuitBreakerRegistry circuitBreakerRegistry;
  @SpyBean
  private Ready ready;
 
  String fallbackMessage = "FoobarHealthCircuitBreaker Fallback";
  
  // ...
  
  // 회로차단기 OPEN (ON) 상태 -> HALF OPEN 상태 테스트 케이스
  @DisplayName("READY_METHOD_MAKE_CB_STATE_FROM_OPEN_TO_HALF_OPEN_DEFAULT_OPTION")
  @Test
  public void TEST_READY_METHOD_MAKE_CB_STATE_FROM_OPEN_TO_HALF_OPEN_DEFAULT_OPTION(){
    // given
    String serviceName = "order-service";
    String successMessage = String.format("OK (%s)", serviceName);
 
    // 차단(OPEN, ON) 된 차단기 준비
    for(int i=0; i<3; i++){
      StepVerifier.withVirtualTime(()->reactiveHealthcheckService.readyWithId("tiny", serviceName, 5000L))
          .thenAwait(Duration.ofSeconds(2))
          .expectNext(fallbackMessage)
          .verifyComplete();
    }
 
    // when
    var tinyCb = circuitBreakerRegistry.circuitBreaker("tiny");
    tinyCb.transitionToHalfOpenState();
    log.info("Half Open 상태로 전환 완료");
 
    // then
    var state = circuitBreakerRegistry.circuitBreaker("tiny").getState();
    Assertions.assertThat(state).isEqualTo(CircuitBreaker.State.HALF_OPEN);
 
    StepVerifier.create(reactiveHealthcheckService.readyWithId("tiny", serviceName, 0L))
        .expectNext(successMessage)
        .verifyComplete();
  }
  
  // ...
 
}

@Slf4j
@TestConfiguration
public class TestCircuitBreakerConfig {
  // ...
  
  @Bean
  public Customizer<ReactiveResilience4JCircuitBreakerFactory> autoHalf(){
    var cbConfig = CircuitBreakerConfig.custom()
        .failureRateThreshold(50)
        .slidingWindowSize(3)
        .enableAutomaticTransitionFromOpenToHalfOpen() // auto half 설정
        .waitDurationInOpenState(Duration.ofSeconds(5))
        .build();
 
    var targets = new String[]{"autoHalf"};
    return factory -> {
      factory.addCircuitBreakerCustomizer(
          loggingCustomizer(), targets);
      factory.configure(builder -> {
        builder.circuitBreakerConfig(cbConfig);
      }, targets);
    };
  }

@Slf4j
@Import(TestCircuitBreakerConfig.class)
@ImportAutoConfiguration(
    classes = {
        ReactiveResilience4JAutoConfiguration.class,
        Resilience4JAutoConfiguration.class,
        CircuitBreakerAutoConfiguration.class,
        TimeLimiterAutoConfiguration.class
    }
)
@SpringBootTest
public class HealthCheckCircuitBreakerTest {
  @Autowired
  private ReactiveHealthcheckService reactiveHealthcheckService;
  @Autowired
  private CircuitBreakerRegistry circuitBreakerRegistry;
  @SpyBean
  private Ready ready;
    
  // ...
    
  @SneakyThrows
  @DisplayName("READY_METHOD_MAKE_CB_STATE_FROM_OPEN_TO_HALF_OPEN_AUTO_DETECT")
  @Test
  public void TEST_READY_METHOD_MAKE_CB_STATE_FROM_OPEN_TO_HALF_OPEN_AUTO_DETECT(){
    // given
    String serviceName = "order-service";
    String successMessage = String.format("OK (%s)", serviceName);
 
    // 회로차단기가 ON (OPEN) 되도록 지연을 유발하는 CALL 호출 3회 수행
    for(int i=0; i<3; i++){
      StepVerifier
          .withVirtualTime(()-> reactiveHealthcheckService.readyWithId("autoHalf", serviceName, 5000L))
          .thenAwait(Duration.ofSeconds(3))
          .expectNext(fallbackMessage)
          .verifyComplete();
    }
 
    // when
    log.info("7초 대기");
    Thread.sleep(7000);
 
    // then
    var state = circuitBreakerRegistry.circuitBreaker("autoHalf").getState();
    Assertions.assertThat(state).isEqualTo(CircuitBreaker.State.HALF_OPEN);
 
    StepVerifier.create(reactiveHealthcheckService.readyWithId("autoHalf", serviceName, 0L))
        .expectNext(successMessage)
        .verifyComplete();
  }
 
  // ...
}

@Slf4j
@TestConfiguration
public class TestCircuitBreakerConfig {
  // ...
  
  @Bean
  public Customizer<ReactiveResilience4JCircuitBreakerFactory> halfOpen() {
    var cbConfig = CircuitBreakerConfig.custom()
        .failureRateThreshold(50)
        .slidingWindowSize(3)
        .enableAutomaticTransitionFromOpenToHalfOpen()
        .waitDurationInOpenState(Duration.ofSeconds(3))
        .permittedNumberOfCallsInHalfOpenState(6) //
        .build();
 
    var targets = new String[]{"halfOpen"};
 
    return factory -> {
      factory.addCircuitBreakerCustomizer(loggingCustomizer(), targets);
      factory.configure(
          builder -> builder.circuitBreakerConfig(cbConfig),
          targets
      );
    };
  }
  
  // ...   
}

@Slf4j
@Import(TestCircuitBreakerConfig.class)
@ImportAutoConfiguration(
    classes = {
        ReactiveResilience4JAutoConfiguration.class,
        Resilience4JAutoConfiguration.class,
        CircuitBreakerAutoConfiguration.class,
        TimeLimiterAutoConfiguration.class
    }
)
@SpringBootTest
public class HealthCheckCircuitBreakerTest {
  @Autowired
  private ReactiveHealthcheckService reactiveHealthcheckService;
  @Autowired
  private CircuitBreakerRegistry circuitBreakerRegistry;
  @SpyBean
  private Ready ready;
 
  String fallbackMessage = "FoobarHealthCircuitBreaker Fallback";
  
  // ...
 
  // half open -> close (차단기 OFF)
  @SneakyThrows
  @DisplayName("READY_METHOD_MAKE_CB_STATE_FROM_HALF_OPEN_TO_CLOSE")
  @Test
  public void TEST_READY_METHOD_MAKE_CB_STATE_FROM_HALF_OPEN_TO_CLOSE(){
    // given
    String serviceName = "order-service";
    String successMessage = String.format("OK (%s)", serviceName);
    String cbId = "halfOpen";
 
    for(int i=0; i<3; i++){
      StepVerifier.withVirtualTime(() -> reactiveHealthcheckService.readyWithId(cbId, serviceName, 5000L))
          .thenAwait(Duration.ofSeconds(2))
          .expectNext(fallbackMessage)
          .verifyComplete();
    }
 
    log.info("3초 대기");
    Thread.sleep(3000);
 
    // when
    var successCnt = 4;
    var failCnt = 2;
    var total = successCnt + failCnt;
 
    // 1) 4번 성공시킴
    for(int i=0; i<successCnt; i++){
      StepVerifier.withVirtualTime(() -> reactiveHealthcheckService.readyWithId(cbId, serviceName, 0L))
          .expectNext(successMessage)
          .verifyComplete();
    }
    // 2) 2번 실패 시킴
    for(int i=0; i<failCnt; i++){
      StepVerifier.withVirtualTime(() -> reactiveHealthcheckService.readyWithId(cbId, serviceName, 5000L))
          .thenAwait(Duration.ofSeconds(2))
          .expectNext(fallbackMessage)
          .verifyComplete();
    }
 
    // then
    var state = circuitBreakerRegistry
        .circuitBreaker(cbId)
        .getState();
 
    Assertions.assertThat(state).isEqualTo(CircuitBreaker.State.CLOSED);
  }
 
  // ...
  
}

@Slf4j
@TestConfiguration
public class TestCircuitBreakerConfig {
  // ...
  
  @Bean
  public Customizer<ReactiveResilience4JCircuitBreakerFactory> halfOpen() {
    var cbConfig = CircuitBreakerConfig.custom()
        .failureRateThreshold(50)
        .slidingWindowSize(3)
        .enableAutomaticTransitionFromOpenToHalfOpen()
        .waitDurationInOpenState(Duration.ofSeconds(3))
        .permittedNumberOfCallsInHalfOpenState(6) //
        .build();
 
    var targets = new String[]{"halfOpen"};
 
    return factory -> {
      factory.addCircuitBreakerCustomizer(loggingCustomizer(), targets);
      factory.configure(
          builder -> builder.circuitBreakerConfig(cbConfig),
          targets
      );
    };
  }
  
  // ...   
}

@Slf4j
@Import(TestCircuitBreakerConfig.class)
@ImportAutoConfiguration(
    classes = {
        ReactiveResilience4JAutoConfiguration.class,
        Resilience4JAutoConfiguration.class,
        CircuitBreakerAutoConfiguration.class,
        TimeLimiterAutoConfiguration.class
    }
)
@SpringBootTest
public class HealthCheckCircuitBreakerTest {
  @Autowired
  private ReactiveHealthcheckService reactiveHealthcheckService;
  @Autowired
  private CircuitBreakerRegistry circuitBreakerRegistry;
  @SpyBean
  private Ready ready;
 
  String fallbackMessage = "FoobarHealthCircuitBreaker Fallback";
  
  // ...
  
  // half open -> open (차단기 ON)
  @SneakyThrows
  @DisplayName("READY_METHOD_MAKE_CB_STATE_FROM_HALF_OPEN_TO_OPEN")
  @Test
  public void TEST_READY_METHOD_MAKE_CB_STATE_FROM_HALF_OPEN_TO_OPEN(){
    // given
    String serviceName = "order-service";
    String successMessage = String.format("OK (%s)", serviceName);
    String cbId = "halfOpen";
 
    for(int i=0; i<3; i++){
      StepVerifier
          .withVirtualTime(() -> reactiveHealthcheckService.readyWithId(cbId, serviceName, 5000L))
          .thenAwait(Duration.ofSeconds(2))
          .expectNext(fallbackMessage)
          .verifyComplete();
    }
 
    log.info("3초 대기");
    Thread.sleep(3000);
 
    // when (실패율 50% 로 조정)
    var successCnt = 3;
    var failCnt = 3;
    var total = successCnt + failCnt;
 
    for(int i=0; i<successCnt; i++){
      StepVerifier
          .create(reactiveHealthcheckService.readyWithId(cbId, serviceName, 0L))
          .expectNext(successMessage)
          .verifyComplete();
    }
 
    for(int i=0; i<failCnt; i++){
      StepVerifier
          .withVirtualTime(() -> reactiveHealthcheckService.readyWithId(cbId, serviceName, 5000L))
          .thenAwait(Duration.ofSeconds(2))
          .expectNext(fallbackMessage)
          .verifyComplete();
    }
 
    // then
    var state = circuitBreakerRegistry.circuitBreaker(cbId)
        .getState();
    Assertions.assertThat(state).isEqualTo(CircuitBreaker.State.OPEN);
  }
}