Spring/spring-data-commons
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Drop support for RxJava 2.

Browse Source 
Closes #2469
This commit is contained in:
Mark Paluch
2021-09-27 14:00:20 +02:00
committed by Jens Schauder
parent 20a1220cd1
commit d4036ec0a9
12 changed files with 14 additions and 554 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
pom.xml
View File

@@ -112,13 +112,6 @@
<!-- RxJava -->
<dependency>
<groupId>io.reactivex.rxjava2</groupId>
<artifactId>rxjava</artifactId>
<version>${rxjava2}</version>
<optional>true</optional>
</dependency>
<dependency>
<groupId>io.reactivex.rxjava3</groupId>
<artifactId>rxjava</artifactId>

202
src/main/java/org/springframework/data/repository/reactive/RxJava2CrudRepository.java
View File

@@ -1,202 +0,0 @@
/*
* Copyright 2017-2021 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
*
* https://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.reactive;
import io.reactivex.Completable;
import io.reactivex.Flowable;
import io.reactivex.Maybe;
import io.reactivex.Single;
import org.springframework.data.repository.NoRepositoryBean;
import org.springframework.data.repository.Repository;
/**
* Interface for generic CRUD operations on a repository for a specific type. This repository follows reactive paradigms
* and uses RxJava 2 types.
*
* @author Mark Paluch
* @since 2.0
* @see Maybe
* @see Single
* @see Flowable
* @see Completable
* @deprecated since 2.6, use {@link RxJava3CrudRepository RxJava 3} instead. To be removed with Spring Data 3.0.
*/
@NoRepositoryBean
@Deprecated
public interface RxJava2CrudRepository<T, ID> extends Repository<T, ID> {
/**
* Saves a given entity. Use the returned instance for further operations as the save operation might have changed the
* entity instance completely.
*
* @param entity must not be {@literal null}.
* @return {@link Single} emitting the saved entity.
* @throws IllegalArgumentException in case the given {@literal entity} is {@literal null}.
*/
<S extends T> Single<S> save(S entity);
/**
* Saves all given entities.
*
* @param entities must not be {@literal null}.
* @return {@link Flowable} emitting the saved entities.
* @throws IllegalArgumentException in case the given {@link Iterable entities} or one of its entities is
* {@literal null}.
*/
<S extends T> Flowable<S> saveAll(Iterable<S> entities);
/**
* Saves all given entities.
*
* @param entityStream must not be {@literal null}.
* @return {@link Flowable} emitting the saved entities.
* @throws IllegalArgumentException in case the given {@link Flowable entityStream} is {@literal null}.
*/
<S extends T> Flowable<S> saveAll(Flowable<S> entityStream);
/**
* Retrieves an entity by its id.
*
* @param id must not be {@literal null}.
* @return {@link Maybe} emitting the entity with the given id or {@link Maybe#empty()} if none found.
* @throws IllegalArgumentException in case the given {@literal id} is {@literal null}.
*/
Maybe<T> findById(ID id);
/**
* Retrieves an entity by its id supplied by a {@link Single}.
*
* @param id must not be {@literal null}. Uses the first emitted element to perform the find-query.
* @return {@link Maybe} emitting the entity with the given id or {@link Maybe#empty()} if none found.
* @throws IllegalArgumentException in case the given {@link Single id} is {@literal null}.
*/
Maybe<T> findById(Single<ID> id);
/**
* Returns whether an entity with the given {@literal id} exists.
*
* @param id must not be {@literal null}.
* @return {@link Single} emitting {@literal true} if an entity with the given id exists, {@literal false} otherwise.
* @throws IllegalArgumentException in case the given {@literal id} is {@literal null}.
*/
Single<Boolean> existsById(ID id);
/**
* Returns whether an entity with the given id, supplied by a {@link Single}, exists.
*
* @param id must not be {@literal null}.
* @return {@link Single} emitting {@literal true} if an entity with the given id exists, {@literal false} otherwise.
* @throws IllegalArgumentException in case the given {@link Single id} is {@literal null}.
*/
Single<Boolean> existsById(Single<ID> id);
/**
* Returns all instances of the type.
*
* @return {@link Flowable} emitting all entities.
*/
Flowable<T> findAll();
/**
* Returns all instances of the type {@code T} with the given IDs.
* <p>
* If some or all ids are not found, no entities are returned for these IDs.
* <p>
* Note that the order of elements in the result is not guaranteed.
*
* @param ids must not be {@literal null} nor contain any {@literal null} values.
* @return {@link Flowable} emitting the found entities. The size can be equal or less than the number of given
* {@literal ids}.
* @throws IllegalArgumentException in case the given {@link Iterable ids} or one of its items is {@literal null}.
*/
Flowable<T> findAllById(Iterable<ID> ids);
/**
* Returns all instances of the type {@code T} with the given IDs supplied by a {@link Flowable}.
* <p>
* If some or all ids are not found, no entities are returned for these IDs.
* <p>
* Note that the order of elements in the result is not guaranteed.
*
* @param idStream must not be {@literal null}.
* @return {@link Flowable} emitting the found entities.
* @throws IllegalArgumentException in case the given {@link Flowable idStream} is {@literal null}.
*/
Flowable<T> findAllById(Flowable<ID> idStream);
/**
* Returns the number of entities available.
*
* @return {@link Single} emitting the number of entities.
*/
Single<Long> count();
/**
* Deletes the entity with the given id.
*
* @param id must not be {@literal null}.
* @return {@link Completable} signaling when operation has completed.
* @throws IllegalArgumentException in case the given {@literal id} is {@literal null}.
*/
Completable deleteById(ID id);
/**
* Deletes a given entity.
*
* @param entity must not be {@literal null}.
* @return {@link Completable} signaling when operation has completed.
* @throws IllegalArgumentException in case the given entity is {@literal null}.
*/
Completable delete(T entity);
/**
* Deletes all instances of the type {@code T} with the given IDs.
*
* @param ids must not be {@literal null}.
* @return {@link Completable} signaling when operation has completed.
* @throws IllegalArgumentException in case the given {@literal ids} or one of its elements is {@literal null}.
* {@literal null}.
* @since 2.5
*/
Completable deleteAllById(Iterable<? extends ID> ids);
/**
* Deletes the given entities.
*
* @param entities must not be {@literal null}.
* @return {@link Completable} signaling when operation has completed.
* @throws IllegalArgumentException in case the given {@link Iterable entities} or one of its entities is
* {@literal null}.
*/
Completable deleteAll(Iterable<? extends T> entities);
/**
* Deletes the given entities supplied by a {@link Flowable}.
*
* @param entityStream must not be {@literal null}.
* @return {@link Completable} signaling when operation has completed.
* @throws IllegalArgumentException in case the given {@link Flowable entityStream} is {@literal null}.
*/
Completable deleteAll(Flowable<? extends T> entityStream);
/**
* Deletes all entities managed by the repository.
*
* @return {@link Completable} signaling when operation has completed.
*/
Completable deleteAll();
}

