@Test
  public void testStateTransition() throws Exception {
    FakeTicker ticker = new FakeTicker();
    int minimumRequestThreshold = 2;
    Duration circuitOpenWindow = Duration.ofSeconds(60);
    Duration counterSlidingWindow = Duration.ofSeconds(180);
    Duration counterUpdateInterval = Duration.ofMillis(1);
    Future<Object> successFuture = successFuture();
    Future<Object> failedFuture = failedFuture();

    CircuitBreaker circuitBreaker =
        new CircuitBreakerBuilder(remoteServiceName)
            .minimumRequestThreshold(minimumRequestThreshold)
            .circuitOpenWindow(circuitOpenWindow)
            .counterSlidingWindow(counterSlidingWindow)
            .counterUpdateInterval(counterUpdateInterval)
            .ticker(ticker)
            .build();

    RemoteInvoker remoteInvoker = mock(RemoteInvoker.class);
    // return failed future
    when(remoteInvoker.invoke(any(), any(), any(), any(), any(), any())).thenReturn(failedFuture);

    CircuitBreakerMapping mapping =
        (eventLoop1, uri, options1, codec1, method, args1) -> circuitBreaker;
    CircuitBreakerRemoteInvoker stub = new CircuitBreakerRemoteInvoker(remoteInvoker, mapping);

    // CLOSED
    for (int i = 0; i < minimumRequestThreshold + 1; i++) {
      Future<Object> future = stub.invoke(eventLoop, uri, options, codec, methodA(), args);
      // The future is `failedFuture` itself
      assertThat(future.isSuccess(), is(false));
      // This is not a CircuitBreakerException
      assertThat(future.cause(), is(not(instanceOf(FailFastException.class))));
      ticker.advance(Duration.ofMillis(1).toNanos());
    }

    // OPEN
    Future<Object> future1 = stub.invoke(eventLoop, uri, options, codec, methodA(), args);
    // The circuit is OPEN
    assertThat(future1.isSuccess(), is(false));
    assertThat(future1.cause(), instanceOf(FailFastException.class));
    assertThat(((FailFastException) future1.cause()).getCircuitBreaker(), is(circuitBreaker));

    ticker.advance(circuitOpenWindow.toNanos());

    // return success future
    when(remoteInvoker.invoke(any(), any(), any(), any(), any(), any())).thenReturn(successFuture);

    // HALF OPEN
    Future<Object> future2 = stub.invoke(eventLoop, uri, options, codec, methodA(), args);
    assertThat(future2.isSuccess(), is(true));

    // CLOSED
    Future<Object> future3 = stub.invoke(eventLoop, uri, options, codec, methodA(), args);
    assertThat(future3.isSuccess(), is(true));
  }
 @SuppressWarnings("unchecked")
 private static <T> Future<T> failedFuture() {
   Future<T> future = mockFuture();
   when(future.isSuccess()).thenReturn(false);
   when(future.cause()).thenReturn(new Exception());
   return future;
 }
  @Test
  public void testPerMethodScope() throws Exception {
    FakeTicker ticker = new FakeTicker();
    int minimumRequestThreshold = 2;
    Duration circuitOpenWindow = Duration.ofSeconds(60);
    Duration counterSlidingWindow = Duration.ofSeconds(180);
    Duration counterUpdateInterval = Duration.ofMillis(1);
    Future<Object> successFuture = successFuture();
    Future<Object> failedFuture = failedFuture();

    Function<String, CircuitBreaker> factory =
        method ->
            new CircuitBreakerBuilder(remoteServiceName)
                .minimumRequestThreshold(minimumRequestThreshold)
                .circuitOpenWindow(circuitOpenWindow)
                .counterSlidingWindow(counterSlidingWindow)
                .counterUpdateInterval(counterUpdateInterval)
                .ticker(ticker)
                .build();

    RemoteInvoker remoteInvoker = mock(RemoteInvoker.class);
    // Always return failed future for methodA
    when(remoteInvoker.invoke(any(), any(), any(), any(), eq(methodA()), any()))
        .thenReturn(failedFuture);
    // Always return success future for methodB
    when(remoteInvoker.invoke(any(), any(), any(), any(), eq(methodB()), any()))
        .thenReturn(successFuture);

    CircuitBreakerMapping mapping =
        new KeyedCircuitBreakerMapping<>(KeySelector.METHOD, factory::apply);
    CircuitBreakerRemoteInvoker stub = new CircuitBreakerRemoteInvoker(remoteInvoker, mapping);

    // CLOSED (methodA)
    for (int i = 0; i < minimumRequestThreshold + 1; i++) {
      stub.invoke(eventLoop, uri, options, codec, methodA(), args);
      ticker.advance(Duration.ofMillis(1).toNanos());
    }

    // OPEN (methodA)
    Future<Object> future1 = stub.invoke(eventLoop, uri, options, codec, methodA(), args);
    assertThat(future1.isSuccess(), is(false));
    assertThat(future1.cause(), instanceOf(FailFastException.class));

    // CLOSED (methodB)
    Future<Object> future2 = stub.invoke(eventLoop, uri, options, codec, methodB(), args);
    assertThat(future2.isSuccess(), is(true));
  }
 @Override
 public final void operationComplete(Future<V> future) throws Exception {
   if (future.isSuccess()) {
     onSuccess(future.get());
   } else {
     onFailure(future.cause());
   }
 }
 @SuppressWarnings("unchecked")
 private static <T> Future<T> successFuture() {
   Future<T> future = mockFuture();
   when(future.isSuccess()).thenReturn(true);
   return future;
 }