/** * Has this signal an item associated with it ? (which only happens if it is an * (onNext) signal) * * @return a boolean indicating whether or not this signal has an item associated with * it */ default boolean hasValue() { return isOnNext() && get() != null; }
MonoCacheTime(Mono<? extends T> source, Function<? super T, Duration> valueTtlGenerator, Function<Throwable, Duration> errorTtlGenerator, Supplier<Duration> emptyTtlGenerator, Scheduler clock) { super(source); this.ttlGenerator = sig -> { if (sig.isOnNext()) return valueTtlGenerator.apply(sig.get()); if (sig.isOnError()) return errorTtlGenerator.apply(sig.getThrowable()); return emptyTtlGenerator.get(); }; this.clock = clock; @SuppressWarnings("unchecked") Signal<T> emptyState = (Signal<T>) EMPTY; this.state = emptyState; }
private void addExpectedValue(T value) { String desc = String.format("expectNext(%s)", value); checkPotentialHang(1, desc); SignalEvent<T> event = new SignalEvent<>((signal, se) -> { if (!signal.isOnNext()) { return errorFormatter.failOptional(se, "expected: onNext(%s); actual: %s", value, signal); } else if (!Objects.equals(value, signal.get())) { return errorFormatter.failOptional(se, "expected value: %s; actual value: %s", value, signal.get()); } else { return Optional.empty(); } }, desc); this.script.add(event); }
@Test public void materialize2() { StepVerifier.create(Flux.just("Three", "Two") .concatWith(Flux.error(new RuntimeException("test"))) .materialize()) .expectNextMatches(s -> s.isOnNext() && "Three".equals(s.get())) .expectNextMatches(s -> s.isOnNext() && "Two".equals(s.get())) .expectNextMatches(s -> s.isOnError() && s.getThrowable() != null && "test".equals(s.getThrowable().getMessage())) .verifyComplete(); }
private DefaultStepVerifierBuilder<T> consumeNextWith(Consumer<? super T> consumer, String description) { Objects.requireNonNull(consumer, "consumer"); checkPotentialHang(1, description); SignalEvent<T> event = new SignalEvent<>((signal, se) -> { if (!signal.isOnNext()) { return errorFormatter.failOptional(se, "expected: onNext(); actual: %s", signal); } else { consumer.accept(signal.get()); return Optional.empty(); } }, description); this.script.add(event); return this; }
@Test public void testDoOnEachSignal() { List<Signal<Integer>> signals = new ArrayList<>(4); Mono<Integer> mono = Mono.just(1) .doOnEach(signals::add); StepVerifier.create(mono) .expectSubscription() .expectNext(1) .expectComplete() .verify(); assertThat(signals.size(), is(2)); assertThat("onNext", signals.get(0).get(), is(1)); assertTrue("onComplete expected", signals.get(1).isOnComplete()); }
@Test public void materialize() { StepVerifier.create(Flux.just("Three", "Two", "One") .materialize()) .expectNextMatches(s -> s.isOnNext() && "Three".equals(s.get())) .expectNextMatches(s -> s.isOnNext() && "Two".equals(s.get())) .expectNextMatches(s -> s.isOnNext() && "One".equals(s.get())) .expectNextMatches(Signal::isOnComplete) .verifyComplete(); }
@Test public void materialize() { StepVerifier.create(Mono.just("Three") .materialize()) .expectNextMatches(s -> s.isOnNext() && s.get() .equals("Three")) .verifyComplete(); }
@Test public void sourceSubscribedOnce() { AtomicInteger subCount = new AtomicInteger(); Flux<Integer> source = Flux.range(1, 10) .hide() .doOnSubscribe(subscription -> subCount.incrementAndGet()); StepVerifier.create(source.switchOnFirst((s, f) -> f.filter(v -> v % 2 == s.get()))) .expectNext(1, 3, 5, 7, 9) .verifyComplete(); Assertions.assertThat(subCount).hasValue(1); }
@Test public void shouldSendOnNextSignal() { Signal<? extends Long>[] first = new Signal[1]; StepVerifier.create(Flux.just(1L) .switchOnFirst((s, f) -> { first[0] = s; return f; })) .expectSubscription() .expectNext(1L) .expectComplete() .verify(); Assertions.assertThat((long) first[0].get()).isEqualTo(1L); }
@Test public void mismatchAtBeginningWhile() { StepVerifier.create(Flux.just("#", "red", "green") .windowWhile(s -> !s.equals("#")) .flatMap(Flux::materialize) .map(sig -> sig.isOnComplete() ? "END" : sig.get())) .expectNext("END") .expectNext("red", "green", "END") .verifyComplete(); }
@Test public void mismatchAtBeginningUntil() { StepVerifier.create(Flux.just("#", "red", "green") .windowUntil(s -> s.equals("#")) .flatMap(Flux::materialize) .map(sig -> sig.isOnComplete() ? "END" : sig.get())) .expectNext("#", "END") .expectNext("red", "green", "END") .verifyComplete(); }
@Test public void mismatchAtBeginningUntilCutBefore() { StepVerifier.create(Flux.just("#", "red", "green") .windowUntil(s -> s.equals("#"), true) .flatMap(Flux::materialize) .map(sig -> sig.isOnComplete() ? "END" : sig.get())) .expectNext("END") .expectNext("#", "red", "green", "END") .verifyComplete(); }
@Test public void apiUntil() { StepVerifier.create(Flux.just("red", "green", "#", "orange", "blue", "#", "black", "white") .windowUntil(color -> color.equals("#")) .flatMap(Flux::materialize) .map(s -> s.isOnComplete() ? "WINDOW CLOSED" : s.get())) .expectNext("red", "green", "#", "WINDOW CLOSED") .expectNext("orange", "blue", "#", "WINDOW CLOSED") .expectNext("black", "white", "WINDOW CLOSED") .verifyComplete(); }
@Test public void apiUntilCutAfter() { StepVerifier.create(Flux.just("red", "green", "#", "orange", "blue", "#", "black", "white") .windowUntil(color -> color.equals("#"), false) .flatMap(Flux::materialize) .map(s -> s.isOnComplete() ? "WINDOW CLOSED" : s.get())) .expectNext("red", "green", "#", "WINDOW CLOSED") .expectNext("orange", "blue", "#", "WINDOW CLOSED") .expectNext("black", "white", "WINDOW CLOSED") .verifyComplete(); }
@Test public void apiUntilCutBefore() { StepVerifier.create(Flux.just("red", "green", "#", "orange", "blue", "#", "black", "white") .windowUntil(color -> color.equals("#"), true) .flatMap(Flux::materialize) .map(s -> s.isOnComplete() ? "WINDOW CLOSED" : s.get())) .expectNext("red", "green", "WINDOW CLOSED", "#") .expectNext("orange", "blue", "WINDOW CLOSED", "#") .expectNext("black", "white", "WINDOW CLOSED") .verifyComplete(); }
@Test public void apiWhile() { StepVerifier.create(Flux.just("red", "green", "#", "orange", "blue", "#", "black", "white") .windowWhile(color -> !color.equals("#")) .flatMap(Flux::materialize) .map(s -> s.isOnComplete() ? "WINDOW CLOSED" : s.get())) .expectNext("red", "green", "WINDOW CLOSED") .expectNext("orange", "blue", "WINDOW CLOSED") .expectNext("black", "white", "WINDOW CLOSED") .verifyComplete(); }
@Test public void shouldSendOnNextSignalConditional() { Signal<? extends Long>[] first = new Signal[1]; StepVerifier.create(Flux.just(1L) .switchOnFirst((s, f) -> { first[0] = s; return f; }) .filter(e -> true) ) .expectSubscription() .expectNext(1L) .expectComplete() .verify(); Assertions.assertThat((long) first[0].get()).isEqualTo(1L); }
@Test public void shouldSendOnNextAsyncSignal() { Signal<? extends Long>[] first = new Signal[1]; StepVerifier.create(Flux.just(1L) .switchOnFirst((s, f) -> { first[0] = s; return f.subscribeOn(Schedulers.elastic()); })) .expectSubscription() .expectNext(1L) .expectComplete() .verify(); Assertions.assertThat((long) first[0].get()).isEqualTo(1L); }
@Test public void shouldSendOnNextAsyncSignalConditional() { Signal<? extends Long>[] first = new Signal[1]; StepVerifier.create(Flux.just(1L) .switchOnFirst((s, f) -> { first[0] = s; return f.subscribeOn(Schedulers.elastic()); }) .filter(p -> true) ) .expectSubscription() .expectNext(1L) .expectComplete() .verify(); Assertions.assertThat((long) first[0].get()).isEqualTo(1L); }