@Test public void shouldNotAffectCircuitBreakerWhenWasCancelledAfterNotPermittedSubscribe() throws Exception { // Given Subscription subscription = mock(Subscription.class); Subscriber childObserver = mock(Subscriber.class); Subscriber decoratedObserver = CircuitBreakerOperator.of(circuitBreaker).apply(childObserver); circuitBreaker.transitionToOpenState(); decoratedObserver.onSubscribe(subscription); // When ((Subscription) decoratedObserver).cancel(); // Then assertNoRegisteredCall(); } }
@Test public void shouldNotAffectCircuitBreakerWhenWasDisposedAfterNotPermittedSubscribe() throws Exception { // Given Disposable disposable = mock(Disposable.class); CompletableObserver childObserver = mock(CompletableObserver.class); CompletableObserver decoratedObserver = CircuitBreakerOperator.of(circuitBreaker).apply(childObserver); circuitBreaker.transitionToOpenState(); decoratedObserver.onSubscribe(disposable); // When ((Disposable) decoratedObserver).dispose(); // Then assertNoRegisteredCall(); } }
@Test public void shouldNotReleaseBulkheadWhenWasDisposedAfterNotPermittedSubscribe() throws Exception { // Given Disposable disposable = mock(Disposable.class); SingleObserver childObserver = mock(SingleObserver.class); SingleObserver decoratedObserver = CircuitBreakerOperator.of(circuitBreaker).apply(childObserver); circuitBreaker.transitionToOpenState(); decoratedObserver.onSubscribe(disposable); // When ((Disposable) decoratedObserver).dispose(); // Then assertNoRegisteredCall(); }
@Test public void shouldNotAffectCircuitBreakerWhenWasDisposedAfterNotPermittedSubscribe() throws Exception { // Given Disposable disposable = mock(Disposable.class); MaybeObserver childObserver = mock(MaybeObserver.class); MaybeObserver decoratedObserver = CircuitBreakerOperator.of(circuitBreaker).apply(childObserver); circuitBreaker.transitionToOpenState(); decoratedObserver.onSubscribe(disposable); // When ((Disposable) decoratedObserver).dispose(); // Then assertNoRegisteredCall(); } }
@Test public void shouldNotAffectCircuitBreakerWhenWasDisposedAfterNotPermittedSubscribe() throws Exception { // Given Disposable disposable = mock(Disposable.class); Observer childObserver = mock(Observer.class); Observer decoratedObserver = CircuitBreakerOperator.of(circuitBreaker).apply(childObserver); circuitBreaker.transitionToOpenState(); decoratedObserver.onSubscribe(disposable); // When ((Disposable) decoratedObserver).dispose(); // Then assertNoRegisteredCall(); } }
@Test public void shouldEmitErrorWithCircuitBreakerOpenException() { circuitBreaker.transitionToOpenState(); StepVerifier.create( Mono.just("Event") .transform(CircuitBreakerOperator.of(circuitBreaker))) .expectError(CircuitBreakerOpenException.class) .verify(Duration.ofSeconds(1)); assertNoRegisteredCall(); }
@Test public void shouldEmitCircuitBreakerOpenExceptionEvenWhenErrorDuringSubscribe() { circuitBreaker.transitionToOpenState(); StepVerifier.create( Flux.error(new IOException("BAM!")) .transform(CircuitBreakerOperator.of(circuitBreaker))) .expectError(CircuitBreakerOpenException.class) .verify(Duration.ofSeconds(1)); assertNoRegisteredCall(); } }
@Test public void shouldEmitCircuitBreakerOpenExceptionEvenWhenErrorNotOnSubscribe() { circuitBreaker.transitionToOpenState(); StepVerifier.create( Flux.error(new IOException("BAM!"), true) .transform(CircuitBreakerOperator.of(circuitBreaker))) .expectError(CircuitBreakerOpenException.class) .verify(Duration.ofSeconds(1)); assertNoRegisteredCall(); }
@Test public void shouldEmitErrorWithCircuitBreakerOpenException() { circuitBreaker.transitionToOpenState(); StepVerifier.create( Flux.just("Event 1", "Event 2") .transform(CircuitBreakerOperator.of(circuitBreaker))) .expectError(CircuitBreakerOpenException.class) .verify(Duration.ofSeconds(1)); assertNoRegisteredCall(); }
@Test public void shouldEmitErrorWithCircuitBreakerOpenExceptionEvenWhenErrorDuringSubscribe() { circuitBreaker.transitionToOpenState(); StepVerifier.create( Flux.error(new IOException("BAM!")) .transform(CircuitBreakerOperator.of(circuitBreaker)) .transform(BulkheadOperator.of(bulkhead, Schedulers.immediate())) .transform(RateLimiterOperator.of(rateLimiter, Schedulers.immediate())) ).expectError(CircuitBreakerOpenException.class) .verify(Duration.ofSeconds(1)); }
@Test public void shouldEmitErrorWithCircuitBreakerOpenExceptionEvenWhenErrorNotOnSubscribe() { circuitBreaker.transitionToOpenState(); StepVerifier.create( Flux.error(new IOException("BAM!"), true) .transform(CircuitBreakerOperator.of(circuitBreaker)) .transform(BulkheadOperator.of(bulkhead, Schedulers.immediate())) .transform(RateLimiterOperator.of(rateLimiter, Schedulers.immediate())) ).expectError(CircuitBreakerOpenException.class) .verify(Duration.ofSeconds(1)); } }
circuitBreaker.transitionToOpenState();
circuitBreaker.transitionToOpenState();
@Test public void shouldEmitErrorWithCircuitBreakerOpenException() { circuitBreaker.transitionToOpenState(); Observable.fromArray("Event 1", "Event 2") .lift(CircuitBreakerOperator.of(circuitBreaker)) .test() .assertSubscribed() .assertError(CircuitBreakerOpenException.class) .assertNotComplete(); assertNoRegisteredCall(); }
@Test public void shouldEmitErrorWithCircuitBreakerOpenException() { circuitBreaker.transitionToOpenState(); Flowable.fromArray("Event 1", "Event 2") .lift(CircuitBreakerOperator.of(circuitBreaker)) .test() .assertSubscribed() .assertError(CircuitBreakerOpenException.class) .assertNotComplete(); assertNoRegisteredCall(); }
@Test public void shouldEmitErrorWithCircuitBreakerOpenException() { circuitBreaker.transitionToOpenState(); Maybe.just(1) .lift(CircuitBreakerOperator.of(circuitBreaker)) .test() .assertSubscribed() .assertError(CircuitBreakerOpenException.class) .assertNotComplete(); assertNoRegisteredCall(); }
@Test public void shouldEmitErrorWithCircuitBreakerOpenException() { circuitBreaker.transitionToOpenState(); Completable.complete() .lift(CircuitBreakerOperator.of(circuitBreaker)) .test() .assertSubscribed() .assertError(CircuitBreakerOpenException.class) .assertNotComplete(); assertNoRegisteredCall(); }
@Test public void shouldEmitErrorWithCircuitBreakerOpenException() { circuitBreaker.transitionToOpenState(); Single.just(1) .lift(CircuitBreakerOperator.of(circuitBreaker)) .test() .assertSubscribed() .assertError(CircuitBreakerOpenException.class) .assertNotComplete(); assertNoRegisteredCall(); }
circuitBreaker.transitionToOpenState(); // Should create a CircuitBreakerOnStateTransitionEvent (20) assertThat(circuitBreaker.isCallPermitted()).isEqualTo(false); assertThat(circuitBreaker.getState()).isEqualTo(CircuitBreaker.State.OPEN);
@Test public void shouldNotCallServiceOnEnqueueWhenOpen() throws Throwable { stubFor(get(urlPathEqualTo("/greeting")) .willReturn(aResponse() .withStatus(200) .withHeader("Content-Type", "text/plain") .withBody("hello world"))); circuitBreaker.transitionToOpenState(); try { EnqueueDecorator.enqueue(service.greeting()); fail("CircuitBreakerOpenException was expected"); } catch (CircuitBreakerOpenException ignore) { } ensureAllRequestsAreExecuted(Duration.ofSeconds(1)); verify(0, getRequestedFor(urlPathEqualTo("/greeting"))); }