@Override public Flux<Person> apply(Person person) { return data.insert(person).flux(); } });
@Override public Mono<Boolean> msetnx(Map<K, V> map) { return pipeliningWithMap(map, kvMap -> RedisAdvancedClusterReactiveCommandsImpl.super.msetnx(kvMap).flux(), booleanFlux -> booleanFlux).reduce((accu, next) -> accu && next); }
@Override public Mono<String> mset(Map<K, V> map) { return pipeliningWithMap(map, kvMap -> RedisAdvancedClusterReactiveCommandsImpl.super.mset(kvMap).flux(), booleanFlux -> booleanFlux).last(); }
@Override @SuppressWarnings("unchecked") protected Flux<I> sourceCallable(OperatorScenario<I, Flux<I>, O, Flux<O>> scenario) { if(scenario.producerCount() == 0){ return (Flux<I>)Mono.fromRunnable(() -> {}) .flux(); } return (Flux<I>)Mono.fromCallable(() -> scenario.producingMapper.apply(0)) .flux(); }
@Test public void monoFromFluxItselfMonoToFlux_fuseable() { Mono<String> original = Mono.just("foo").map(v -> v + "bar"); Flux<String> firstConversion = original.flux(); Mono<String> secondConversion = Mono.from(firstConversion); assertThat(original).isInstanceOf(Fuseable.class); assertThat(secondConversion).isInstanceOf(Fuseable.class); assertThat(secondConversion.block()).isEqualTo("foobar"); assertThat(secondConversion).as("conversions negated").isSameAs(original); }
@Test public void monoFromFluxItselfMonoToFlux() { Mono<String> original = Mono.just("foo").hide(); Flux<String> firstConversion = original.flux(); Mono<String> secondConversion = Mono.from(firstConversion); assertThat(secondConversion.block()).isEqualTo("foo"); assertThat(secondConversion).as("conversions negated").isSameAs(original); }
@Override @SuppressWarnings("unchecked") protected ParallelFlux<I> sourceCallable(OperatorScenario<I, ParallelFlux<I>, O, ParallelFlux<O>> scenario) { if(scenario.producerCount() == 0){ return (ParallelFlux<I>)Mono.fromRunnable(() -> {}) .flux() .parallel(4); } return (ParallelFlux<I>) Mono.fromCallable(() -> scenario.producingMapper.apply(0)) .flux() .parallel(4); }
@Test public void monoFromFluxItselfMonoToFlux_scalarCallableNotOptimized() { Mono<String> original = Mono.just("foo"); Flux<String> firstConversion = original.flux(); Mono<String> secondConversion = Mono.from(firstConversion); assertThat(secondConversion.block()).isEqualTo("foo"); assertThat(secondConversion).as("conversions not negated but equivalent") .isNotSameAs(original) .hasSameClassAs(original); }
@Test public void fluxJust() { StepVerifier.create(Mono.just(1).flux()) .expectNext(1) .verifyComplete(); }
@Test public void collectListCallable() { StepVerifier.create(Mono.fromCallable(() -> 1) .flux() .collectList()) .assertNext(d -> assertThat(d).containsExactly(1)) .verifyComplete(); }
@Test public void collectMultiMapCallable() { StepVerifier.create(Mono.fromCallable(() -> new Pojo("test", 1L)) .flux() .collectMultimap(p -> p.id)) .assertNext(p -> assertThat(p).containsOnlyKeys(1L) .containsValues(Arrays.asList(new Pojo( "test", 1L)))) .verifyComplete(); } }
@Test public void normal3() { StepVerifier.create(Mono.fromCallable(() -> 100) .flux() .last(-1)) .expectNext(100) .verifyComplete(); }
@Test public void singleFallbackCallable() { StepVerifier.create(Mono.fromCallable(() -> 1) .flux() .single(2)) .expectNext(1) .verifyComplete(); }
@Test public void singleCallable() { StepVerifier.create(Mono.fromCallable(() -> 1) .flux() .single()) .expectNext(1) .verifyComplete(); }
@Test public void singleEmptyFallbackCallable() { StepVerifier.create(Mono.fromCallable(() -> 1) .flux() .singleOrEmpty()) .expectNext(1) .verifyComplete(); }
@Test public void callableReturnsNull3() { StepVerifier.create(Mono.fromCallable(() -> null) .flux() .subscribeOn(Schedulers.single()), 1) .verifyComplete(); }
@Test public void collectMapCallable() { StepVerifier.create(Mono.fromCallable(() -> new Pojo("test", 1L)) .flux() .collectMap(p -> p.id)) .assertNext(p -> assertThat(p).containsOnlyKeys(1L) .containsValues(new Pojo("test", 1L))) .verifyComplete(); }
@Test public void callableReturnsNull() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); Mono.<Integer>fromCallable(() -> null).log().flux() .subscribe(ts); ts.assertNoValues() .assertNoError() .assertComplete(); }
@Test public void normal() { StepVerifier.create(Mono.fromCallable(() -> 1) .flux() .subscribeOn(Schedulers.single())) .expectNext(1) .expectComplete() .verify(); }