, io.reactivex.Observable> {
+
+ INSTANCE;
+
+ @Override
+ public io.reactivex.Observable convert(io.reactivex.Single source) {
+ return source.toObservable();
+ }
+ }
}
diff --git a/src/main/java/org/springframework/data/repository/util/ReactiveWrapperConverters.java b/src/main/java/org/springframework/data/repository/util/ReactiveWrapperConverters.java
new file mode 100644
index 000000000..8f11c9ac5
--- /dev/null
+++ b/src/main/java/org/springframework/data/repository/util/ReactiveWrapperConverters.java
@@ -0,0 +1,285 @@
+/*
+ * Copyright 2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.repository.util;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.reactivestreams.Publisher;
+import org.springframework.core.ReactiveAdapterRegistry;
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.core.convert.support.GenericConversionService;
+import org.springframework.util.Assert;
+import org.springframework.util.ClassUtils;
+
+import io.reactivex.Flowable;
+import lombok.experimental.UtilityClass;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import rx.Observable;
+import rx.Single;
+
+/**
+ * Conversion support for reactive wrapper types. This class is a logical extension to {@link QueryExecutionConverters}.
+ *
+ * This class discovers reactive wrapper availability and their conversion support based on the class path. Reactive
+ * wrapper types might be supported/on the class path but conversion may require additional dependencies.
+ *
+ * @author Mark Paluch
+ * @since 2.0
+ * @see ReactiveWrappers
+ * @see ReactiveAdapterRegistry
+ */
+@UtilityClass
+public class ReactiveWrapperConverters {
+
+ private static final List> REACTIVE_WRAPPERS = new ArrayList<>();
+ private static final GenericConversionService GENERIC_CONVERSION_SERVICE = new GenericConversionService();
+ private static final ReactiveAdapterRegistry REACTIVE_ADAPTER_REGISTRY = new ReactiveAdapterRegistry();
+
+ static {
+
+ if (ReactiveWrappers.RXJAVA1_PRESENT) {
+
+ REACTIVE_WRAPPERS.add(RxJava1SingleWrapper.INSTANCE);
+ REACTIVE_WRAPPERS.add(RxJava1ObservableWrapper.INSTANCE);
+ }
+
+ if (ReactiveWrappers.RXJAVA2_PRESENT) {
+
+ REACTIVE_WRAPPERS.add(RxJava2SingleWrapper.INSTANCE);
+ REACTIVE_WRAPPERS.add(RxJava2MaybeWrapper.INSTANCE);
+ REACTIVE_WRAPPERS.add(RxJava2ObservableWrapper.INSTANCE);
+ REACTIVE_WRAPPERS.add(RxJava2FlowableWrapper.INSTANCE);
+ }
+
+ if (ReactiveWrappers.PROJECT_REACTOR_PRESENT) {
+
+ REACTIVE_WRAPPERS.add(FluxWrapper.INSTANCE);
+ REACTIVE_WRAPPERS.add(MonoWrapper.INSTANCE);
+ REACTIVE_WRAPPERS.add(PublisherWrapper.INSTANCE);
+ }
+
+ QueryExecutionConverters.registerConvertersIn(GENERIC_CONVERSION_SERVICE);
+ }
+
+ /**
+ * Returns whether the given type is supported for wrapper type conversion.
+ *
+ * NOTE: A reactive wrapper type might be supported in general by {@link ReactiveWrappers#supports(Class)} but not
+ * necessarily for conversion using this method.
+ *
+ *
+ * @param type must not be {@literal null}.
+ * @return {@literal true} if the {@code type} is a supported reactive wrapper type.
+ */
+ public static boolean supports(Class type) {
+ return REACTIVE_ADAPTER_REGISTRY.getAdapterFrom(type) != null;
+ }
+
+ /**
+ * Casts or converts the given wrapper type into a different wrapper type.
+ *
+ * @param stream the stream, must not be {@literal null}.
+ * @param expectedWrapperType must not be {@literal null}.
+ * @return
+ */
+ @SuppressWarnings("unchecked")
+ public static T toWrapper(Object stream, Class expectedWrapperType) {
+
+ Assert.notNull(stream, "Stream must not be null!");
+ Assert.notNull(expectedWrapperType, "Converter must not be null!");
+
+ if (expectedWrapperType.isAssignableFrom(stream.getClass())) {
+ return (T) stream;
+ }
+
+ return GENERIC_CONVERSION_SERVICE.convert(stream, expectedWrapperType);
+ }
+
+ /**
+ * Maps elements of a reactive element stream to other elements.
+ *
+ * @param stream must not be {@literal null}.
+ * @param converter must not be {@literal null}.
+ * @return
+ */
+ @SuppressWarnings("unchecked")
+ public static T map(Object stream, Converter converter) {
+
+ Assert.notNull(stream, "Stream must not be null!");
+ Assert.notNull(converter, "Converter must not be null!");
+
+ for (AbstractReactiveWrapper reactiveWrapper : REACTIVE_WRAPPERS) {
+
+ if (ClassUtils.isAssignable(reactiveWrapper.getWrapperClass(), stream.getClass())) {
+ return (T) reactiveWrapper.map(stream, converter);
+ }
+ }
+
+ throw new IllegalStateException(String.format("Cannot apply converter to %s", stream));
+ }
+
+ private interface AbstractReactiveWrapper {
+
+ Class getWrapperClass();
+
+ Object map(Object wrapper, Converter converter);
+ }
+
+ private enum MonoWrapper implements AbstractReactiveWrapper> {
+
+ INSTANCE;
+
+ @Override
+ public Class> getWrapperClass() {
+ return Mono.class;
+ }
+
+ @Override
+ public Mono map(Object wrapper, Converter converter) {
+ return ((Mono) wrapper).map(converter::convert);
+ }
+ }
+
+ private enum FluxWrapper implements AbstractReactiveWrapper> {
+
+ INSTANCE;
+
+ @Override
+ public Class> getWrapperClass() {
+ return Flux.class;
+ }
+
+ public Flux map(Object wrapper, Converter converter) {
+ return ((Flux) wrapper).map(converter::convert);
+ }
+ }
+
+ private enum PublisherWrapper implements AbstractReactiveWrapper> {
+
+ INSTANCE;
+
+ @Override
+ public Class> getWrapperClass() {
+ return Publisher.class;
+ }
+
+ @Override
+ public Publisher map(Object wrapper, Converter converter) {
+
+ if (wrapper instanceof Mono) {
+ return MonoWrapper.INSTANCE.map(wrapper, converter);
+ }
+
+ if (wrapper instanceof Flux) {
+ return FluxWrapper.INSTANCE.map(wrapper, converter);
+ }
+
+ return FluxWrapper.INSTANCE.map(Flux.from((Publisher) wrapper), converter);
+ }
+ }
+
+ private enum RxJava1SingleWrapper implements AbstractReactiveWrapper> {
+
+ INSTANCE;
+
+ @Override
+ public Class> getWrapperClass() {
+ return Single.class;
+ }
+
+ @Override
+ public Single map(Object wrapper, Converter converter) {
+ return ((Single) wrapper).map(converter::convert);
+ }
+ }
+
+ private enum RxJava1ObservableWrapper implements AbstractReactiveWrapper> {
+
+ INSTANCE;
+
+ @Override
+ public Class> getWrapperClass() {
+ return Observable.class;
+ }
+
+ @Override
+ public Observable map(Object wrapper, Converter converter) {
+ return ((Observable) wrapper).map(converter::convert);
+ }
+ }
+
+ private enum RxJava2SingleWrapper implements AbstractReactiveWrapper> {
+
+ INSTANCE;
+
+ @Override
+ public Class> getWrapperClass() {
+ return io.reactivex.Single.class;
+ }
+
+ @Override
+ public io.reactivex.Single map(Object wrapper, Converter converter) {
+ return ((io.reactivex.Single) wrapper).map(converter::convert);
+ }
+ }
+
+ private enum RxJava2MaybeWrapper implements AbstractReactiveWrapper> {
+
+ INSTANCE;
+
+ @Override
+ public Class> getWrapperClass() {
+ return io.reactivex.Maybe.class;
+ }
+
+ @Override
+ public io.reactivex.Maybe map(Object wrapper, Converter converter) {
+ return ((io.reactivex.Maybe) wrapper).map(converter::convert);
+ }
+ }
+
+ private enum RxJava2ObservableWrapper implements AbstractReactiveWrapper> {
+
+ INSTANCE;
+
+ @Override
+ public Class> getWrapperClass() {
+ return io.reactivex.Observable.class;
+ }
+
+ @Override
+ public io.reactivex.Observable map(Object wrapper, Converter converter) {
+ return ((io.reactivex.Observable) wrapper).map(converter::convert);
+ }
+ }
+
+ private enum RxJava2FlowableWrapper implements AbstractReactiveWrapper> {
+
+ INSTANCE;
+
+ @Override
+ public Class> getWrapperClass() {
+ return io.reactivex.Flowable.class;
+ }
+
+ @Override
+ public io.reactivex.Flowable map(Object wrapper, Converter converter) {
+ return ((io.reactivex.Flowable) wrapper).map(converter::convert);
+ }
+ }
+}
diff --git a/src/main/java/org/springframework/data/repository/util/ReactiveWrappers.java b/src/main/java/org/springframework/data/repository/util/ReactiveWrappers.java
new file mode 100644
index 000000000..f4338e71b
--- /dev/null
+++ b/src/main/java/org/springframework/data/repository/util/ReactiveWrappers.java
@@ -0,0 +1,210 @@
+/*
+ * Copyright 2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.repository.util;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+import org.reactivestreams.Publisher;
+import org.springframework.core.ReactiveAdapter.Descriptor;
+import org.springframework.util.Assert;
+import org.springframework.util.ClassUtils;
+
+import lombok.experimental.UtilityClass;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import rx.Completable;
+import rx.Observable;
+import rx.Single;
+
+/**
+ * Utility class to expose details about reactive wrapper types. This class exposes whether a reactive wrapper is
+ * supported in general and whether a particular type is suitable for no-value/single-value/multi-value usage.
+ *
+ * Supported types are discovered by their availability on the class path. This class is typically used to determine
+ * multiplicity and whether a reactive wrapper type is acceptable for a specific operation.
+ *
+ * @author Mark Paluch
+ * @since 2.0
+ * @see org.reactivestreams.Publisher
+ * @see rx.Single
+ * @see rx.Observable
+ * @see rx.Completable
+ * @see io.reactivex.Single
+ * @see io.reactivex.Maybe
+ * @see io.reactivex.Observable
+ * @see io.reactivex.Completable
+ * @see io.reactivex.Flowable
+ * @see Mono
+ * @see Flux
+ */
+@UtilityClass
+public class ReactiveWrappers {
+
+ static final boolean PROJECT_REACTOR_PRESENT = ClassUtils.isPresent("reactor.core.publisher.Mono",
+ ReactiveWrappers.class.getClassLoader());
+
+ static final boolean RXJAVA1_PRESENT = ClassUtils.isPresent("rx.Completable",
+ ReactiveWrappers.class.getClassLoader());
+
+ static final boolean RXJAVA2_PRESENT = ClassUtils.isPresent("io.reactivex.Flowable",
+ ReactiveWrappers.class.getClassLoader());
+
+ private static final Map, Descriptor> REACTIVE_WRAPPERS;
+
+ static {
+
+ Map, Descriptor> reactiveWrappers = new LinkedHashMap<>(3);
+
+ if (RXJAVA1_PRESENT) {
+
+ reactiveWrappers.put(Single.class, new Descriptor(false, true, false));
+ reactiveWrappers.put(Completable.class, new Descriptor(false, true, true));
+ reactiveWrappers.put(Observable.class, new Descriptor(true, true, false));
+ }
+
+ if (RXJAVA2_PRESENT) {
+
+ reactiveWrappers.put(io.reactivex.Single.class, new Descriptor(false, true, false));
+ reactiveWrappers.put(io.reactivex.Maybe.class, new Descriptor(false, true, false));
+ reactiveWrappers.put(io.reactivex.Completable.class, new Descriptor(false, true, true));
+ reactiveWrappers.put(io.reactivex.Flowable.class, new Descriptor(true, true, false));
+ reactiveWrappers.put(io.reactivex.Observable.class, new Descriptor(true, true, false));
+ }
+
+ if (PROJECT_REACTOR_PRESENT) {
+
+ reactiveWrappers.put(Mono.class, new Descriptor(false, true, false));
+ reactiveWrappers.put(Flux.class, new Descriptor(true, true, true));
+ reactiveWrappers.put(Publisher.class, new Descriptor(true, true, true));
+ }
+
+ REACTIVE_WRAPPERS = Collections.unmodifiableMap(reactiveWrappers);
+ }
+
+ /**
+ * Returns {@literal true} if reactive support is available. More specifically, whether RxJava1/2 or Project Reactor
+ * libraries are on the class path.
+ *
+ * @return {@literal true} if reactive support is available.
+ */
+ public static boolean isAvailable() {
+ return RXJAVA1_PRESENT || RXJAVA2_PRESENT || PROJECT_REACTOR_PRESENT;
+ }
+
+ /**
+ * Returns {@literal true} if the {@code type} is a supported reactive wrapper type.
+ *
+ * @param type must not be {@literal null}.
+ * @return {@literal true} if the {@code type} is a supported reactive wrapper type.
+ */
+ public static boolean supports(Class type) {
+ return isNoValueType(type) || isSingleValueType(type) || isMultiValueType(type);
+ }
+
+ /**
+ * Returns {@literal true} if {@code type} is a reactive wrapper type that contains no value.
+ *
+ * @param type must not be {@literal null}.
+ * @return {@literal true} if {@code type} is a reactive wrapper type that contains no value.
+ */
+ public static boolean isNoValueType(Class type) {
+
+ Assert.notNull(type, "Class must not be null!");
+
+ return findDescriptor(type).map(Descriptor::isNoValue).orElse(false);
+ }
+
+ /**
+ * Returns {@literal true} if {@code type} is a reactive wrapper type for a single value.
+ *
+ * @param type must not be {@literal null}.
+ * @return {@literal true} if {@code type} is a reactive wrapper type for a single value.
+ */
+ public static boolean isSingleValueType(Class type) {
+
+ Assert.notNull(type, "Class must not be null!");
+
+ return findDescriptor(type).map((descriptor) -> !descriptor.isMultiValue() && !descriptor.isNoValue())
+ .orElse(false);
+ }
+
+ /**
+ * Returns {@literal true} if {@code type} is a reactive wrapper type supporting multiple values ({@code 0..N}
+ * elements).
+ *
+ * @param type must not be {@literal null}.
+ * @return {@literal true} if {@code type} is a reactive wrapper type supporting multiple values ({@code 0..N}
+ * elements).
+ */
+ public static boolean isMultiValueType(Class type) {
+
+ Assert.notNull(type, "Class must not be null!");
+
+ // Prevent single-types with a multi-hierarchy supertype to be reported as multi type
+ // See Mono implements Publisher
+ if (isSingleValueType(type)) {
+ return false;
+ }
+
+ return findDescriptor(type).map(Descriptor::isMultiValue).orElse(false);
+ }
+
+ /**
+ * Returns a collection of No-Value wrapper types.
+ *
+ * @return a collection of No-Value wrapper types.
+ */
+ public static Collection> getNoValueTypes() {
+ return REACTIVE_WRAPPERS.entrySet().stream().filter(entry -> entry.getValue().isNoValue()).map(Entry::getKey)
+ .collect(Collectors.toList());
+ }
+
+ /**
+ * Returns a collection of Single-Value wrapper types.
+ *
+ * @return a collection of Single-Value wrapper types.
+ */
+ public static Collection> getSingleValueTypes() {
+ return REACTIVE_WRAPPERS.entrySet().stream().filter(entry -> !entry.getValue().isMultiValue()).map(Entry::getKey)
+ .collect(Collectors.toList());
+ }
+
+ /**
+ * Returns a collection of Multi-Value wrapper types.
+ *
+ * @return a collection of Multi-Value wrapper types.
+ */
+ public static Collection> getMultiValueTypes() {
+ return REACTIVE_WRAPPERS.entrySet().stream().filter(entry -> entry.getValue().isMultiValue()).map(Entry::getKey)
+ .collect(Collectors.toList());
+ }
+
+ private static Optional findDescriptor(Class rhsType) {
+
+ for (Class type : REACTIVE_WRAPPERS.keySet()) {
+ if (org.springframework.util.ClassUtils.isAssignable(type, rhsType)) {
+ return Optional.ofNullable(REACTIVE_WRAPPERS.get(type));
+ }
+ }
+ return Optional.empty();
+ }
+}
diff --git a/src/test/java/org/springframework/data/repository/query/ReactiveWrapperConvertersUnitTests.java b/src/test/java/org/springframework/data/repository/query/ReactiveWrapperConvertersUnitTests.java
deleted file mode 100644
index fc15b1cae..000000000
--- a/src/test/java/org/springframework/data/repository/query/ReactiveWrapperConvertersUnitTests.java
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
- * Copyright 2016 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.repository.query;
-
-import static org.assertj.core.api.AssertionsForClassTypes.*;
-
-import org.junit.Test;
-import org.reactivestreams.Publisher;
-
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-import rx.Completable;
-import rx.Observable;
-import rx.Single;
-
-/**
- * Unit tests for {@link ReactiveWrapperConverters}.
- *
- * @author Mark Paluch
- */
-public class ReactiveWrapperConvertersUnitTests {
-
- /**
- * @see DATACMNS-836
- */
- @Test
- public void shouldSupportReactorTypes() {
-
- assertThat(ReactiveWrapperConverters.supports(Mono.class)).isTrue();
- assertThat(ReactiveWrapperConverters.supports(Flux.class)).isTrue();
- assertThat(ReactiveWrapperConverters.supports(Publisher.class)).isTrue();
- assertThat(ReactiveWrapperConverters.supports(Object.class)).isFalse();
- }
-
- /**
- * @see DATACMNS-836
- */
- @Test
- public void shouldSupportRxJavaTypes() {
-
- assertThat(ReactiveWrapperConverters.supports(Single.class)).isTrue();
- assertThat(ReactiveWrapperConverters.supports(Observable.class)).isTrue();
- assertThat(ReactiveWrapperConverters.supports(Completable.class)).isFalse();
- }
-
- /**
- * @see DATACMNS-836
- */
- @Test
- public void isSingleLikeShouldReportCorrectSingleTypes() {
-
- assertThat(ReactiveWrapperConverters.isSingleLike(Mono.class)).isTrue();
- assertThat(ReactiveWrapperConverters.isSingleLike(Flux.class)).isFalse();
- assertThat(ReactiveWrapperConverters.isSingleLike(Single.class)).isTrue();
- assertThat(ReactiveWrapperConverters.isSingleLike(Observable.class)).isFalse();
- assertThat(ReactiveWrapperConverters.isSingleLike(Publisher.class)).isFalse();
- }
-
- /**
- * @see DATACMNS-836
- */
- @Test
- public void isCollectionLikeShouldReportCorrectCollectionTypes() {
-
- assertThat(ReactiveWrapperConverters.isCollectionLike(Mono.class)).isFalse();
- assertThat(ReactiveWrapperConverters.isCollectionLike(Flux.class)).isTrue();
- assertThat(ReactiveWrapperConverters.isCollectionLike(Single.class)).isFalse();
- assertThat(ReactiveWrapperConverters.isCollectionLike(Observable.class)).isTrue();
- assertThat(ReactiveWrapperConverters.isCollectionLike(Publisher.class)).isTrue();
- }
-
- /**
- * @see DATACMNS-836
- */
- @Test
- public void toWrapperShouldCastMonoToMono() {
-
- Mono foo = Mono.just("foo");
- assertThat(ReactiveWrapperConverters.toWrapper(foo, Mono.class)).isSameAs(foo);
- }
-
- /**
- * @see DATACMNS-836
- */
- @Test
- public void toWrapperShouldConvertMonoToSingle() {
-
- Mono foo = Mono.just("foo");
- assertThat(ReactiveWrapperConverters.toWrapper(foo, Single.class)).isInstanceOf(Single.class);
- }
-
- /**
- * @see DATACMNS-836
- */
- @Test
- public void toWrapperShouldConvertMonoToFlux() {
-
- Mono foo = Mono.just("foo");
- assertThat(ReactiveWrapperConverters.toWrapper(foo, Flux.class)).isInstanceOf(Flux.class);
- }
-
- /**
- * @see DATACMNS-836
- */
- @Test
- public void shouldMapMono() {
-
- Mono foo = Mono.just("foo");
- Mono map = ReactiveWrapperConverters.map(foo, source -> 1L);
- assertThat(map.block()).isEqualTo(1L);
- }
-
- /**
- * @see DATACMNS-836
- */
- @Test
- public void shouldMapFlux() {
-
- Flux foo = Flux.just("foo");
- Flux map = ReactiveWrapperConverters.map(foo, source -> 1L);
- assertThat(map.next().block()).isEqualTo(1L);
- }
-
- /**
- * @see DATACMNS-836
- */
- @Test
- public void shouldMapSingle() {
-
- Single foo = Single.just("foo");
- Single map = ReactiveWrapperConverters.map(foo, source -> 1L);
- assertThat(map.toBlocking().value()).isEqualTo(1L);
- }
-
- /**
- * @see DATACMNS-836
- */
- @Test
- public void shouldMapObservable() {
-
- Observable foo = Observable.just("foo");
- Observable map = ReactiveWrapperConverters.map(foo, source -> 1L);
- assertThat(map.toBlocking().first()).isEqualTo(1L);
- }
-}
diff --git a/src/test/java/org/springframework/data/repository/util/QueryExecutionConvertersUnitTests.java b/src/test/java/org/springframework/data/repository/util/QueryExecutionConvertersUnitTests.java
index 7ac2e1f97..02d6518e2 100644
--- a/src/test/java/org/springframework/data/repository/util/QueryExecutionConvertersUnitTests.java
+++ b/src/test/java/org/springframework/data/repository/util/QueryExecutionConvertersUnitTests.java
@@ -84,6 +84,11 @@ public class QueryExecutionConvertersUnitTests {
assertThat(QueryExecutionConverters.supports(Single.class), is(true));
assertThat(QueryExecutionConverters.supports(Completable.class), is(true));
assertThat(QueryExecutionConverters.supports(Observable.class), is(true));
+ assertThat(QueryExecutionConverters.supports(io.reactivex.Single.class), is(true));
+ assertThat(QueryExecutionConverters.supports(io.reactivex.Maybe.class), is(true));
+ assertThat(QueryExecutionConverters.supports(io.reactivex.Completable.class), is(true));
+ assertThat(QueryExecutionConverters.supports(io.reactivex.Flowable.class), is(true));
+ assertThat(QueryExecutionConverters.supports(io.reactivex.Observable.class), is(true));
}
/**
@@ -111,6 +116,11 @@ public class QueryExecutionConvertersUnitTests {
assertThat(QueryExecutionConverters.supportsUnwrapping(Single.class), is(false));
assertThat(QueryExecutionConverters.supportsUnwrapping(Completable.class), is(false));
assertThat(QueryExecutionConverters.supportsUnwrapping(Observable.class), is(false));
+ assertThat(QueryExecutionConverters.supportsUnwrapping(io.reactivex.Single.class), is(false));
+ assertThat(QueryExecutionConverters.supportsUnwrapping(io.reactivex.Maybe.class), is(false));
+ assertThat(QueryExecutionConverters.supportsUnwrapping(io.reactivex.Completable.class), is(false));
+ assertThat(QueryExecutionConverters.supportsUnwrapping(io.reactivex.Flowable.class), is(false));
+ assertThat(QueryExecutionConverters.supportsUnwrapping(io.reactivex.Observable.class), is(false));
}
/**
diff --git a/src/test/java/org/springframework/data/repository/util/ReactiveWrapperConvertersUnitTests.java b/src/test/java/org/springframework/data/repository/util/ReactiveWrapperConvertersUnitTests.java
new file mode 100644
index 000000000..2b61c02db
--- /dev/null
+++ b/src/test/java/org/springframework/data/repository/util/ReactiveWrapperConvertersUnitTests.java
@@ -0,0 +1,312 @@
+/*
+ * Copyright 2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.repository.util;
+
+import static org.assertj.core.api.AssertionsForClassTypes.*;
+
+import org.junit.Test;
+import org.reactivestreams.Publisher;
+
+import io.reactivex.Flowable;
+import org.springframework.data.repository.util.ReactiveWrapperConverters;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import rx.Completable;
+import rx.Observable;
+import rx.Single;
+
+/**
+ * Unit tests for {@link ReactiveWrapperConverters}.
+ *
+ * @author Mark Paluch
+ */
+public class ReactiveWrapperConvertersUnitTests {
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void shouldSupportReactorTypes() {
+
+ assertThat(ReactiveWrapperConverters.supports(Mono.class)).isTrue();
+ assertThat(ReactiveWrapperConverters.supports(Flux.class)).isTrue();
+ assertThat(ReactiveWrapperConverters.supports(Publisher.class)).isTrue();
+ assertThat(ReactiveWrapperConverters.supports(Object.class)).isFalse();
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void shouldSupportRxJava1Types() {
+
+ assertThat(ReactiveWrapperConverters.supports(Single.class)).isTrue();
+ assertThat(ReactiveWrapperConverters.supports(Observable.class)).isTrue();
+ assertThat(ReactiveWrapperConverters.supports(Completable.class)).isTrue();
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void shouldSupportRxJava2Types() {
+
+ assertThat(ReactiveWrapperConverters.supports(io.reactivex.Single.class)).isTrue();
+ assertThat(ReactiveWrapperConverters.supports(io.reactivex.Maybe.class)).isTrue();
+ assertThat(ReactiveWrapperConverters.supports(io.reactivex.Observable.class)).isTrue();
+ assertThat(ReactiveWrapperConverters.supports(io.reactivex.Flowable.class)).isTrue();
+ assertThat(ReactiveWrapperConverters.supports(io.reactivex.Completable.class)).isTrue();
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void toWrapperShouldCastMonoToMono() {
+
+ Mono foo = Mono.just("foo");
+ assertThat(ReactiveWrapperConverters.toWrapper(foo, Mono.class)).isSameAs(foo);
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void toWrapperShouldConvertMonoToRxJava1Single() {
+
+ Mono foo = Mono.just("foo");
+ assertThat(ReactiveWrapperConverters.toWrapper(foo, Single.class)).isInstanceOf(Single.class);
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void toWrapperShouldConvertMonoToRxJava2Single() {
+
+ Mono foo = Mono.just("foo");
+ assertThat(ReactiveWrapperConverters.toWrapper(foo, io.reactivex.Single.class))
+ .isInstanceOf(io.reactivex.Single.class);
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void toWrapperShouldConvertRxJava2SingleToMono() {
+
+ io.reactivex.Single foo = io.reactivex.Single.just("foo");
+ assertThat(ReactiveWrapperConverters.toWrapper(foo, Mono.class)).isInstanceOf(Mono.class);
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void toWrapperShouldConvertRxJava2SingleToPublisher() {
+
+ io.reactivex.Single foo = io.reactivex.Single.just("foo");
+ assertThat(ReactiveWrapperConverters.toWrapper(foo, Publisher.class)).isInstanceOf(Publisher.class);
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void toWrapperShouldConvertRxJava2MaybeToMono() {
+
+ io.reactivex.Maybe foo = io.reactivex.Maybe.just("foo");
+ assertThat(ReactiveWrapperConverters.toWrapper(foo, Mono.class)).isInstanceOf(Mono.class);
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void toWrapperShouldConvertRxJava2MaybeToFlux() {
+
+ io.reactivex.Maybe foo = io.reactivex.Maybe.just("foo");
+ assertThat(ReactiveWrapperConverters.toWrapper(foo, Flux.class)).isInstanceOf(Flux.class);
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void toWrapperShouldConvertRxJava2MaybeToPublisher() {
+
+ io.reactivex.Maybe foo = io.reactivex.Maybe.just("foo");
+ assertThat(ReactiveWrapperConverters.toWrapper(foo, Publisher.class)).isInstanceOf(Publisher.class);
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void toWrapperShouldConvertRxJava2FlowableToMono() {
+
+ io.reactivex.Flowable foo = io.reactivex.Flowable.just("foo");
+ assertThat(ReactiveWrapperConverters.toWrapper(foo, Mono.class)).isInstanceOf(Mono.class);
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void toWrapperShouldConvertRxJava2FlowableToFlux() {
+
+ io.reactivex.Flowable foo = io.reactivex.Flowable.just("foo");
+ assertThat(ReactiveWrapperConverters.toWrapper(foo, Flux.class)).isInstanceOf(Flux.class);
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void toWrapperShouldCastRxJava2FlowableToPublisher() {
+
+ io.reactivex.Flowable foo = io.reactivex.Flowable.just("foo");
+ assertThat(ReactiveWrapperConverters.toWrapper(foo, Publisher.class)).isSameAs(foo);
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void toWrapperShouldConvertRxJava2ObservableToMono() {
+
+ io.reactivex.Observable foo = io.reactivex.Observable.just("foo");
+ assertThat(ReactiveWrapperConverters.toWrapper(foo, Mono.class)).isInstanceOf(Mono.class);
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void toWrapperShouldConvertRxJava2ObservableToFlux() {
+
+ io.reactivex.Observable foo = io.reactivex.Observable.just("foo");
+ assertThat(ReactiveWrapperConverters.toWrapper(foo, Flux.class)).isInstanceOf(Flux.class);
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void toWrapperShouldConvertRxJava2ObservableToPublisher() {
+
+ io.reactivex.Observable foo = io.reactivex.Observable.just("foo");
+ assertThat(ReactiveWrapperConverters.toWrapper(foo, Publisher.class)).isInstanceOf(Publisher.class);
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void toWrapperShouldConvertMonoToFlux() {
+
+ Mono foo = Mono.just("foo");
+ assertThat(ReactiveWrapperConverters.toWrapper(foo, Flux.class)).isInstanceOf(Flux.class);
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void shouldMapMono() {
+
+ Mono foo = Mono.just("foo");
+ Mono map = ReactiveWrapperConverters.map(foo, source -> 1L);
+ assertThat(map.block()).isEqualTo(1L);
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void shouldMapFlux() {
+
+ Flux foo = Flux.just("foo");
+ Flux map = ReactiveWrapperConverters.map(foo, source -> 1L);
+ assertThat(map.next().block()).isEqualTo(1L);
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void shouldMapRxJava1Single() {
+
+ Single foo = Single.just("foo");
+ Single map = ReactiveWrapperConverters.map(foo, source -> 1L);
+ assertThat(map.toBlocking().value()).isEqualTo(1L);
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void shouldMapRxJava1Observable() {
+
+ Observable foo = Observable.just("foo");
+ Observable map = ReactiveWrapperConverters.map(foo, source -> 1L);
+ assertThat(map.toBlocking().first()).isEqualTo(1L);
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void shouldMapRxJava2Single() {
+
+ io.reactivex.Single foo = io.reactivex.Single.just("foo");
+ io.reactivex.Single map = ReactiveWrapperConverters.map(foo, source -> 1L);
+ assertThat(map.blockingGet()).isEqualTo(1L);
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void shouldMapRxJava2Maybe() {
+
+ io.reactivex.Maybe foo = io.reactivex.Maybe.just("foo");
+ io.reactivex.Maybe map = ReactiveWrapperConverters.map(foo, source -> 1L);
+ assertThat(map.toSingle().blockingGet()).isEqualTo(1L);
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void shouldMapRxJava2Observable() {
+
+ io.reactivex.Observable foo = io.reactivex.Observable.just("foo");
+ io.reactivex.Observable map = ReactiveWrapperConverters.map(foo, source -> 1L);
+ assertThat(map.blockingFirst()).isEqualTo(1L);
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void shouldMapRxJava2Flowable() {
+
+ io.reactivex.Flowable foo = io.reactivex.Flowable.just("foo");
+ io.reactivex.Flowable map = ReactiveWrapperConverters.map(foo, source -> 1L);
+ assertThat(map.blockingFirst()).isEqualTo(1L);
+ }
+}
diff --git a/src/test/java/org/springframework/data/repository/util/ReactiveWrappersUnitTests.java b/src/test/java/org/springframework/data/repository/util/ReactiveWrappersUnitTests.java
new file mode 100644
index 000000000..81fd9f556
--- /dev/null
+++ b/src/test/java/org/springframework/data/repository/util/ReactiveWrappersUnitTests.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.repository.util;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import io.reactivex.Completable;
+import io.reactivex.Flowable;
+import org.junit.Test;
+import org.reactivestreams.Publisher;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import rx.Observable;
+import rx.Single;
+
+/**
+ * Unit tests for {@link ReactiveWrappers}.
+ *
+ * @author Mark Paluch
+ */
+public class ReactiveWrappersUnitTests {
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void isSingleLikeShouldReportCorrectNoTypes() {
+
+ assertThat(ReactiveWrappers.isNoValueType(Mono.class)).isFalse();
+ assertThat(ReactiveWrappers.isNoValueType(Flux.class)).isTrue();
+ assertThat(ReactiveWrappers.isNoValueType(Single.class)).isFalse();
+ assertThat(ReactiveWrappers.isNoValueType(Completable.class)).isTrue();
+ assertThat(ReactiveWrappers.isNoValueType(Observable.class)).isFalse();
+ assertThat(ReactiveWrappers.isNoValueType(Publisher.class)).isTrue();
+ assertThat(ReactiveWrappers.isNoValueType(io.reactivex.Single.class)).isFalse();
+ assertThat(ReactiveWrappers.isNoValueType(io.reactivex.Maybe.class)).isFalse();
+ assertThat(ReactiveWrappers.isNoValueType(Flowable.class)).isFalse();
+ assertThat(ReactiveWrappers.isNoValueType(io.reactivex.Observable.class)).isFalse();
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void isSingleLikeShouldReportCorrectSingleTypes() {
+
+ assertThat(ReactiveWrappers.isSingleValueType(Mono.class)).isTrue();
+ assertThat(ReactiveWrappers.isSingleValueType(Flux.class)).isFalse();
+ assertThat(ReactiveWrappers.isSingleValueType(Single.class)).isTrue();
+ assertThat(ReactiveWrappers.isSingleValueType(Completable.class)).isFalse();
+ assertThat(ReactiveWrappers.isSingleValueType(Observable.class)).isFalse();
+ assertThat(ReactiveWrappers.isSingleValueType(Publisher.class)).isFalse();
+ assertThat(ReactiveWrappers.isSingleValueType(io.reactivex.Single.class)).isTrue();
+ assertThat(ReactiveWrappers.isSingleValueType(io.reactivex.Completable.class)).isFalse();
+ assertThat(ReactiveWrappers.isSingleValueType(io.reactivex.Maybe.class)).isTrue();
+ assertThat(ReactiveWrappers.isSingleValueType(Flowable.class)).isFalse();
+ assertThat(ReactiveWrappers.isSingleValueType(io.reactivex.Observable.class)).isFalse();
+ }
+
+ /**
+ * @see DATACMNS-836
+ */
+ @Test
+ public void isCollectionLikeShouldReportCorrectCollectionTypes() {
+
+ assertThat(ReactiveWrappers.isMultiValueType(Mono.class)).isFalse();
+ assertThat(ReactiveWrappers.isMultiValueType(Flux.class)).isTrue();
+ assertThat(ReactiveWrappers.isMultiValueType(Single.class)).isFalse();
+ assertThat(ReactiveWrappers.isSingleValueType(Completable.class)).isFalse();
+ assertThat(ReactiveWrappers.isMultiValueType(Observable.class)).isTrue();
+ assertThat(ReactiveWrappers.isMultiValueType(Publisher.class)).isTrue();
+ assertThat(ReactiveWrappers.isMultiValueType(io.reactivex.Single.class)).isFalse();
+ assertThat(ReactiveWrappers.isSingleValueType(io.reactivex.Completable.class)).isFalse();
+ assertThat(ReactiveWrappers.isMultiValueType(Flowable.class)).isTrue();
+ assertThat(ReactiveWrappers.isMultiValueType(io.reactivex.Observable.class)).isTrue();
+ }
+}