@Test public void whenMonoError() { MonoProcessor<Tuple2<Integer, Integer>> mp = MonoProcessor.create(); StepVerifier.create(Mono.zip(Mono.<Integer>error(new Exception("test1")), Mono.<Integer>error(new Exception("test2"))) .subscribeWith(mp)) .then(() -> assertThat(mp.isError()).isTrue()) .then(() -> assertThat(mp.isSuccess()).isFalse()) .then(() -> assertThat(mp.isTerminated()).isTrue()) .verifyErrorSatisfies(e -> assertThat(e).hasMessage("test1")); }
@Test public void whenDelayJustMono3() { MonoProcessor<Tuple3<Integer, Integer, Integer>> mp = MonoProcessor.create(); StepVerifier.create(Mono.zipDelayError(Mono.just(1), Mono.just(2), Mono.just(3)) .subscribeWith(mp)) .then(() -> assertThat(mp.isError()).isFalse()) .then(() -> assertThat(mp.isSuccess()).isTrue()) .then(() -> assertThat(mp.isTerminated()).isTrue()) .assertNext(v -> assertThat(v.getT1() == 1 && v.getT2() == 2 && v.getT3() == 3).isTrue()) .verifyComplete(); }
@Test public void whenMonoJust() { MonoProcessor<Tuple2<Integer, Integer>> mp = MonoProcessor.create(); StepVerifier.create(Mono.zip(Mono.just(1), Mono.just(2)) .subscribeWith(mp)) .then(() -> assertThat(mp.isError()).isFalse()) .then(() -> assertThat(mp.isSuccess()).isTrue()) .then(() -> assertThat(mp.isTerminated()).isTrue()) .assertNext(v -> assertThat(v.getT1() == 1 && v.getT2() == 2).isTrue()) .verifyComplete(); }
@Test public void doOnErrorPredicateNot() { AtomicReference<Throwable> ref = new AtomicReference<>(); StepVerifier.create(Flux.error(new TestException()) .doOnError(RuntimeException.class::isInstance, ref::set)) .thenAwait() .then(() -> assertThat(ref.get()) .isNull()) .verifyError(TestException.class); }
@Test public void doOnErrorPredicate() { AtomicReference<Throwable> ref = new AtomicReference<>(); StepVerifier.create(Flux.error(new TestException()) .doOnError(TestException.class::isInstance, ref::set)) .thenAwait() .then(() -> assertThat(ref.get()) .isInstanceOf(TestException.class)) .verifyError(TestException.class); }
@Test public void failAsyncInnerFusion() { UnicastProcessor<Integer> up = UnicastProcessor.create(); StepVerifier.create(Flux.just(1) .hide() .flatMap(f -> up, 1)) .then(() -> up.onNext(1)) .then(() -> up.onNext(2)) .then(() -> up.onError(new Exception("test"))) .expectNext(1, 2) .verifyErrorMessage("test"); }
@Test public void whenDelayJustMono() { MonoProcessor<Tuple2<Integer, Integer>> mp = MonoProcessor.create(); StepVerifier.create(Mono.zipDelayError(Mono.just(1), Mono.just(2)) .subscribeWith(mp)) .then(() -> assertThat(mp.isError()).isFalse()) .then(() -> assertThat(mp.isSuccess()).isTrue()) .then(() -> assertThat(mp.isTerminated()).isTrue()) .assertNext(v -> assertThat(v.getT1() == 1 && v.getT2() == 2).isTrue()) .verifyComplete(); }
@Test public void otherwiseErrorFilter() { MonoProcessor<Integer> mp = MonoProcessor.create(); StepVerifier.create(Mono.<Integer>error(new TestException()) .onErrorResume(TestException.class, e -> Mono.just(1)) .subscribeWith(mp)) .then(() -> assertThat(mp.isError()).isFalse()) .then(() -> assertThat(mp.isSuccess()).isTrue()) .then(() -> assertThat(mp.isTerminated()).isTrue()) .expectNext(1) .verifyComplete(); }
@Test public void takeFusedAsync() { UnicastProcessor<String> up = UnicastProcessor.create(); StepVerifier.create(up.take(2)) .expectFusion(Fuseable.ASYNC) .then(() -> { up.onNext("test"); up.onNext("test2"); }) .expectNext("test", "test2") .verifyComplete(); }
@Test public void mergePublisherPublisher(){ AtomicLong request = new AtomicLong(); StepVerifier.create(Flux.merge(Flux.just(Flux.just(1, 2), Flux.just(3, 4)).doOnRequest(request::set))) .expectNext(1, 2, 3, 4) .then(() -> assertThat(request.get()).isEqualTo(1) ) .verifyComplete(); }
@Test public void twoRepeatNormalSupplier() { AtomicBoolean bool = new AtomicBoolean(true); StepVerifier.create(Flux.range(1, 4) .repeat(2, bool::get)) .expectNext(1, 2, 3, 4) .expectNext(1, 2, 3, 4) .expectNext(1, 2, 3, 4) .then(() -> bool.set(false)) .verifyComplete(); }
@Test public void whenMonoCallable() { MonoProcessor<Tuple2<Integer, Integer>> mp = MonoProcessor.create(); StepVerifier.create(Mono.zip(Mono.fromCallable(() -> 1), Mono.fromCallable(() -> 2)) .subscribeWith(mp)) .then(() -> assertThat(mp.isError()).isFalse()) .then(() -> assertThat(mp.isSuccess()).isTrue()) .then(() -> assertThat(mp.isTerminated()).isTrue()) .assertNext(v -> assertThat(v.getT1() == 1 && v.getT2() == 2).isTrue()) .verifyComplete(); }
@Test public void filterMonoNot() { MonoProcessor<Integer> mp = MonoProcessor.create(); StepVerifier.create(Mono.just(1).filter(s -> s % 2 == 0).subscribeWith(mp)) .then(() -> assertThat(mp.isError()).isFalse()) .then(() -> assertThat(mp.isSuccess()).isTrue()) .then(() -> assertThat(mp.peek()).isNull()) .then(() -> assertThat(mp.isTerminated()).isTrue()) .verifyComplete(); } }
@Test public void otherwiseReturnErrorUnfilter2() { MonoProcessor<Integer> mp = MonoProcessor.create(); StepVerifier.create(Mono.<Integer>error(new TestException()) .onErrorReturn(RuntimeException.class::isInstance, 1) .subscribeWith(mp)) .then(() -> assertThat(mp.isError()).isTrue()) .then(() -> assertThat(mp.isSuccess()).isFalse()) .then(() -> assertThat(mp.isTerminated()).isTrue()) .verifyError(TestException.class); } }
@Test public void failNextIfTerminatedTakeFused() { UnicastProcessor<Integer> up = UnicastProcessor.create(); Hooks.onNextDropped(t -> assertThat(t).isEqualTo(1)); StepVerifier.create(up.take(2)) .then(() -> up.actual.onComplete()) .then(() -> up.actual.onNext(1)) .verifyComplete(); Hooks.resetOnNextDropped(); }
@Test public void coldDisallowsOverflow() { TestPublisher<String> publisher = TestPublisher.createCold(); StepVerifier.create(publisher, 1) .then(() -> publisher.next("foo")).as("should pass") .then(() -> publisher.emit("bar")).as("should fail") .expectNext("foo") .expectErrorMatches(e -> e instanceof IllegalStateException && "Can't deliver value due to lack of requests".equals(e.getMessage())) .verify(); publisher.assertNoRequestOverflow(); }
@Test public void apiTakeUntilOtherShortcircuits() { TestPublisher<String> other = TestPublisher.create(); StepVerifier.withVirtualTime(() -> Mono.delay(Duration.ofMillis(200)) .takeUntilOther(other) ) .thenAwait(Duration.ofMillis(100)) .then(() -> other.next("go")) .verifyComplete(); other.assertCancelled(); }
@Test public void firstMonoJust() { MonoProcessor<Integer> mp = MonoProcessor.create(); StepVerifier.create(Mono.first(Mono.just(1), Mono.just(2)) .subscribeWith(mp)) .then(() -> assertThat(mp.isError()).isFalse()) .then(() -> assertThat(mp.isSuccess()).isTrue()) .then(() -> assertThat(mp.isTerminated()).isTrue()) .expectNext(1) .verifyComplete(); }
@Test public void expectMinRequestedNormal() { TestPublisher<String> publisher = TestPublisher.create(); StepVerifier.create(Flux.from(publisher).limitRate(5)) .then(publisher::assertNotCancelled) .then(() -> publisher.assertMinRequested(5)) .thenCancel() .verify(); publisher.assertCancelled(); publisher.assertNoSubscribers(); publisher.assertMinRequested(0); }