@Test public void backpressureConditionalTest() { Flux<Integer> publisher = Flux.range(0, 10000); AtomicLong requested = new AtomicLong(); Flux<String> switchTransformed = publisher.doOnRequest(requested::addAndGet) .switchOnFirst((first, innerFlux) -> innerFlux.map(String::valueOf)) .filter(e -> false); StepVerifier.create(switchTransformed, 0) .thenRequest(1) .expectComplete() .verify(Duration.ofSeconds(10)); Assertions.assertThat(requested.get()).isEqualTo(2L); }
@Test public void streamClosedOnCancelSlowPathConditional() { AtomicInteger closed = new AtomicInteger(); Stream<String> source = Stream.of("foo", "bar", "baz") .onClose(closed::incrementAndGet); StepVerifier.create(Flux.fromStream(source).filter(i -> true), 0) .thenRequest(1) .expectNext("foo") .thenCancel() .verify(); assertThat(closed.get()).isEqualTo(1); }
@Test @SuppressWarnings("unchecked") //safe varargs public void fusedThrowsInPostEmissionCheckDelayed() { new FluxMergeOrdered<>(2, Queues.small(), Comparator.naturalOrder(), Flux.just(1).map(v -> { throw new IllegalArgumentException("boom"); }), Flux.just(2, 3)) .as(f -> StepVerifier.create(f, 0L)) .thenRequest(2) .expectNext(2, 3) .verifyErrorMessage("boom"); }
@Test public void onBackpressureBuffer() { StepVerifier.create(Flux.range(1, 100) .onBackpressureBuffer(), 0) .thenRequest(5) .expectNext(1, 2, 3, 4, 5) .thenAwait() .thenRequest(90) .expectNextCount(90) .thenAwait() .thenRequest(5) .expectNext(96, 97, 98, 99, 100) .verifyComplete(); }
@Test public void onBackpressureBufferMaxCallbackOverflow() { AtomicInteger last = new AtomicInteger(); StepVerifier.create(Flux.range(1, 100) .hide() .onBackpressureBuffer(8, last::set, BufferOverflowStrategy.ERROR), 0) .thenRequest(7) .expectNext(1, 2, 3, 4, 5, 6, 7) .then(() -> assertThat(last.get()).isEqualTo(16)) .thenRequest(9) .expectNextCount(8) .verifyErrorMatches(Exceptions::isOverflow); }
@Test public void onBackpressureBufferMaxCallback() { AtomicInteger last = new AtomicInteger(); StepVerifier.create(Flux.range(1, 100) .hide() .onBackpressureBuffer(8, last::set), 0) .thenRequest(7) .expectNext(1, 2, 3, 4, 5, 6, 7) .then(() -> assertThat(last.get()).isEqualTo(16)) .thenRequest(9) .expectNextCount(8) .verifyErrorMatches(Exceptions::isOverflow); }
@Test public void onBackpressureBufferMaxCallbackOverflow3() { AtomicInteger last = new AtomicInteger(); StepVerifier.create(Flux.range(1, 100) .hide() .onBackpressureBuffer(8, last::set, BufferOverflowStrategy.DROP_LATEST), 0) .thenRequest(7) .expectNext(1, 2, 3, 4, 5, 6, 7) .then(() -> assertThat(last.get()).isEqualTo(100)) .thenRequest(9) .expectNext(8, 9, 10, 11, 12, 13, 14, 15) .verifyComplete(); }
@Test public void failCombinedFusedError() { StepVerifier.create(Flux.zip(obj -> 0, Flux.just(1, null), Flux.just(2, 3)), 0) .thenRequest(1) .expectNext(0) .verifyError(NullPointerException.class); }
@Test public void ignoreSyncFusedRequest() { StepVerifier.create(Flux.just(1, 2, 3) .flatMap(f -> Flux.range(f, 2), 1), 0) .thenRequest(1) .thenCancel() .verify(); }
@Test public void backpressuredScalarThenCancel(){ StepVerifier.create(Flux.just(1, 2, 3).flatMap(Flux::just), 0) .thenRequest(2) .expectNext(1, 2) .thenCancel() .verify(); }
@Test public void initialBoundedThenUnboundedRequestDoesntOverflow() { TestPublisher<String> publisher = TestPublisher.createNoncompliant( REQUEST_OVERFLOW); StepVerifier.create(publisher, 2) .thenRequest(Long.MAX_VALUE - 2) .then(() -> publisher.emit("foo", "bar", "baz")) .expectNext("foo", "bar", "baz") .expectComplete() .verify(); }
@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 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 onBackpressureDrop() { StepVerifier.create(Flux.range(1, 100) .onBackpressureDrop(), 0) .thenRequest(5) .expectNext(1, 2, 3, 4, 5) .verifyComplete(); }
@Test public void onBackpressureBufferMax() { StepVerifier.create(Flux.range(1, 100) .hide() .onBackpressureBuffer(8), 0) .thenRequest(7) .expectNext(1, 2, 3, 4, 5, 6, 7) .thenAwait() .verifyErrorMatches(Exceptions::isOverflow); }
@Test public void verifyVirtualTimeOnErrorAsync() { VirtualTimeScheduler vts = VirtualTimeScheduler.create(); StepVerifier.withVirtualTime(() -> Flux.just(123) .subscribeOn(vts), () -> vts, 0) .thenRequest(1) .thenAwait() .expectNext(123) .expectComplete() .verify(); }
@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(); }
@Test public void handleBackpressuredBothConditional() { TestPublisher<String> ts = TestPublisher.create(); StepVerifier.create(ts.flux() .as(this::filterTest2), 0) .thenRequest(2) .then(() -> ts.next("test0", "test1")) .expectNext("test0", "test1") .thenRequest(1) .then(() -> ts.next("test2")) .expectNext("test2") .verifyComplete(); }
@Test @SuppressWarnings("unchecked") //safe varargs public void secondErrorsBackpressuredDelayed() { new FluxMergeOrdered<>(2, Queues.small(), Comparator.naturalOrder(), Flux.just(1, 3, 5, 7), Flux.error(new IOException("boom")) ) .as(f -> StepVerifier.create(f, 0L)) .thenRequest(4) .expectNext(1, 3, 5, 7) .verifyError(IOException.class); }
@Test @SuppressWarnings("unchecked") //safe varargs public void firstErrorsBackpressuredDelayed() { new FluxMergeOrdered<>(2, Queues.small(), Comparator.naturalOrder(), Flux.error(new IOException("boom")), Flux.just(2, 4, 6, 8)) .as(f -> StepVerifier.create(f, 0L)) .thenRequest(4) .expectNext(2, 4, 6, 8) .verifyError(IOException.class); }