@Test public void thenAwaitThenCancelWaitsForDuration() { Duration verifyDuration = StepVerifier.create(Flux.just("foo", "bar") .delayElements(Duration.ofMillis(500))) .expectSubscription() .thenAwait(Duration.ofMillis(500)) .expectNext("foo") .thenAwait(Duration.ofMillis(200)) .thenCancel() .verify(Duration.ofMillis(1000)); assertThat(verifyDuration.toMillis()).isGreaterThanOrEqualTo(700L); }
@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 shouldEmitErrorWithBulkheadFullException() { bulkhead.isCallPermitted(); StepVerifier.create( Mono.just("Event") .transform(BulkheadOperator.of(bulkhead))) .expectSubscription() .expectError(BulkheadFullException.class) .verify(Duration.ofSeconds(1)); assertThat(bulkhead.getMetrics().getAvailableConcurrentCalls()).isEqualTo(0); }
@Test public void virtualTimeNoEventExpectationButError() { assertThatExceptionOfType(AssertionError.class) .isThrownBy(StepVerifier.withVirtualTime(() -> Flux.error(new IllegalStateException("boom")).hide()) .expectSubscription() .expectNoEvent(Duration.ofMillis(50)) .expectComplete() ::verify) .withMessage("Unexpected error during a no-event expectation: java.lang.IllegalStateException: boom") .withCause(new IllegalStateException("boom")); } }
@Test public void noEventExpectationButError() { assertThatExceptionOfType(AssertionError.class) .isThrownBy(StepVerifier.create(Flux.error(new IllegalStateException("boom")).hide()) .expectSubscription() .expectNoEvent(Duration.ofMillis(50)) .expectComplete() ::verify) .withMessage("Unexpected error during a no-event expectation: java.lang.IllegalStateException: boom") .withCause(new IllegalStateException("boom")); }
@Test public void verifyVirtualTimeNoEventNever() { StepVerifier.withVirtualTime(() -> Mono.never() .log()) .expectSubscription() .expectNoEvent(Duration.ofDays(10000)) .thenCancel() .verify(); }
@Test public void verifyVirtualTimeNoEventInterval() { StepVerifier.withVirtualTime(() -> Flux.interval(Duration.ofSeconds(3)) .take(2)) .expectSubscription() .expectNoEvent(Duration.ofSeconds(3)) .expectNext(0L) .expectNoEvent(Duration.ofSeconds(3)) .expectNext(1L) .expectComplete() .verify(); }
@Test public void bufferLimit() { StepVerifier.create(Flux.range(1, 5) .onBackpressureBuffer(Duration.ofMinutes(1), 1, this, Schedulers.single()), 0) .expectSubscription() .expectNoEvent(Duration.ofMillis(100)) .thenRequest(1) .expectNext(5) .verifyComplete(); assertThat(evicted).containsExactly(1, 2, 3, 4); }
@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 shouldEmitErrorWithBulkheadFullException() { saturateRateLimiter(); StepVerifier.create( Mono.just("Event") .transform(RateLimiterOperator.of(rateLimiter))) .expectSubscription() .expectError(RequestNotPermitted.class) .verify(Duration.ofSeconds(1)); assertNoPermitLeft(); }
@Test public void shouldPropagateError() { StepVerifier.create( Mono.error(new IOException("BAM!")) .transform(RateLimiterOperator.of(rateLimiter))) .expectSubscription() .expectError(IOException.class) .verify(Duration.ofSeconds(1)); assertSinglePermitUsed(); }
@Test public void shouldPropagateError() { StepVerifier.create( Mono.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 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 shouldPropagateError() { StepVerifier.create( Flux.error(new IOException("BAM!")) .transform(RateLimiterOperator.of(rateLimiter))) .expectSubscription() .expectError(IOException.class) .verify(Duration.ofSeconds(1)); assertSinglePermitUsed(); }
@Test public void shouldEmitBulkheadFullExceptionEvenWhenErrorNotOnSubscribe() { bulkhead.isCallPermitted(); StepVerifier.create( Mono.error(new IOException("BAM!")).delayElement(Duration.ofMillis(1)) .transform(BulkheadOperator.of(bulkhead, Schedulers.immediate()))) .expectSubscription() .expectError(BulkheadFullException.class) .verify(Duration.ofSeconds(1)); assertThat(bulkhead.getMetrics().getAvailableConcurrentCalls()).isEqualTo(0); } }
@Test public void shouldEmitBulkheadFullExceptionEvenWhenErrorDuringSubscribe() { bulkhead.isCallPermitted(); StepVerifier.create( Mono.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 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 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 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 shouldEmitRequestNotPermittedExceptionEvenWhenErrorDuringSubscribe() { saturateRateLimiter(); StepVerifier.create( Flux.error(new IOException("BAM!")) .transform(RateLimiterOperator.of(rateLimiter))) .expectSubscription() .expectError(RequestNotPermitted.class) .verify(Duration.ofSeconds(1)); assertNoPermitLeft(); }