private static Function<ClientResponse, Mono<ClientResponse>> convertClientResponse(Function<Flux<DataBuffer>, Flux<DataBuffer>> bodConverter, MediaType contentType) { return response -> { ClientResponse convertedResponse = ClientResponse.from(response).headers(headers -> { headers.replace(HttpHeaders.CONTENT_TYPE, singletonList(contentType.toString())); headers.remove(HttpHeaders.CONTENT_LENGTH); }).body(response.bodyToFlux(DataBuffer.class).transform(bodConverter)).build(); return Mono.just(convertedResponse); }; }
@Test public void shouldPropagateError() { StepVerifier.create( Flux.error(new IOException("BAM!")) .transform(BulkheadOperator.of(bulkhead)) .transform(RateLimiterOperator.of(rateLimiter)) .transform(CircuitBreakerOperator.of(circuitBreaker)) ).expectError(IOException.class) .verify(Duration.ofSeconds(1)); }
@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)); } }
@Test public void shouldEmitEvents() { StepVerifier.create( Flux.just("Event 1", "Event 2") .transform(BulkheadOperator.of(bulkhead)) .transform(RateLimiterOperator.of(rateLimiter)) .transform(CircuitBreakerOperator.of(circuitBreaker)) ).expectNext("Event 1") .expectNext("Event 2") .verifyComplete(); }
@Test public void shouldPropagateError() { StepVerifier.create( Flux.error(new IOException("BAM!")) .transform(BulkheadOperator.of(bulkhead))) .expectSubscription() .expectError(IOException.class) .verify(Duration.ofSeconds(1)); assertThat(bulkhead.getMetrics().getAvailableConcurrentCalls()).isEqualTo(1); }
@Test public void shouldPropagateError() { StepVerifier.create( Flux.error(new IOException("BAM!")) .transform(CircuitBreakerOperator.of(circuitBreaker))) .expectError(IOException.class) .verify(Duration.ofSeconds(1)); assertSingleFailedCall(); }
@Test public void shouldPropagateErrorWhenErrorNotOnSubscribe() { StepVerifier.create( Flux.error(new IOException("BAM!"), true) .transform(CircuitBreakerOperator.of(circuitBreaker))) .expectError(IOException.class) .verify(Duration.ofSeconds(1)); assertSingleFailedCall(); }
@Test public void shouldEmitBulkheadFullExceptionEvenWhenErrorDuringSubscribe() { bulkhead.isCallPermitted(); StepVerifier.create( Flux.error(new IOException("BAM!")) .transform(BulkheadOperator.of(bulkhead, Schedulers.immediate()))) .expectSubscription() .expectError(BulkheadFullException.class) .verify(Duration.ofSeconds(1)); assertThat(bulkhead.getMetrics().getAvailableConcurrentCalls()).isEqualTo(0); }
@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 shouldEmitBulkheadFullExceptionEvenWhenErrorNotOnSubscribe() { bulkhead.isCallPermitted(); StepVerifier.create( Flux.error(new IOException("BAM!"), true) .transform(BulkheadOperator.of(bulkhead, Schedulers.immediate()))) .expectSubscription() .expectError(BulkheadFullException.class) .verify(Duration.ofSeconds(1)); assertThat(bulkhead.getMetrics().getAvailableConcurrentCalls()).isEqualTo(0); } }
@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 shouldPropagateError() { StepVerifier.create( Flux.error(new IOException("BAM!")) .transform(RateLimiterOperator.of(rateLimiter))) .expectSubscription() .expectError(IOException.class) .verify(Duration.ofSeconds(1)); assertSinglePermitUsed(); }
@Test public void shouldEmitErrorWithBulkheadFullException() { bulkhead.isCallPermitted(); StepVerifier.create( Flux.just("Event") .transform(BulkheadOperator.of(bulkhead))) .expectSubscription() .expectError(BulkheadFullException.class) .verify(Duration.ofSeconds(1)); assertThat(bulkhead.getMetrics().getAvailableConcurrentCalls()).isEqualTo(0); }
@Test public void shouldEmitEvent() { StepVerifier.create( Flux.just("Event 1", "Event 2") .transform(BulkheadOperator.of(bulkhead))) .expectNext("Event 1") .expectNext("Event 2") .verifyComplete(); assertThat(bulkhead.getMetrics().getAvailableConcurrentCalls()).isEqualTo(1); }
@Test public void shouldEmitRequestNotPermittedExceptionEvenWhenErrorDuringSubscribe() { saturateRateLimiter(); StepVerifier.create( Flux.error(new IOException("BAM!")) .transform(RateLimiterOperator.of(rateLimiter))) .expectSubscription() .expectError(RequestNotPermitted.class) .verify(Duration.ofSeconds(1)); assertNoPermitLeft(); }
@Test public void shouldEmitRequestNotPermittedExceptionEvenWhenErrorNotOnSubscribe() { saturateRateLimiter(); StepVerifier.create( Flux.error(new IOException("BAM!"), true) .transform(RateLimiterOperator.of(rateLimiter))) .expectSubscription() .expectError(RequestNotPermitted.class) .verify(Duration.ofSeconds(1)); assertNoPermitLeft(); } }
@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 shouldEmitRequestNotPermittedException() { saturateRateLimiter(); StepVerifier.create( Flux.just("Event") .transform(RateLimiterOperator.of(rateLimiter, Schedulers.immediate()))) .expectSubscription() .expectError(RequestNotPermitted.class) .verify(Duration.ofSeconds(1)); assertNoPermitLeft(); }
@Test public void shouldEmitEvent() { StepVerifier.create( Flux.just("Event 1", "Event 2") .transform(CircuitBreakerOperator.of(circuitBreaker))) .expectNext("Event 1") .expectNext("Event 2") .verifyComplete(); assertSingleSuccessfulCall(); }