@Test public void fromPublishersDefaultPrefetchIsMinusOne() { assertThat(ParallelFlux.from(Flux.range(1, 5), Flux.range(5, 5)) .getPrefetch()).isEqualTo(-1); }
@Test public void scannableNameParallelFluxDefaultsToToString() { final ParallelFlux<Integer> flux = ParallelFlux.from(Mono.just(1)) .map(i -> i + 10); assertThat(Scannable.from(flux).name()) .isEqualTo(Scannable.from(flux).stepName()) .isEqualTo("map"); }
@Test public void fromZeroParallelismRejected() { Assertions.assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ParallelFlux.from(Mono.just(1), 0)) .withMessage("parallelism > 0 required but it was 0"); }
@Test public void fromNegativeParallelismRejected() { Assertions.assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ParallelFlux.from(Mono.just(1), -1)) .withMessage("parallelism > 0 required but it was -1"); }
@Test public void namedParallelFluxTest() { ParallelFlux<Integer> named1 = ParallelFlux.from(Mono.just(1)) .name("100s"); ParallelFlux<Integer> named2 = named1.filter(i -> i % 3 == 0) .name("multiple of 3 100s") .hide(); assertThat(Scannable.from(named1).name()).isEqualTo("100s"); assertThat(Scannable.from(named2).name()).isEqualTo("multiple of 3 100s"); }
@Test public void namedOverridenParallelFluxTest() { ParallelFlux<Integer> named1 = ParallelFlux.from(Mono.just(1)) .name("1s") .name("100s"); ParallelFlux<Integer> named2 = named1.filter(i -> i % 3 == 0) .name("multiple of 3 100s") .hide(); assertThat(Scannable.from(named1).name()).isEqualTo("100s"); assertThat(Scannable.from(named2).name()).isEqualTo("multiple of 3 100s"); }
@Test public void sequentialZeroPrefetchRejected() { ParallelFlux<Integer> validSoFar = ParallelFlux.from(Mono.just(1)); Assertions.assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> validSoFar.sequential(0)) .withMessage("prefetch > 0 required but it was 0"); }
@Test public void sequentialNegativePrefetchRejected() { ParallelFlux<Integer> validSoFar = ParallelFlux.from(Mono.just(1)); Assertions.assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> validSoFar.sequential(-1)) .withMessage("prefetch > 0 required but it was -1"); }
@Test public void testConcatMapDelayErrorPrefetchDelayUntilEnd() { ParallelFlux<Integer> pf = ParallelFlux.from(Flux.range(1, 4), 2) .concatMapDelayError(i -> { if (i == 1) return Mono.error(new IllegalStateException("boom")); return Flux.just(i, 100 * i); }, false, 4); assertThat(pf.getPrefetch()).isEqualTo(4); StepVerifier.create(pf) .verifyErrorMessage("boom"); }
@Test public void fromZeroPrefetchRejected() { Assertions.assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ParallelFlux.from(Mono.just(1), 1, 0, Queues.small())) .withMessage("prefetch > 0 required but it was 0"); }
@Test public void fromPublishersSequentialSubscribe() { List<Integer> values = Collections.synchronizedList(new ArrayList<>(10)); ParallelFlux.from(Flux.range(1, 3), Flux.range(4, 3)) .runOn(Schedulers.parallel()) .doOnNext(values::add) .sequential() .blockLast(); assertThat(values) .hasSize(6) .containsExactlyInAnyOrder(1, 2, 3, 4, 5, 6); }
@Test public void fromNullPublisherRejected() { Assertions.assertThatExceptionOfType(NullPointerException.class) .isThrownBy(() -> ParallelFlux.from((Publisher<?>) null)) .withMessage("source"); }
@Test public void runOnZeroPrefetchRejected() { ParallelFlux<Integer> validSoFar = ParallelFlux.from(Mono.just(1)); Assertions.assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> validSoFar.runOn(Schedulers.parallel(), 0)) .withMessage("prefetch > 0 required but it was 0"); }
@Test public void runOnNegativePrefetchRejected() { ParallelFlux<Integer> validSoFar = ParallelFlux.from(Mono.just(1)); Assertions.assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> validSoFar.runOn(Schedulers.parallel(), -1)) .withMessage("prefetch > 0 required but it was -1"); }
@Test public void testConcatMapPrefetch() { ParallelFlux<Integer> pf = ParallelFlux.from(Flux.range(1, 4), 2) .concatMap(i -> Flux.just(i, 100 * i), 4); assertThat(pf.getPrefetch()).isEqualTo(4); StepVerifier.create(pf) .expectNext(1, 100, 2, 200, 3, 300, 4, 400) .verifyComplete(); }
@Test public void from() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); ParallelFlux.from(Flux.range(1, 5), Flux.range(6, 5)) .sequential() .subscribe(ts); ts.assertContainValues(new HashSet<>(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))) .assertNoError() .assertComplete(); }
@Test public void transformChangesPrefetch() { assertThat(ParallelFlux.from(Flux.range(1, 10), 3, 12, Queues.small()) .transform(pf -> pf.runOn(Schedulers.parallel(), 3) .log() .hide()) .getPrefetch()) .isEqualTo(3); }
@Test public void testFlatMapDelayErrorMaxConcurrency() { ParallelFlux<Integer> pf = ParallelFlux.from(Flux.range(1, 4), 2) .flatMap(i -> { if (i == 1) return Mono.<Integer>error(new IllegalStateException("boom")).hide(); return Flux.just(i, 100 * i); }, true, 2); StepVerifier.create(pf) .expectNext(2, 200, 3, 300, 4, 400) .verifyErrorMessage("boom"); }
@Test public void testConcatMapDelayError() { ParallelFlux<Integer> pf = ParallelFlux.from(Flux.range(1, 4), 2) .concatMapDelayError(i -> { if (i == 1) return Mono.<Integer>error(new IllegalStateException("boom")).hide(); return Flux.just(i, 100 * i); }); StepVerifier.create(pf) .expectNext(2, 200, 3, 300, 4, 400) .verifyErrorMessage("boom"); }