@Override public void close() { this.closeProcessor.onComplete(); }
private void generateAndComplete(int start, int count) { generate(start, count); sourceProcessor.onComplete(); generate(start + count, 10); }
@Test public void delayElementShouldNotCancelTwice() throws Exception { DirectProcessor<Long> p = DirectProcessor.create(); AtomicInteger cancellations = new AtomicInteger(); Flux<Long> publishedFlux = p .publish() .refCount(2) .doOnCancel(() -> cancellations.incrementAndGet()); publishedFlux.any(x -> x > 5) .delayElement(Duration.ofMillis(2)) .subscribe(); CompletableFuture<List<Long>> result = publishedFlux.collectList().toFuture(); for (long i = 0; i < 10; i++) { p.onNext(i); Thread.sleep(1); } p.onComplete(); assertThat(result.get(10, TimeUnit.MILLISECONDS).size()).isEqualTo(10); assertThat(cancellations.get()).isEqualTo(2); }
@Test public void advancedHot() { DirectProcessor<String> hotSource = DirectProcessor.create(); Flux<String> hotFlux = hotSource.map(String::toUpperCase); hotFlux.subscribe(d -> System.out.println("Subscriber 1 to Hot Source: "+d)); hotSource.onNext("blue"); hotSource.onNext("green"); hotFlux.subscribe(d -> System.out.println("Subscriber 2 to Hot Source: "+d)); hotSource.onNext("orange"); hotSource.onNext("purple"); hotSource.onComplete(); }
public void completeImmediately(boolean which) { DirectProcessor<Integer> main = DirectProcessor.create(); DirectProcessor<String> other = DirectProcessor.create(); if (which) { main.onComplete(); } else { other.onComplete(); } AssertSubscriber<Integer> ts = AssertSubscriber.create(); main.sample(other).subscribe(ts); Assert.assertFalse("Main subscriber?", main.hasDownstreams()); Assert.assertFalse("Other subscriber?", other.hasDownstreams()); ts.assertNoValues() .assertNoError() .assertComplete(); }
@Test public void oldTimeoutCompleteHasNoEffect() { DirectProcessor<Integer> source = DirectProcessor.create(); DirectProcessor<Integer> tp = DirectProcessor.create(); AssertSubscriber<Integer> ts = AssertSubscriber.create(); source.timeout(tp, v -> Flux.never(), Flux.range(1, 10)) .subscribe(ts); source.onNext(0); tp.onComplete(); source.onComplete(); Assert.assertFalse("Timeout has subscribers?", tp.hasDownstreams()); ts.assertValues(0) .assertComplete() .assertNoError(); }
@Test public void notEnoughRequests() { DirectProcessor<Integer> tp = DirectProcessor.create(); StepVerifier.create(tp, 1L) .then(() -> { tp.onNext(1); tp.onNext(2); tp.onComplete(); }) .expectNext(1) .expectError(IllegalStateException.class) .verify(); }
@Test public void fused() { DirectProcessor<Integer> dp1 = DirectProcessor.create(); DirectProcessor<Integer> dp2 = DirectProcessor.create(); AssertSubscriber<Integer> ts = AssertSubscriber.create(); ts.requestedFusionMode(Fuseable.ANY); Flux.combineLatest(dp1, dp2, (a, b) -> a + b) .subscribe(ts); dp1.onNext(1); dp1.onNext(2); dp2.onNext(10); dp2.onNext(20); dp2.onNext(30); dp1.onNext(3); dp1.onComplete(); dp2.onComplete(); ts.assertFuseableSource() .assertFusionMode(Fuseable.ASYNC) .assertValues(12, 22, 32, 33); }
@Test public void someDrops() { DirectProcessor<Integer> tp = DirectProcessor.create(); AssertSubscriber<Integer> ts = AssertSubscriber.create(0); List<Integer> drops = new ArrayList<>(); tp.onBackpressureDrop(drops::add) .subscribe(ts); tp.onNext(1); ts.request(2); tp.onNext(2); tp.onNext(3); tp.onNext(4); ts.request(1); tp.onNext(5); tp.onComplete(); ts.assertValues(2, 3, 5) .assertComplete() .assertNoError(); Assert.assertEquals(Arrays.asList(1, 4), drops); }
@Test public void allDistinctConditional() { DirectProcessor<Integer> dp = new DirectProcessor<>(); AssertSubscriber<Integer> ts = dp.distinctUntilChanged() .filter(v -> true) .subscribeWith(AssertSubscriber.create()); dp.onNext(1); dp.onNext(2); dp.onNext(3); dp.onComplete(); ts.assertValues(1, 2, 3).assertComplete(); }
@Test public void noswitch() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); DirectProcessor<Integer> sp1 = DirectProcessor.create(); DirectProcessor<Integer> sp2 = DirectProcessor.create(); sp1.switchMap(v -> sp2) .subscribe(ts); sp1.onNext(1); sp2.onNext(10); sp2.onNext(20); sp2.onNext(30); sp2.onNext(40); sp2.onComplete(); ts.assertValues(10, 20, 30, 40) .assertNoError() .assertNotComplete(); sp1.onComplete(); ts.assertValues(10, 20, 30, 40) .assertNoError() .assertComplete(); }
@Test public void normal2() { AssertSubscriber<Object> ts = AssertSubscriber.create(); DirectProcessor<Integer> source1 = DirectProcessor.create(); DirectProcessor<Integer> source2 = DirectProcessor.create(); Flux<Integer> m = source1.join(source2, just(Flux.never()), just(Flux.never()), add); m.subscribe(ts); source1.onNext(1); source1.onNext(2); source1.onComplete(); source2.onNext(16); source2.onNext(32); source2.onNext(64); source2.onComplete(); ts.assertValues(17, 18, 33, 34, 65, 66) .assertComplete() .assertNoError(); }
@Test public void oldTimeoutErrorHasNoEffect() { DirectProcessor<Integer> source = DirectProcessor.create(); DirectProcessor<Integer> tp = DirectProcessor.create(); AssertSubscriber<Integer> ts = AssertSubscriber.create(); source.timeout(tp, v -> Flux.never(), Flux.range(1, 10)) .subscribe(ts); source.onNext(0); tp.onError(new RuntimeException("forced failure")); source.onComplete(); Assert.assertFalse("Timeout has subscribers?", tp.hasDownstreams()); ts.assertValues(0) .assertComplete() .assertNoError(); }
@Test public void mainErrorsDelayEnd() { DirectProcessor<Integer> main = DirectProcessor.create(); final DirectProcessor<Integer> inner = DirectProcessor.create(); AssertSubscriber<Integer> ts = main.flatMapSequentialDelayError(t -> inner, 32, 32) .subscribeWith(AssertSubscriber.create()); main.onNext(1); main.onNext(2); inner.onNext(2); ts.assertValues(2); main.onError(new RuntimeException("Forced failure")); ts.assertNoError(); inner.onNext(3); inner.onComplete(); ts.assertValues(2, 3, 2, 3) .assertErrorMessage("Forced failure"); }
@Test public void normal1() { AssertSubscriber<Object> ts = AssertSubscriber.create(); DirectProcessor<Integer> source1 = DirectProcessor.create(); DirectProcessor<Integer> source2 = DirectProcessor.create(); Flux<Integer> m = source1.join(source2, just(Flux.never()), just(Flux.never()), add); m.subscribe(ts); source1.onNext(1); source1.onNext(2); source1.onNext(4); source2.onNext(16); source2.onNext(32); source2.onNext(64); source1.onComplete(); source2.onComplete(); ts.assertValues(17, 18, 20, 33, 34, 36, 65, 66, 68) .assertComplete() .assertNoError(); }
@Test public void timeoutRequested() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); DirectProcessor<Integer> source = DirectProcessor.create(); DirectProcessor<Integer> tp = DirectProcessor.create(); source.timeout(tp, v -> tp) .subscribe(ts); tp.onNext(1); source.onNext(2); source.onComplete(); ts.assertNoValues() .assertError(TimeoutException.class) .assertNotComplete(); }
@Test public void mainErrorsImmediate() { DirectProcessor<Integer> main = DirectProcessor.create(); final DirectProcessor<Integer> inner = DirectProcessor.create(); AssertSubscriber<Integer> ts = main.flatMapSequential(t -> inner) .subscribeWith(AssertSubscriber.create()); main.onNext(1); main.onNext(2); inner.onNext(2); ts.assertValues(2); main.onError(new RuntimeException("Forced failure")); assertFalse("inner has subscribers?", inner.hasDownstreams()); inner.onNext(3); inner.onComplete(); ts.assertValues(2).assertErrorMessage("Forced failure"); }
@Test public void mainError() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); DirectProcessor<Integer> sp1 = DirectProcessor.create(); DirectProcessor<Integer> sp2 = DirectProcessor.create(); sp1.switchMap(v -> sp2) .subscribe(ts); sp1.onNext(1); sp1.onError(new RuntimeException("forced failure")); sp2.onNext(10); sp2.onNext(20); sp2.onNext(30); sp2.onNext(40); sp2.onComplete(); ts.assertNoValues() .assertError(RuntimeException.class) .assertErrorMessage("forced failure") .assertNotComplete(); }
@Test public void terminatedNormally() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); DirectProcessor<Integer> tp = DirectProcessor.create(); tp.onComplete(); tp.subscribe(ts); Assert.assertFalse("Subscribers present?", tp.hasDownstreams()); Assert.assertTrue("Not completed?", tp.hasCompleted()); Assert.assertNull("Has error?", tp.getError()); Assert.assertFalse("Has error?", tp.hasError()); ts.assertNoValues() .assertComplete() .assertNoError(); }
@Test public void oldTimeoutHasNoEffect() { DirectProcessor<Integer> source = DirectProcessor.create(); DirectProcessor<Integer> tp = DirectProcessor.create(); AssertSubscriber<Integer> ts = AssertSubscriber.create(); source.timeout(tp, v -> Flux.never(), Flux.range(1, 10)) .subscribe(ts); source.onNext(0); tp.onNext(1); source.onComplete(); Assert.assertFalse("Timeout has subscribers?", tp.hasDownstreams()); ts.assertValues(0) .assertComplete() .assertNoError(); }