@Test public void onMonoDoOnRequest() { Mono<String> mp = Mono.just("test"); AtomicReference<Long> ref = new AtomicReference<>(); StepVerifier.create(mp.doOnRequest(ref::set), 0) .thenAwait() .thenRequest(123) .expectNext("test") .verifyComplete(); assertThat(ref.get()).isEqualTo(123); }
@Test public void timeoutEvictAll() { StepVerifier.withVirtualTime(() -> Flux.range(1, 5) .onBackpressureBuffer(Duration.ofSeconds(1), Integer.MAX_VALUE, this, VirtualTimeScheduler.get()), 0) .expectSubscription() .expectNoEvent(Duration.ofSeconds(1)) .thenAwait(Duration.ofMinutes(1)) .thenRequest(1) .verifyComplete(); assertThat(evicted).containsExactly(1, 2, 3, 4, 5); }
@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 ignoreRequestZeroThenRequestOneByOne() { StepVerifier.create(Flux.just(1, 2, 3) .flatMap(f -> Flux.just(f * 2)), 0) .consumeSubscriptionWith(s -> s.request(0)) .thenRequest(1) .expectNext(2) .thenRequest(1) .expectNext(4) .thenRequest(1) .expectNext(6) .verifyComplete(); }
@Test public void twoRepeatBackpressured() { AtomicInteger i = new AtomicInteger(); StepVerifier.create(Mono.fromCallable(i::incrementAndGet) .repeat(2), 0) .expectSubscription() .expectNoEvent(Duration.ofMillis(100)) .thenRequest(2) .expectNext(1, 2) .thenRequest(3) .expectNext(3) .verifyComplete(); }
@Test public void callableReturnsNullFused2() { StepVerifier.create(Mono.fromCallable(() -> null) .flux() .subscribeOn(Schedulers.single()) .doOnNext(v -> System.out.println(v)), 1) .expectFusion(Fuseable.ASYNC) .thenRequest(1) .verifyComplete(); }
@Test public void aFluxCanBeTimestamped(){ StepVerifier.withVirtualTime(this::scenario_aFluxCanBeTimestamped, 0) .thenAwait(Duration.ofSeconds(2)) .thenRequest(1) .expectNextMatches(t -> t.getT1() == 2000 && t.getT2().equals("test")) .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 delayedUnboundedScalarThenCancel() { StepVerifier.create(Flux.just(1, 2, 3) .flatMap(Flux::just), 0) .thenAwait() .thenRequest(Long.MAX_VALUE) .expectNext(1, 2, 3) .thenCancel() .verify(); }
@Test public void prematureCancel2() { StepVerifier.create(Flux.range(1, 10000) .flatMap(Flux::just, 2) .cancelOn(Schedulers.single()), 1) .expectNext(1) .thenRequest(2) .expectNext(2, 3) .thenCancel() .verify(); }
@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 request() { Flux<String> flux = Flux.just("foo", "bar"); StepVerifier.create(flux, 1) .thenRequest(1) .expectNext("foo") .thenRequest(1) .expectNext("bar") .expectComplete() .verify(); }
@Test public void aMonoCanBeTimestamped(){ StepVerifier.withVirtualTime(this::scenario_aMonoCanBeTimestamped, 0) .thenAwait(Duration.ofSeconds(2)) .thenRequest(1) .expectNextMatches(t -> t.getT1() == 2000 && t.getT2().equals("test")) .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 ignoreRequestZeroHideAll() { StepVerifier.create(Flux.zip(obj -> (int) obj[0] + (int) obj[1], Flux.just(1) .hide(), Flux.just(2) .hide()), 0) .consumeSubscriptionWith(s -> s.request(0)) .thenRequest(1) .expectNext(3) .verifyComplete(); }
@Test public void aFluxCanBeBenchmarked(){ StepVerifier.withVirtualTime(this::scenario_aFluxCanBeBenchmarked,0) .thenAwait(Duration.ofSeconds(2)) .thenRequest(1) .expectNextMatches(t -> t.getT1() == 2000 && t.getT2().equals("test")) .verifyComplete(); }
@Test public void backpressuredThenCancel() { StepVerifier.withVirtualTime(this::scenario_backpressuredThenCancel, 0) .thenRequest(2) .thenAwait(Duration.ofSeconds(1)) .expectNext(1, 1) .thenAwait(Duration.ofSeconds(1)) .thenRequest(1) .expectNext(2) .thenCancel() .verify(); }
@Test public void aFluxCanBeBenchmarked(){ StepVerifier.withVirtualTime(this::scenario_aFluxCanBeBenchmarked,0) .thenAwait(Duration.ofSeconds(2)) .thenRequest(1) .expectNextMatches(t -> t.getT1() == 2000 && t.getT2().equals("test")) .verifyComplete(); }
@Test public void expectNextCount() { Flux<String> flux = Flux.just("foo", "bar"); StepVerifier.create(flux, 0) .thenRequest(1) .expectNextCount(1) .thenRequest(1) .expectNextCount(1) .expectComplete() .verify(); }