45
src/main/java/org/springframework/data/repository/reactive/RxJava2SortingRepository.java
View File

@@ -1,45 +0,0 @@
/*
* Copyright 2017-2021 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
*
* https://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.reactive;
import io.reactivex.Flowable;
import org.springframework.data.domain.Sort;
import org.springframework.data.repository.NoRepositoryBean;
/**
* Extension of {@link RxJava2CrudRepository} to provide additional methods to retrieve entities using the sorting
* abstraction.
*
* @author Mark Paluch
* @since 2.0
* @see Sort
* @see Flowable
* @see RxJava2CrudRepository
* @deprecated since 2.6, use {@link RxJava3SortingRepository RxJava 3} instead. To be removed with Spring Data 3.0.
*/
@NoRepositoryBean
@Deprecated
public interface RxJava2SortingRepository<T, ID> extends RxJava2CrudRepository<T, ID> {
/**
* Returns all entities sorted by the given options.
*
* @param sort must not be {@literal null}.
* @return all entities sorted by the given options.
*/
Flowable<T> findAll(Sort sort);
}

1
src/main/java/org/springframework/data/repository/reactive/RxJava3SortingRepository.java
View File

@@ -28,7 +28,6 @@ import org.springframework.data.repository.NoRepositoryBean;
* @since 2.4
* @see Sort
* @see Flowable
* @see RxJava2CrudRepository
*/
@NoRepositoryBean
public interface RxJava3SortingRepository<T, ID> extends RxJava3CrudRepository<T, ID> {

86
src/main/java/org/springframework/data/repository/util/ReactiveWrapperConverters.java
View File

@@ -15,8 +15,6 @@
*/
package org.springframework.data.repository.util;
import io.reactivex.Flowable;
import io.reactivex.Maybe;
import kotlinx.coroutines.flow.Flow;
import kotlinx.coroutines.flow.FlowKt;
import kotlinx.coroutines.reactive.ReactiveFlowKt;
@@ -68,14 +66,6 @@ public abstract class ReactiveWrapperConverters {
static {
if (ReactiveWrappers.isAvailable(ReactiveLibrary.RXJAVA2)) {
REACTIVE_WRAPPERS.add(RxJava2SingleWrapper.INSTANCE);
REACTIVE_WRAPPERS.add(RxJava2MaybeWrapper.INSTANCE);
REACTIVE_WRAPPERS.add(RxJava2ObservableWrapper.INSTANCE);
REACTIVE_WRAPPERS.add(RxJava2FlowableWrapper.INSTANCE);
}
if (ReactiveWrappers.isAvailable(ReactiveLibrary.RXJAVA3)) {
REACTIVE_WRAPPERS.add(RxJava3SingleWrapper.INSTANCE);
@@ -331,82 +321,6 @@ public abstract class ReactiveWrapperConverters {
}
}
// -------------------------------------------------------------------------
// RxJava 2 converters
// -------------------------------------------------------------------------
/**
* Wrapper for RxJava 2's {@link io.reactivex.Single}.
*/
private enum RxJava2SingleWrapper implements ReactiveTypeWrapper<io.reactivex.Single<?>> {
INSTANCE;
@Override
public Class<? super io.reactivex.Single<?>> getWrapperClass() {
return io.reactivex.Single.class;
}
@Override
public io.reactivex.Single<?> map(Object wrapper, Function<Object, Object> function) {
return ((io.reactivex.Single<?>) wrapper).map(function::apply);
}
}
/**
* Wrapper for RxJava 2's {@link io.reactivex.Maybe}.
*/
private enum RxJava2MaybeWrapper implements ReactiveTypeWrapper<Maybe<?>> {
INSTANCE;
@Override
public Class<? super io.reactivex.Maybe<?>> getWrapperClass() {
return io.reactivex.Maybe.class;
}
@Override
public io.reactivex.Maybe<?> map(Object wrapper, Function<Object, Object> function) {
return ((io.reactivex.Maybe<?>) wrapper).map(function::apply);
}
}
/**
* Wrapper for RxJava 2's {@link io.reactivex.Observable}.
*/
private enum RxJava2ObservableWrapper implements ReactiveTypeWrapper<io.reactivex.Observable<?>> {
INSTANCE;
@Override
public Class<? super io.reactivex.Observable<?>> getWrapperClass() {
return io.reactivex.Observable.class;
}
@Override
public io.reactivex.Observable<?> map(Object wrapper, Function<Object, Object> function) {
return ((io.reactivex.Observable<?>) wrapper).map(function::apply);
}
}
/**
* Wrapper for RxJava 2's {@link io.reactivex.Flowable}.
*/
private enum RxJava2FlowableWrapper implements ReactiveTypeWrapper<Flowable<?>> {
INSTANCE;
@Override
public Class<? super Flowable<?>> getWrapperClass() {
return io.reactivex.Flowable.class;
}
@Override
public io.reactivex.Flowable<?> map(Object wrapper, Function<Object, Object> function) {
return ((io.reactivex.Flowable<?>) wrapper).map(function::apply);
}
}
// -------------------------------------------------------------------------
// RxJava 3 converters
// -------------------------------------------------------------------------

19
src/main/java/org/springframework/data/repository/util/ReactiveWrappers.java
View File

@@ -43,11 +43,6 @@ import org.springframework.util.ClassUtils;
* @author Hantsy Bai
* @since 2.0
* @see org.reactivestreams.Publisher
* @see io.reactivex.Single
* @see io.reactivex.Maybe
* @see io.reactivex.Observable
* @see io.reactivex.Completable
* @see io.reactivex.Flowable
* @see io.reactivex.rxjava3.core.Single
* @see io.reactivex.rxjava3.core.Maybe
* @see io.reactivex.rxjava3.core.Observable
@@ -63,10 +58,6 @@ public abstract class ReactiveWrappers {
private static final boolean PROJECT_REACTOR_PRESENT = ClassUtils.isPresent("reactor.core.publisher.Flux",
ReactiveWrappers.class.getClassLoader());
@Deprecated
private static final boolean RXJAVA2_PRESENT = ClassUtils.isPresent("io.reactivex.Flowable",
ReactiveWrappers.class.getClassLoader());
private static final boolean RXJAVA3_PRESENT = ClassUtils.isPresent("io.reactivex.rxjava3.core.Flowable",
ReactiveWrappers.class.getClassLoader());
@@ -85,13 +76,7 @@ public abstract class ReactiveWrappers {
*/
public enum ReactiveLibrary {
PROJECT_REACTOR,
/**
* @deprecated since 2.6, use RxJava 3 instead. To be removed with Spring Data 3.0.
*/
@Deprecated
RXJAVA2, RXJAVA3, KOTLIN_COROUTINES;
PROJECT_REACTOR, RXJAVA3, KOTLIN_COROUTINES, MUTINY;
}
/**
@@ -117,8 +102,6 @@ public abstract class ReactiveWrappers {
switch (reactiveLibrary) {
case PROJECT_REACTOR:
return PROJECT_REACTOR_PRESENT;
case RXJAVA2:
return RXJAVA2_PRESENT;
case RXJAVA3:
return RXJAVA3_PRESENT;
case KOTLIN_COROUTINES:

14
src/test/java/org/springframework/data/repository/core/support/ReactiveRepositoryInformationUnitTests.java
View File

@@ -17,7 +17,7 @@ package org.springframework.data.repository.core.support;
import static org.assertj.core.api.Assertions.*;
import io.reactivex.Flowable;
import io.reactivex.rxjava3.core.Flowable;
import reactor.core.publisher.Flux;
import java.lang.reflect.Method;
@@ -30,7 +30,7 @@ import org.reactivestreams.Publisher;
import org.springframework.data.repository.core.RepositoryMetadata;
import org.springframework.data.repository.reactive.ReactiveCrudRepository;
import org.springframework.data.repository.reactive.ReactiveSortingRepository;
import org.springframework.data.repository.reactive.RxJava2CrudRepository;
import org.springframework.data.repository.reactive.RxJava3CrudRepository;
/**
* Unit tests for {@link ReactiveRepositoryInformation}.
@@ -45,18 +45,18 @@ class ReactiveRepositoryInformationUnitTests {
static final Class<ReactiveJavaInterfaceWithGenerics> BASE_CLASS = ReactiveJavaInterfaceWithGenerics.class;
@Test // DATACMNS-988
void discoversRxJava2MethodWithoutComparingReturnType() throws Exception {
void discoversRxJava3MethodWithoutComparingReturnType() throws Exception {
Method reference = extractTargetMethodFromRepository(RxJava2InterfaceWithGenerics.class, "deleteAll");
Method reference = extractTargetMethodFromRepository(RxJava3InterfaceWithGenerics.class, "deleteAll");
assertThat(reference.getDeclaringClass()).isEqualTo(ReactiveCrudRepository.class);
assertThat(reference.getName()).isEqualTo("deleteAll");
}
@Test // DATACMNS-988
void discoversRxJava2MethodWithConvertibleArguments() throws Exception {
void discoversRxJava3MethodWithConvertibleArguments() throws Exception {
Method reference = extractTargetMethodFromRepository(RxJava2InterfaceWithGenerics.class, "saveAll", Flowable.class);
Method reference = extractTargetMethodFromRepository(RxJava3InterfaceWithGenerics.class, "saveAll", Flowable.class);
assertThat(reference.getDeclaringClass()).isEqualTo(ReactiveCrudRepository.class);
assertThat(reference.getName()).isEqualTo("saveAll");
@@ -113,7 +113,7 @@ class ReactiveRepositoryInformationUnitTests {
return composition.findMethod(repositoryType.getMethod(methodName, args)).get();
}
interface RxJava2InterfaceWithGenerics extends RxJava2CrudRepository<User, String> {}
interface RxJava3InterfaceWithGenerics extends RxJava3CrudRepository<User, String> {}
interface ReactiveJavaInterfaceWithGenerics extends ReactiveCrudRepository<User, String> {}

10
src/test/java/org/springframework/data/repository/core/support/ReactiveWrapperRepositoryFactorySupportUnitTests.java
View File

@@ -17,8 +17,8 @@ package org.springframework.data.repository.core.support;
import static org.mockito.Mockito.*;
import io.reactivex.Completable;
import io.reactivex.Maybe;
import io.reactivex.rxjava3.core.Completable;
import io.reactivex.rxjava3.core.Maybe;
import io.reactivex.rxjava3.core.Single;
import reactor.core.publisher.Mono;
@@ -72,7 +72,7 @@ class ReactiveWrapperRepositoryFactorySupportUnitTests {
Long id = 1L;
when(backingRepo.findById(id)).thenReturn(Mono.just(true));
RxJava2ConvertingRepository repository = factory.getRepository(RxJava2ConvertingRepository.class);
RxJava3ConvertingRepository repository = factory.getRepository(RxJava3ConvertingRepository.class);
repository.findById(id);
verify(backingRepo, times(1)).findById(id);
@@ -84,14 +84,14 @@ class ReactiveWrapperRepositoryFactorySupportUnitTests {
Serializable id = 1L;
when(backingRepo.deleteById(id)).thenReturn(Mono.empty());
RxJava2ConvertingRepository repository = factory.getRepository(RxJava2ConvertingRepository.class);
RxJava3ConvertingRepository repository = factory.getRepository(RxJava3ConvertingRepository.class);
repository.deleteById(id);
verify(backingRepo, times(1)).deleteById(id);
}
interface RxJava2ConvertingRepository extends Repository<Object, Long> {
interface RxJava3ConvertingRepository extends Repository<Object, Long> {
Maybe<Boolean> findById(Serializable id);

2
src/test/java/org/springframework/data/repository/query/ResultProcessorUnitTests.java
View File

@@ -18,7 +18,7 @@ package org.springframework.data.repository.query;
import static org.assertj.core.api.Assertions.*;
import static org.mockito.Mockito.*;
import io.reactivex.Flowable;
import io.reactivex.rxjava3.core.Flowable;
import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.core.Single;
import lombok.Getter;

5
src/test/java/org/springframework/data/repository/util/QueryExecutionConvertersUnitTests.java
View File

@@ -102,11 +102,6 @@ class QueryExecutionConvertersUnitTests {
assertThat(QueryExecutionConverters.supportsUnwrapping(Single.class)).isFalse();
assertThat(QueryExecutionConverters.supportsUnwrapping(Completable.class)).isFalse();
assertThat(QueryExecutionConverters.supportsUnwrapping(Observable.class)).isFalse();
assertThat(QueryExecutionConverters.supportsUnwrapping(io.reactivex.Single.class)).isFalse();
assertThat(QueryExecutionConverters.supportsUnwrapping(io.reactivex.Maybe.class)).isFalse();
assertThat(QueryExecutionConverters.supportsUnwrapping(io.reactivex.Completable.class)).isFalse();
assertThat(QueryExecutionConverters.supportsUnwrapping(io.reactivex.Flowable.class)).isFalse();
assertThat(QueryExecutionConverters.supportsUnwrapping(io.reactivex.Observable.class)).isFalse();
}
@Test // DATACMNS-714

159
src/test/java/org/springframework/data/repository/util/ReactiveWrapperConvertersUnitTests.java
View File

@@ -17,7 +17,6 @@ package org.springframework.data.repository.util;
import static org.assertj.core.api.AssertionsForClassTypes.*;
import io.reactivex.Maybe;
import io.smallrye.mutiny.Multi;
import io.smallrye.mutiny.Uni;
import kotlinx.coroutines.flow.Flow;
@@ -47,16 +46,6 @@ class ReactiveWrapperConvertersUnitTests {
assertThat(ReactiveWrapperConverters.supports(Object.class)).isFalse();
}
@Test // DATACMNS-836
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();
}
@Test // DATACMNS-1653
void shouldSupportRxJava3Types() {
@@ -88,122 +77,6 @@ class ReactiveWrapperConvertersUnitTests {
assertThat(ReactiveWrapperConverters.toWrapper(foo, Mono.class)).isSameAs(foo);
}
@Test // DATACMNS-836
void toWrapperShouldConvertMonoToRxJava2Single() {
Mono<String> foo = Mono.just("foo");
assertThat(ReactiveWrapperConverters.toWrapper(foo, io.reactivex.Single.class))
.isInstanceOf(io.reactivex.Single.class);
}
@Test // DATACMNS-836
void toWrapperShouldConvertRxJava2SingleToMono() {
io.reactivex.Single<String> foo = io.reactivex.Single.just("foo");
assertThat(ReactiveWrapperConverters.toWrapper(foo, Mono.class)).isInstanceOf(Mono.class);
}
@Test // DATACMNS-836
void toWrapperShouldConvertRxJava2SingleToPublisher() {
io.reactivex.Single<String> foo = io.reactivex.Single.just("foo");
assertThat(ReactiveWrapperConverters.toWrapper(foo, Publisher.class)).isInstanceOf(Publisher.class);
}
@Test // DATACMNS-836
void toWrapperShouldConvertRxJava2MaybeToMono() {
io.reactivex.Maybe<String> foo = io.reactivex.Maybe.just("foo");
assertThat(ReactiveWrapperConverters.toWrapper(foo, Mono.class)).isInstanceOf(Mono.class);
}
@Test // DATACMNS-836
void toWrapperShouldConvertRxJava2MaybeToFlux() {
io.reactivex.Maybe<String> foo = io.reactivex.Maybe.just("foo");
assertThat(ReactiveWrapperConverters.toWrapper(foo, Flux.class)).isInstanceOf(Flux.class);
}
@Test // DATACMNS-836
void toWrapperShouldConvertRxJava2MaybeToPublisher() {
io.reactivex.Maybe<String> foo = io.reactivex.Maybe.just("foo");
assertThat(ReactiveWrapperConverters.toWrapper(foo, Publisher.class)).isInstanceOf(Publisher.class);
}
@Test // DATACMNS-836
void toWrapperShouldConvertRxJava2FlowableToMono() {
io.reactivex.Flowable<String> foo = io.reactivex.Flowable.just("foo");
assertThat(ReactiveWrapperConverters.toWrapper(foo, Mono.class)).isInstanceOf(Mono.class);
}
@Test // DATACMNS-836
void toWrapperShouldConvertRxJava2FlowableToFlux() {
io.reactivex.Flowable<String> foo = io.reactivex.Flowable.just("foo");
assertThat(ReactiveWrapperConverters.toWrapper(foo, Flux.class)).isInstanceOf(Flux.class);
}
@Test // DATACMNS-836
void toWrapperShouldCastRxJava2FlowableToPublisher() {
io.reactivex.Flowable<String> foo = io.reactivex.Flowable.just("foo");
assertThat(ReactiveWrapperConverters.toWrapper(foo, Publisher.class)).isSameAs(foo);
}
@Test // DATACMNS-836
void toWrapperShouldConvertRxJava2ObservableToMono() {
io.reactivex.Observable<String> foo = io.reactivex.Observable.just("foo");
assertThat(ReactiveWrapperConverters.toWrapper(foo, Mono.class)).isInstanceOf(Mono.class);
}
@Test // DATACMNS-836
void toWrapperShouldConvertRxJava2ObservableToFlux() {
io.reactivex.Observable<String> foo = io.reactivex.Observable.just("foo");
assertThat(ReactiveWrapperConverters.toWrapper(foo, Flux.class)).isInstanceOf(Flux.class);
}
@Test // DATACMNS-836
void toWrapperShouldConvertRxJava2ObservableToSingle() {
io.reactivex.Observable<String> foo = io.reactivex.Observable.just("foo");
assertThat(ReactiveWrapperConverters.toWrapper(foo, io.reactivex.Single.class))
.isInstanceOf(io.reactivex.Single.class);
}
@Test // DATACMNS-836
void toWrapperShouldConvertRxJava2ObservableToMaybe() {
io.reactivex.Observable<String> foo = io.reactivex.Observable.empty();
assertThat(ReactiveWrapperConverters.toWrapper(foo, Maybe.class)).isInstanceOf(Maybe.class);
}
@Test // DATACMNS-836
void toWrapperShouldConvertRxJava2ObservableToPublisher() {
io.reactivex.Observable<String> foo = io.reactivex.Observable.just("foo");
assertThat(ReactiveWrapperConverters.toWrapper(foo, Publisher.class)).isInstanceOf(Publisher.class);
}
@Test // DATACMNS-988
void toWrapperShouldConvertPublisherToRxJava2Observable() {
Flux<String> foo = Flux.just("foo");
assertThat(ReactiveWrapperConverters.toWrapper(foo, io.reactivex.Observable.class))
.isInstanceOf(io.reactivex.Observable.class);
}
@Test // DATACMNS-988
void toWrapperShouldConvertPublisherToRxJava2Flowable() {
Flux<String> foo = Flux.just("foo");
assertThat(ReactiveWrapperConverters.toWrapper(foo, io.reactivex.Flowable.class))
.isInstanceOf(io.reactivex.Flowable.class);
}
@Test // DATACMNS-836
void toWrapperShouldConvertMonoToFlux() {
@@ -227,38 +100,6 @@ class ReactiveWrapperConvertersUnitTests {
assertThat(map.next().block()).isEqualTo(1L);
}
@Test // DATACMNS-836
void shouldMapRxJava2Single() {
io.reactivex.Single<String> foo = io.reactivex.Single.just("foo");
io.reactivex.Single<Long> map = ReactiveWrapperConverters.map(foo, source -> 1L);
assertThat(map.blockingGet()).isEqualTo(1L);
}
@Test // DATACMNS-836
void shouldMapRxJava2Maybe() {
io.reactivex.Maybe<String> foo = io.reactivex.Maybe.just("foo");
io.reactivex.Maybe<Long> map = ReactiveWrapperConverters.map(foo, source -> 1L);
assertThat(map.toSingle().blockingGet()).isEqualTo(1L);
}
@Test // DATACMNS-836
void shouldMapRxJava2Observable() {
io.reactivex.Observable<String> foo = io.reactivex.Observable.just("foo");
io.reactivex.Observable<Long> map = ReactiveWrapperConverters.map(foo, source -> 1L);
assertThat(map.blockingFirst()).isEqualTo(1L);
}
@Test // DATACMNS-836
void shouldMapRxJava2Flowable() {
io.reactivex.Flowable<String> foo = io.reactivex.Flowable.just("foo");
io.reactivex.Flowable<Long> map = ReactiveWrapperConverters.map(foo, source -> 1L);
assertThat(map.blockingFirst()).isEqualTo(1L);
}
@Test // DATACMNS-1653
void shouldMapRxJava3Single() {

18
src/test/java/org/springframework/data/repository/util/ReactiveWrappersUnitTests.java
View File

@@ -17,8 +17,6 @@ package org.springframework.data.repository.util;
import static org.assertj.core.api.Assertions.*;
import io.reactivex.Completable;
import io.reactivex.Flowable;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
@@ -41,13 +39,8 @@ class ReactiveWrappersUnitTests {
assertThat(ReactiveWrappers.isNoValueType(Mono.class)).isFalse();
assertThat(ReactiveWrappers.isNoValueType(Flux.class)).isFalse();
assertThat(ReactiveWrappers.isNoValueType(Completable.class)).isTrue();
assertThat(ReactiveWrappers.isNoValueType(CompletableFuture.class)).isFalse();
assertThat(ReactiveWrappers.isNoValueType(Publisher.class)).isFalse();
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();
assertThat(ReactiveWrappers.isNoValueType(io.reactivex.rxjava3.core.Single.class)).isFalse();
assertThat(ReactiveWrappers.isNoValueType(io.reactivex.rxjava3.core.Maybe.class)).isFalse();
assertThat(ReactiveWrappers.isNoValueType(io.reactivex.rxjava3.core.Flowable.class)).isFalse();
@@ -61,14 +54,8 @@ class ReactiveWrappersUnitTests {
assertThat(ReactiveWrappers.isSingleValueType(Mono.class)).isTrue();
assertThat(ReactiveWrappers.isSingleValueType(Flux.class)).isFalse();
assertThat(ReactiveWrappers.isSingleValueType(Completable.class)).isFalse();
assertThat(ReactiveWrappers.isSingleValueType(CompletableFuture.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();
assertThat(ReactiveWrappers.isSingleValueType(io.reactivex.rxjava3.core.Single.class)).isTrue();
assertThat(ReactiveWrappers.isSingleValueType(io.reactivex.rxjava3.core.Completable.class)).isFalse();
assertThat(ReactiveWrappers.isSingleValueType(io.reactivex.rxjava3.core.Maybe.class)).isTrue();
@@ -83,13 +70,8 @@ class ReactiveWrappersUnitTests {
assertThat(ReactiveWrappers.isMultiValueType(Mono.class)).isFalse();
assertThat(ReactiveWrappers.isMultiValueType(Flux.class)).isTrue();
assertThat(ReactiveWrappers.isSingleValueType(Completable.class)).isFalse();
assertThat(ReactiveWrappers.isSingleValueType(CompletableFuture.class)).isFalse();
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();
assertThat(ReactiveWrappers.isMultiValueType(io.reactivex.rxjava3.core.Single.class)).isFalse();
assertThat(ReactiveWrappers.isSingleValueType(io.reactivex.rxjava3.core.Completable.class)).isFalse();
assertThat(ReactiveWrappers.isMultiValueType(io.reactivex.rxjava3.core.Flowable.class)).isTrue();