@Test public void disposeCancelsBoth() { AtomicReference<SignalType> s1 = new AtomicReference<>(); AtomicReference<SignalType> s2 = new AtomicReference<>(); StepVerifier.create(new MonoTakeUntilOther<>(Mono.never().doFinally(s1::set), Mono.never().doFinally(s2::set))) .expectSubscription() .expectNoEvent(Duration.ofMillis(100)) .thenCancel() .verify(Duration.ofMillis(500)); assertThat(s1.get()).isEqualTo(SignalType.CANCEL); assertThat(s2.get()).isEqualTo(SignalType.CANCEL); }
@Test public void neverSourceIsCancelled() { AtomicReference<SignalType> signal = new AtomicReference<>(); StepVerifier.withVirtualTime(() -> new MonoTakeUntilOther<>(Mono.never().doFinally(signal::set), Mono.delay(Duration.ofMillis(100))) ) .expectSubscription() .expectNoEvent(Duration.ofMillis(100)) .verifyComplete(); assertThat(signal.get()).isEqualTo(SignalType.CANCEL); }
@Test public void normalFiltered() { StepVerifier.withVirtualTime(() -> Mono.just(1) .filterWhen(v -> Mono.just(v % 2 == 0) .delayElement(Duration.ofMillis(100)))) .expectSubscription() .expectNoEvent(Duration.ofMillis(100)) .verifyComplete(); }
@Test public void errorDelayed() { StepVerifier.create(Flux.just(1) .concatWith(Flux.error(new IOException())) .onBackpressureBuffer(Duration.ofMinutes(1), Integer.MAX_VALUE, v -> {}), 0) .expectSubscription() .expectNoEvent(Duration.ofMillis(50)) .thenRequest(1) .expectNext(1) .verifyError(IOException.class); }
@Test public void takeNever() { StepVerifier.create( Flux.never().take(1)) .expectSubscription() .expectNoEvent(Duration.ofSeconds(1)) .thenCancel() .verify(); }
@Test public void triggerSequenceDoneFirst() { StepVerifier.withVirtualTime(() -> Mono.delay(Duration.ofSeconds(2)) .delayUntil(a -> Mono.just("foo"))) .expectSubscription() .expectNoEvent(Duration.ofSeconds(2)) .expectNext(0L) .verifyComplete(); }
@Test public void testAPIDelayUntil() { StepVerifier.withVirtualTime(() -> Flux.just("foo") .delayUntil(a -> Mono.delay(Duration.ofSeconds(2)))) .expectSubscription() .expectNoEvent(Duration.ofSeconds(2)) .expectNext("foo") .verifyComplete(); }
@Test public void oneRepeatBackpressured() { AtomicInteger i = new AtomicInteger(); StepVerifier.create(Mono.fromCallable(i::incrementAndGet) .repeat(1), 0) .expectSubscription() .expectNoEvent(Duration.ofMillis(100)) .thenRequest(3) .expectNext(1, 2) .verifyComplete(); }
@Test public void reorderingAPISmallRequest() { Flux<Integer> test = Flux.mergeOrdered(Comparator.naturalOrder(), Flux.just(1, 3, 5, 7), Flux.just(2, 4, 6, 8, 10)); StepVerifier.create(test, 5) .expectNext(1, 2, 3, 4) .expectNoEvent(Duration.ofMillis(50)) .thenRequest(5) .expectNext(5, 6, 7, 8, 10) .verifyComplete(); }
@Test public void virtualTimeNoEventExpectationButComplete() { assertThatExceptionOfType(AssertionError.class) .isThrownBy(StepVerifier.withVirtualTime(() -> Flux.empty().hide()) .expectSubscription() .expectNoEvent(Duration.ofMillis(50)) .expectComplete() ::verify) .withMessage("Unexpected completion during a no-event expectation"); }
@Test public void monoApiTestMillis() { StepVerifier.withVirtualTime(() -> Mono.just("foo").delayElement(Duration.ofMillis(5000L))) .expectSubscription() .expectNoEvent(Duration.ofSeconds(5)) .expectNext("foo") .verifyComplete(); }
@Test public void normalIsDelayed() { Mono<String> source = Mono.just("foo").log().hide(); StepVerifier.withVirtualTime(() -> new MonoDelayElement<>(source, 2, TimeUnit.SECONDS, defaultSchedulerForDelay()).log()) .expectSubscription() .expectNoEvent(Duration.ofSeconds(2)) .expectNext("foo") .verifyComplete(); }
@Test public void delayEach() throws InterruptedException { StepVerifier.withVirtualTime(() -> Flux.range(1, 3).delayElements(Duration.ofMillis(1000))) .expectSubscription() .expectNoEvent(Duration.ofSeconds(1)) .expectNext(1) .expectNoEvent(Duration.ofSeconds(1)) .expectNext(2) .expectNoEvent(Duration.ofSeconds(1)) .expectNext(3) .verifyComplete(); }
@Test public void normalBackpressured() { StepVerifier.withVirtualTime( () -> Mono.fromCallable(() -> 1).subscribeOn(Schedulers.single()), 0) .expectSubscription() .expectNoEvent(Duration.ofSeconds(1)) .thenRequest(1) .thenAwait() .expectNext(1) .expectComplete() .verify(); }
@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(timeout = 500) public void noSignalVirtualTime() { StepVerifier.withVirtualTime(Mono::never, 1) .expectSubscription() .expectNoEvent(Duration.ofSeconds(100)) .thenCancel() .verify(); }
@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); }