@Test public void equalPredicateFailure() { StepVerifier.create(Mono.sequenceEqual(Mono.just("one"), Mono.just("one"), (s1, s2) -> { throw new IllegalStateException("boom"); })) .verifyErrorMessage("boom"); }
@Test public void lazilyEvaluatedSubscribe() { AtomicInteger count = new AtomicInteger(); Flux<Object> error = Flux.error(() -> new IllegalStateException("boom" + count.incrementAndGet())); assertThat(count).as("no op before subscribe").hasValue(0); StepVerifier.create(error.retry(3)) .verifyErrorMessage("boom4"); }
@Test public void failScalarMap() { StepVerifier.create(Mono.just(1) .flatMapMany(f -> { throw new RuntimeException("test"); })) .verifyErrorMessage("test"); }
@Test //FIXME use Violation.NO_CLEANUP_ON_TERMINATE public void failDoubleErrorSilent() { Hooks.onErrorDropped(e -> { }); StepVerifier.create(Flux.zip(obj -> 0, Flux.just(1), Flux.never(), s -> { s.onSubscribe(Operators.emptySubscription()); s.onError(new Exception("test")); s.onError(new Exception("test2")); })) .verifyErrorMessage("test"); Hooks.resetOnErrorDropped(); }
@Test public void normal() { StepVerifier.create(Flux.error(new Exception("test"))) .verifyErrorMessage("test"); }
@Test public void fluxCreateLatestError2() { Flux<String> created = Flux.create(s -> { s.error(new Exception("test")); }, FluxSink.OverflowStrategy.LATEST); StepVerifier.create(created) .verifyErrorMessage("test"); }
@Test public void thenManyError(){ StepVerifier.create(Flux.error(new Exception("test")).thenMany(Flux.just(4, 5, 6))) .verifyErrorMessage("test"); }
@Test public void fluxError() { StepVerifier.create(Mono.error(new Exception("test")).flux()) .verifyErrorMessage("test"); }
@Test public void error() { StepVerifier.create(Flux.error(new IllegalStateException("boom")) .publish() .refCount(1, Duration.ofMillis(500))) .verifyErrorMessage("boom"); }
@Test public void errorHide() { StepVerifier.create(Mono.error(new RuntimeException("forced failure")) .hide() .publishOn(Schedulers.single())) .verifyErrorMessage("forced failure"); } }
@Test public void failCallable() { StepVerifier.create(Flux.zip(obj -> 0, Flux.just(1), Mono.fromCallable(() -> { throw new Exception("test"); }))) .verifyErrorMessage("test"); }
@Test public void errorPropagate() { Mono<Integer> m = Mono.from(Flux.error(new Error("test"))); assertTrue(m instanceof MonoError); StepVerifier.create(m) .verifyErrorMessage("test"); }
@Test public void fluxCreateDropError2() { Flux<String> created = Flux.create(s -> { s.error(new Exception("test")); }, FluxSink.OverflowStrategy.DROP); StepVerifier.create(created) .verifyErrorMessage("test"); }
@Test public void fluxCreateBufferedError2() { Flux<String> created = Flux.create(s -> { s.error(new Exception("test")); }); StepVerifier.create(created) .verifyErrorMessage("test"); }
@Test public void failCallable() { StepVerifier.create(Flux.just(1, 2, 3) .flatMap(d -> Mono.fromCallable(() -> { throw new Exception("test"); }))) .verifyErrorMessage("test"); }
@Test public void failInitial() { Supplier<List<Integer>> as = () -> { throw new RuntimeException("test"); }; StepVerifier.create(Flux.range(1, 10) .parallel(3) .collect(as, List::add)) .verifyErrorMessage("test"); }
@Test public void errorHide() { StepVerifier.create(Flux.error(new Exception("test")) .hide() .last()) .verifyErrorMessage("test"); }
@Test public void supplierThrows() { StepVerifier.create(Mono.fromSupplier(() -> { throw new RuntimeException("forced failure"); })) .verifyErrorMessage("forced failure"); }
@Test public void error() { StepVerifier.create(Mono.error(new RuntimeException("forced failure")) .defaultIfEmpty("blah")) .verifyErrorMessage("forced failure"); }
@Test public void syncFusedCrash() { Flux<Integer> source = Flux.range(1, 10).map(i -> { throw new IllegalArgumentException("boom"); }); StepVerifier.create(Mono.sequenceEqual(source, Flux.range(1, 10).hide())) .verifyErrorMessage("boom"); StepVerifier.create(Mono.sequenceEqual(Flux.range(1, 10).hide(), source)) .verifyErrorMessage("boom"); }