/** * Converts the EventPublisher into a Flux. * * @param eventPublisher the event publisher * @param <T> the type of the event * @return the Flux */ public static <T> Flux<T> toFlux(EventPublisher<T> eventPublisher) { DirectProcessor<T> directProcessor = DirectProcessor.create(); eventPublisher.onEvent(directProcessor::onNext); return directProcessor; } }
/** * Converts the EventPublisher into a Flux. * * @param eventPublisher the event publisher * @param <T> the type of the event * @return the Flux */ public static <T> Flux<T> toFlux(EventPublisher<T> eventPublisher) { DirectProcessor<T> directProcessor = DirectProcessor.create(); eventPublisher.onEvent(directProcessor::onNext); return directProcessor; } }
@Test public void windowStartEndInnerCancel() throws Exception { DirectProcessor<Integer> start = DirectProcessor.create(); DirectProcessor<Integer> end1 = DirectProcessor.create(); DirectProcessor<Integer> end2 = DirectProcessor.create(); Flux<Flux<Integer>> windows = source.windowWhen(start, v -> v == 1 ? end1 : end2); subscribe(windows); start.onNext(1); generateWithCancel(0, 6, 1); verifyInnerCancel(0, i -> i != 2, Arrays.asList(0, 1)); }
@Test(expected = NullPointerException.class) public void onNextNull() { DirectProcessor.create().onNext(null); }
@Test(expected = NullPointerException.class) public void onSubscribeNull() { DirectProcessor.create().onSubscribe(null); }
@Test(expected = NullPointerException.class) public void subscribeNull() { DirectProcessor.create().subscribe((Subscriber<Object>)null); }
@Test public void scanProcessor() { FluxProcessor<String, String> test = DirectProcessor.<String>create().serialize(); assertThat(test.scan(Scannable.Attr.CAPACITY)).isEqualTo(16); assertThat(test.scan(Scannable.Attr.TERMINATED)).isFalse(); assertThat(test.scan(Scannable.Attr.ERROR)).isNull(); test.onError(new IllegalStateException("boom")); assertThat(test.scan(Scannable.Attr.ERROR)).hasMessage("boom"); assertThat(test.scan(Scannable.Attr.TERMINATED)).isTrue(); } }
@Test public void prematureCompleteSourceEmptyDouble() { DirectProcessor<Integer> d = DirectProcessor.create(); StepVerifier.create(Flux.zip(obj -> 0, d, s -> { CoreSubscriber<?> a = ((DirectProcessor.DirectInner) d.inners().findFirst().get()) .actual; Operators.complete(s); a.onComplete(); }, Mono.just(1))) .verifyComplete(); }
@Test public void windowBoundaryInnerCancel() throws Exception { DirectProcessor<Integer> boundaryProcessor = DirectProcessor.create(); Flux<Flux<Integer>> windows = source.window(boundaryProcessor); subscribe(windows); generateWithCancel(0, 6, 1); verifyInnerCancel(0, i -> i != 2, Arrays.asList(0, 1)); }
@Test public void windowBoundaryComplete() throws Exception { DirectProcessor<Integer> boundary = DirectProcessor.create(); Flux<Flux<Integer>> windows = source.window(boundary); subscribe(windows); generate(0, 3); boundary.onNext(1); generateAndComplete(3, 3); verifyMainComplete(Arrays.asList(0, 1, 2), Arrays.asList(3, 4, 5)); }
@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(); }
@Test public void leftDurationThrows() { AssertSubscriber<Object> ts = AssertSubscriber.create(); DirectProcessor<Integer> source1 = DirectProcessor.create(); DirectProcessor<Integer> source2 = DirectProcessor.create(); Flux<Integer> duration1 = Flux.error(new RuntimeException("Forced failure")); Flux<Integer> m = source1.join(source2, just(duration1), just(Flux.never()), add); m.subscribe(ts); source1.onNext(1); ts.assertErrorMessage("Forced failure") .assertNotComplete() .assertNoValues(); }
@Test public void windowBoundaryMainCancelNoNewWindow() throws Exception { DirectProcessor<Integer> boundary = DirectProcessor.create(); Flux<Flux<Integer>> windows = source.window(boundary); subscribe(windows); generate(0, 3); boundary.onNext(1); mainSubscriber.cancel(); generate(3, 1); verifyMainCancelNoNewWindow(1, Arrays.asList(0, 1, 2)); }
@Test public void verifyThenOnCompleteRange() { DirectProcessor<Void> p = DirectProcessor.create(); Flux<String> flux = Flux.range(0, 3) .map(d -> "t" + d) .takeUntilOther(p); StepVerifier.create(flux, 2) .expectNext("t0", "t1") .then(p::onComplete) .expectComplete() .verify(); }
@Test public void windowBoundaryMainCancel() throws Exception { DirectProcessor<Integer> boundary = DirectProcessor.create(); Flux<Flux<Integer>> windows = source.window(boundary); subscribe(windows); generate(0, 3); boundary.onNext(1); generate(3, 1); mainSubscriber.cancel(); generate(4, 2); boundary.onNext(1); generate(6, 10); verifyMainCancel(true, Arrays.asList(0, 1, 2), Arrays.asList(3, 4, 5)); }
@Test public void error() { DirectProcessor<Integer> tp = DirectProcessor.create(); AssertSubscriber<Integer> ts = AssertSubscriber.create(0); tp.onBackpressureLatest().subscribe(ts); tp.onError(new RuntimeException("forced failure")); ts.assertNoValues() .assertNotComplete() .assertError(RuntimeException.class) .assertErrorMessage("forced failure"); }
@Test public void mapperReturnsNull() { AssertSubscriber<Object> ts = AssertSubscriber.create(); DirectProcessor<Integer> sp1 = DirectProcessor.create(); sp1.switchMap(v -> null) .subscribe(ts); sp1.onNext(1); ts.assertNoValues() .assertError(NullPointerException.class) .assertNotComplete(); }
@Test public void subscriberAlreadyCancelled() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); ts.cancel(); DirectProcessor<Integer> tp = DirectProcessor.create(); tp.subscribe(ts); Assert.assertFalse("Subscribers present?", tp.hasDownstreams()); tp.onNext(1); ts.assertNoValues() .assertNotComplete() .assertNoError(); }
@Test public void throttlerReturnsNull() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); DirectProcessor<Integer> sp1 = DirectProcessor.create(); sp1.sampleTimeout(v -> null) .subscribe(ts); sp1.onNext(1); ts.assertNoValues() .assertError(NullPointerException.class) .assertNotComplete(); Assert.assertFalse("sp1 has subscribers?", sp1.hasDownstreams()); }
@Test public void throttlerReturnsNull() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); DirectProcessor<Integer> sp1 = DirectProcessor.create(); sp1.sampleFirst(v -> null) .subscribe(ts); sp1.onNext(1); ts.assertValues(1) .assertError(NullPointerException.class) .assertNotComplete(); Assert.assertFalse("sp1 has subscribers?", sp1.hasDownstreams()); }