@Test public void subscriberCancels() { DirectProcessor<Integer> main = DirectProcessor.create(); DirectProcessor<String> other = DirectProcessor.create(); AssertSubscriber<Integer> ts = AssertSubscriber.create(); main.sample(other).subscribe(ts); Assert.assertTrue("Main no subscriber?", main.hasDownstreams()); Assert.assertTrue("Other no subscriber?", other.hasDownstreams()); ts.cancel(); Assert.assertFalse("Main no subscriber?", main.hasDownstreams()); Assert.assertFalse("Other no subscriber?", other.hasDownstreams()); ts.assertNoValues() .assertNoError() .assertNotComplete(); }
@Test @SuppressWarnings("unchecked") public void bufferSupplierThrows() { DirectProcessor<Integer> sp1 = DirectProcessor.create(); FluxBufferPredicate<Integer, List<Integer>> bufferUntil = new FluxBufferPredicate<>( sp1, i -> i % 3 == 0, () -> { throw new RuntimeException("supplier failure"); }, FluxBufferPredicate.Mode.UNTIL); Assert.assertFalse("sp1 has subscribers?", sp1.hasDownstreams()); StepVerifier.create(bufferUntil) .expectErrorMessage("supplier failure") .verify(); }
@Test public void bufferSupplierReturnsNull() { DirectProcessor<Integer> sp1 = DirectProcessor.create(); FluxBufferPredicate<Integer, List<Integer>> bufferUntil = new FluxBufferPredicate<>( sp1, i -> i % 3 == 0, () -> null, FluxBufferPredicate.Mode.UNTIL); Assert.assertFalse("sp1 has subscribers?", sp1.hasDownstreams()); StepVerifier.create(bufferUntil) .then(() -> sp1.onNext(1)) .expectErrorMatches(t -> t instanceof NullPointerException && "The bufferSupplier returned a null initial buffer".equals(t.getMessage())) .verify(); }
@Test public void throttlerError() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); DirectProcessor<Integer> sp1 = DirectProcessor.create(); DirectProcessor<Integer> sp2 = DirectProcessor.create(); DirectProcessor<Integer> sp3 = DirectProcessor.create(); sp1.sampleFirst(v -> v == 1 ? sp2 : sp3) .subscribe(ts); sp1.onNext(1); sp2.onError(new RuntimeException("forced failure")); ts.assertValues(1) .assertError(RuntimeException.class) .assertErrorMessage("forced failure") .assertNotComplete(); Assert.assertFalse("sp1 has subscribers?", sp1.hasDownstreams()); Assert.assertFalse("sp1 has subscribers?", sp2.hasDownstreams()); Assert.assertFalse("sp1 has subscribers?", sp3.hasDownstreams()); }
@Test public void bufferSupplierReturnsNUll() { AssertSubscriber<List<Integer>> ts = AssertSubscriber.create(); DirectProcessor<Integer> sp1 = DirectProcessor.create(); DirectProcessor<Integer> sp2 = DirectProcessor.create(); sp1.buffer(sp2, (Supplier<List<Integer>>) () -> null) .subscribe(ts); Assert.assertFalse("sp1 has subscribers?", sp1.hasDownstreams()); Assert.assertFalse("sp2 has subscribers?", sp2.hasDownstreams()); ts.assertNoValues() .assertError(NullPointerException.class) .assertNotComplete(); }
@Test public void bufferSupplierThrows() { AssertSubscriber<List<Integer>> ts = AssertSubscriber.create(); DirectProcessor<Integer> sp1 = DirectProcessor.create(); DirectProcessor<Integer> sp2 = DirectProcessor.create(); sp1.buffer(sp2, (Supplier<List<Integer>>) () -> { throw new RuntimeException("forced failure"); }) .subscribe(ts); Assert.assertFalse("sp1 has subscribers?", sp1.hasDownstreams()); Assert.assertFalse("sp2 has subscribers?", sp2.hasDownstreams()); ts.assertNoValues() .assertError(RuntimeException.class) .assertErrorMessage("forced failure") .assertNotComplete(); }
@Test public void mainError() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); DirectProcessor<Integer> sp1 = DirectProcessor.create(); DirectProcessor<Integer> sp2 = DirectProcessor.create(); sp1.sampleTimeout(v -> sp2) .subscribe(ts); sp1.onNext(1); sp1.onError(new RuntimeException("forced failure")); ts.assertNoValues() .assertError(RuntimeException.class) .assertErrorMessage("forced failure") .assertNotComplete(); Assert.assertFalse("sp1 has subscribers?", sp1.hasDownstreams()); Assert.assertFalse("sp2 has subscribers?", sp2.hasDownstreams()); }
@Test public void throttlerError() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); DirectProcessor<Integer> sp1 = DirectProcessor.create(); DirectProcessor<Integer> sp2 = DirectProcessor.create(); sp1.sampleTimeout(v -> sp2) .subscribe(ts); sp1.onNext(1); sp2.onError(new RuntimeException("forced failure")); ts.assertNoValues() .assertError(RuntimeException.class) .assertErrorMessage("forced failure") .assertNotComplete(); Assert.assertFalse("sp1 has subscribers?", sp1.hasDownstreams()); Assert.assertFalse("sp2 has subscribers?", sp2.hasDownstreams()); }
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 throttlerThrows() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); DirectProcessor<Integer> sp1 = DirectProcessor.create(); sp1.sampleFirst(v -> { throw new RuntimeException("forced failure"); }) .subscribe(ts); sp1.onNext(1); ts.assertValues(1) .assertError(RuntimeException.class) .assertErrorMessage("forced failure") .assertNotComplete(); Assert.assertFalse("sp1 has subscribers?", sp1.hasDownstreams()); }
@Test public void subscriberCancels() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); DirectProcessor<Integer> tp = DirectProcessor.create(); tp.subscribe(ts); Assert.assertTrue("No Subscribers present?", tp.hasDownstreams()); tp.onNext(1); ts.assertValues(1) .assertNoError() .assertNotComplete(); ts.cancel(); Assert.assertFalse("Subscribers present?", tp.hasDownstreams()); tp.onNext(2); ts.assertValues(1) .assertNotComplete() .assertNoError(); }
@Test public void terminatedWithError() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); DirectProcessor<Integer> tp = DirectProcessor.create(); tp.onError(new RuntimeException("forced failure")); tp.subscribe(ts); Assert.assertFalse("Subscribers present?", tp.hasDownstreams()); Assert.assertFalse("Completed?", tp.hasCompleted()); Assert.assertNotNull("No error?", tp.getError()); Assert.assertTrue("No error?", tp.hasError()); Throwable e = tp.getError(); Assert.assertTrue("Wrong exception? " + e, RuntimeException.class.isInstance(e)); Assert.assertEquals("forced failure", e.getMessage()); ts.assertNoValues() .assertNotComplete() .assertError(RuntimeException.class) .assertErrorMessage("forced failure"); }
@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()); }
@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 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 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 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 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(); }