@Override public void subscribe(CoreSubscriber<? super T> actual) { source.publishOn(scheduler) .subscribe(new BulkheadSubscriber<>(bulkhead, actual)); }
@Override public void subscribe(CoreSubscriber<? super T> actual) { source.publishOn(scheduler) .subscribe(new RateLimiterSubscriber<>(rateLimiter, actual)); }
@Override public Mono<Void> handle(ServerHttpRequest request, ServerHttpResponse response) { return response.writeWith(Flux.just("h", "e", "l", "l", "o") .delayElements(Duration.ofMillis(100)) .publishOn(asyncGroup) .collect(dataBufferFactory::allocateBuffer, (buffer, str) -> buffer.write(str.getBytes()))); } }
@Test(expected = RuntimeException.class) public void blockingFirstError() { Flux.error(new RuntimeException("test")) .publishOn(scheduler) .blockFirst(); }
@Test public void subscribeOnDispatchOn() throws InterruptedException { CountDownLatch latch = new CountDownLatch(100); Flux.range(1, 100) .log("testOn", Level.FINE) .subscribeOn(ioGroup) .publishOn(asyncGroup) .limitRate(1) .subscribe(t -> latch.countDown()); assertThat("Not totally dispatched", latch.await(30, TimeUnit.SECONDS)); } @Test
@Test public void blockingLast() { Assert.assertEquals((Integer) 10, Flux.range(1, 10) .publishOn(scheduler) .blockLast()); }
@Test public void blockingFirst() { Assert.assertEquals((Integer) 1, Flux.range(1, 10) .publishOn(scheduler) .blockFirst()); }
@Test public void classicJust() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); Flux.just(1) .publishOn(Schedulers.fromExecutorService(exec)) .subscribe(ts); ts.await(Duration.ofSeconds(5)); ts.assertValues(1) .assertNoError() .assertComplete(); }
@Test public void publishOnFilter() throws Exception { Flux<Long> flux = Flux.interval(Duration.ofMillis(2)).take(255) .publishOn(scheduler) .filter(t -> true) .doOnNext(i -> onNext(i)) .doOnError(e -> onError(e)); verifyRejectedExecutionConsistency(flux, 5); }
@Test public void syncSourceWithNull() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); Flux.just(1, null, 1) .publishOn(Schedulers.fromExecutorService(exec)) .subscribe(ts); ts.await(Duration.ofSeconds(5)); ts.assertValues(1) .assertError(NullPointerException.class) .assertNotComplete(); }
@Test public void subscribeWithAsyncFusion() { Processor<Integer, Integer> processor = EmitterProcessor.create(16); StepVerifier.create(processor) .then(() -> Flux.range(1, 5).publishOn(Schedulers.elastic()).subscribe(processor)) .expectNext(1, 2, 3, 4, 5) .expectComplete() .verify(Duration.ofSeconds(1)); }
@Test public void crossRange() { int count = 1000000; StepVerifier.create(Flux.range(1, count) .flatMap(v -> Flux.range(v, 2), false, 128, 1) .publishOn(Schedulers.fromExecutorService(exec))) .expectNextCount(2 * count) .verifyComplete(); }
@Test public void crossRangeMax() { int count = 1000000; StepVerifier.create(Flux.range(1, count) .flatMap(v -> Flux.range(v, 2), false, 128, 32) .publishOn(Schedulers.fromExecutorService(exec))) .expectNextCount(2 * count) .verifyComplete(); }
@Test public void expectNextAsync() { Flux<String> flux = Flux.just("foo", "bar") .publishOn(Schedulers.parallel()); StepVerifier.create(flux) .expectNext("foo") .expectNext("bar") .expectComplete() .verify(); }
@Test public void verifyFusionModeExpected2() { Flux<String> flux = Flux.just("foo", "bar") .publishOn(Schedulers.immediate()); StepVerifier.create(flux) .expectFusion(Fuseable.SYNC | Fuseable.ASYNC, Fuseable.ASYNC) .expectNext("foo", "bar") .expectComplete() .verify(); }
@Test public void crossRangeMaxUnbounded() { int count = 1000000; StepVerifier.create(Flux.range(1, count) .flatMap(v -> Flux.range(v, 2)) .publishOn(Schedulers.fromExecutorService(exec))) .expectNextCount(2 * count) .verifyComplete(); }
@Test public void discardPollAsyncPredicateMiss() { StepVerifier.create(Flux.just(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) //range uses tryOnNext, so let's use just instead .publishOn(Schedulers.newSingle("discardPollAsync")) .filter(i -> i % 2 == 0) ) .expectFusion(Fuseable.ASYNC) .expectNextCount(5) .expectComplete() .verifyThenAssertThat() .hasDiscardedExactly(1, 3, 5, 7, 9); }
@Test public void fluxCreateError2(){ StepVerifier.create(Flux.create(s -> { s.next("test1"); s.next("test2"); s.next("test3"); s.complete(); }, FluxSink.OverflowStrategy.ERROR).publishOn(Schedulers.parallel())) .expectNext("test1", "test2", "test3") .verifyComplete(); }
@Test public void fluxCreateIgnore2(){ StepVerifier.create(Flux.create(s -> { s.next("test1"); s.next("test2"); s.next("test3"); s.complete(); }, FluxSink.OverflowStrategy.IGNORE).publishOn(Schedulers.parallel())) .expectNext("test1", "test2", "test3") .verifyComplete(); }
@Test public void crossRangeMaxHidden() throws Exception { int count = 1000000; StepVerifier.create(Flux.range(1, count) .hide() .flatMap(v -> Flux.range(v, 2) .hide(), false, 4, 32) .hide() .publishOn(Schedulers.fromExecutorService(exec))) .expectNextCount(2 * count) .verifyComplete(); }