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

DATACMNS-867 - Ported tests for reactive support to AssertJ.

Browse Source
This commit is contained in:
Oliver Gierke
2016-11-15 12:32:45 +01:00
parent fd2c400c4e
commit 615b6548e8
5 changed files with 109 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/test/java/org/springframework/data/repository/config/RepositoryConfigurationExtensionSupportUnitTests.java
View File

@@ -41,21 +41,21 @@ public class RepositoryConfigurationExtensionSupportUnitTests {
public void doesNotConsiderRepositoryForPlainTypeStrictMatch() {
RepositoryMetadata metadata = AbstractRepositoryMetadata.getMetadata(PlainTypeRepository.class);
assertThat(extension.isStrictRepositoryCandidate(metadata), is(false));
assertThat(extension.isStrictRepositoryCandidate(metadata)).isFalse();
}
@Test // DATACMNS-526
public void considersRepositoryWithAnnotatedTypeStrictMatch() {
RepositoryMetadata metadata = AbstractRepositoryMetadata.getMetadata(AnnotatedTypeRepository.class);
assertThat(extension.isStrictRepositoryCandidate(metadata), is(true));
assertThat(extension.isStrictRepositoryCandidate(metadata)).isTrue();
}
@Test // DATACMNS-526
public void considersRepositoryInterfaceExtendingStoreInterfaceStrictMatch() {
RepositoryMetadata metadata = AbstractRepositoryMetadata.getMetadata(ExtendingInterface.class);
assertThat(extension.isStrictRepositoryCandidate(metadata), is(true));
assertThat(extension.isStrictRepositoryCandidate(metadata)).isTrue();
}
static class SampleRepositoryConfigurationExtension extends RepositoryConfigurationExtensionSupport {

70
src/test/java/org/springframework/data/repository/core/support/QueryExecutionResultHandlerUnitTests.java
View File

@@ -108,10 +108,10 @@ public class QueryExecutionResultHandlerUnitTests {
Single<Entity> entity = Single.just(new Entity());
Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("publisher"));
assertThat(result, is(instanceOf(Publisher.class)));
assertThat(result).isInstanceOf(Publisher.class);
Mono<Entity> mono = Mono.from((Publisher<Entity>) result);
assertThat(mono.block(), is(entity.toBlocking().value()));
assertThat(mono.block()).isEqualTo(entity.toBlocking().value());
}
@Test // DATACMNS-836
@@ -121,10 +121,10 @@ public class QueryExecutionResultHandlerUnitTests {
Single<Entity> entity = Single.just(new Entity());
Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("mono"));
assertThat(result, is(instanceOf(Mono.class)));
assertThat(result).isInstanceOf(Mono.class);
Mono<Entity> mono = (Mono<Entity>) result;
assertThat(mono.block(), is(entity.toBlocking().value()));
assertThat(mono.block()).isEqualTo(entity.toBlocking().value());
}
@Test // DATACMNS-836
@@ -134,10 +134,10 @@ public class QueryExecutionResultHandlerUnitTests {
Single<Entity> entity = Single.just(new Entity());
Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("flux"));
assertThat(result, is(instanceOf(Flux.class)));
assertThat(result).isInstanceOf(Flux.class);
Flux<Entity> flux = (Flux<Entity>) result;
assertThat(flux.next().block(), is(entity.toBlocking().value()));
assertThat(flux.next().block()).isEqualTo(entity.toBlocking().value());
}
@Test // DATACMNS-836
@@ -147,10 +147,10 @@ public class QueryExecutionResultHandlerUnitTests {
Observable<Entity> entity = Observable.just(new Entity());
Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("publisher"));
assertThat(result, is(instanceOf(Publisher.class)));
assertThat(result).isInstanceOf(Publisher.class);
Mono<Entity> mono = Mono.from((Publisher<Entity>) result);
assertThat(mono.block(), is(entity.toBlocking().first()));
assertThat(mono.block()).isEqualTo(entity.toBlocking().first());
}
@Test // DATACMNS-836
@@ -160,10 +160,10 @@ public class QueryExecutionResultHandlerUnitTests {
Observable<Entity> entity = Observable.just(new Entity());
Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("mono"));
assertThat(result, is(instanceOf(Mono.class)));
assertThat(result).isInstanceOf(Mono.class);
Mono<Entity> mono = (Mono<Entity>) result;
assertThat(mono.block(), is(entity.toBlocking().first()));
assertThat(mono.block()).isEqualTo(entity.toBlocking().first());
}
@Test // DATACMNS-836
@@ -173,10 +173,10 @@ public class QueryExecutionResultHandlerUnitTests {
Observable<Entity> entity = Observable.just(new Entity());
Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("flux"));
assertThat(result, is(instanceOf(Flux.class)));
assertThat(result).isInstanceOf(Flux.class);
Flux<Entity> flux = (Flux<Entity>) result;
assertThat(flux.next().block(), is(entity.toBlocking().first()));
assertThat(flux.next().block()).isEqualTo(entity.toBlocking().first());
}
@Test // DATACMNS-836
@@ -186,10 +186,10 @@ public class QueryExecutionResultHandlerUnitTests {
Observable<Entity> entity = Observable.just(new Entity());
Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("single"));
assertThat(result, is(instanceOf(Single.class)));
assertThat(result).isInstanceOf(Single.class);
Single<Entity> single = (Single<Entity>) result;
assertThat(single.toBlocking().value(), is(entity.toBlocking().first()));
assertThat(single.toBlocking().value()).isEqualTo(entity.toBlocking().first());
}
@Test // DATACMNS-836
@@ -199,10 +199,10 @@ public class QueryExecutionResultHandlerUnitTests {
Single<Entity> entity = Single.just(new Entity());
Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("observable"));
assertThat(result, is(instanceOf(Observable.class)));
assertThat(result).isInstanceOf(Observable.class);
Observable<Entity> observable = (Observable<Entity>) result;
assertThat(observable.toBlocking().first(), is(entity.toBlocking().value()));
assertThat(observable.toBlocking().first()).isEqualTo(entity.toBlocking().value());
}
@Test // DATACMNS-836
@@ -212,10 +212,10 @@ public class QueryExecutionResultHandlerUnitTests {
Mono<Entity> entity = Mono.just(new Entity());
Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("single"));
assertThat(result, is(instanceOf(Single.class)));
assertThat(result).isInstanceOf(Single.class);
Single<Entity> single = (Single<Entity>) result;
assertThat(single.toBlocking().value(), is(entity.block()));
assertThat(single.toBlocking().value()).isEqualTo(entity.block());
}
@Test // DATACMNS-836
@@ -225,10 +225,10 @@ public class QueryExecutionResultHandlerUnitTests {
Mono<Entity> entity = Mono.just(new Entity());
Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("completable"));
assertThat(result, is(instanceOf(Completable.class)));
assertThat(result).isInstanceOf(Completable.class);
Completable completable = (Completable) result;
assertThat(completable.get(), is(nullValue()));
assertThat(completable.get()).isNull();
}
@Test // DATACMNS-836
@@ -238,10 +238,10 @@ public class QueryExecutionResultHandlerUnitTests {
Mono<Entity> entity = Mono.error(new InvalidDataAccessApiUsageException("err"));
Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("completable"));
assertThat(result, is(instanceOf(Completable.class)));
assertThat(result).isInstanceOf(Completable.class);
Completable completable = (Completable) result;
assertThat(completable.get(), is(instanceOf(InvalidDataAccessApiUsageException.class)));
assertThat(completable.get()).isInstanceOf(InvalidDataAccessApiUsageException.class);
}
@Test // DATACMNS-836
@@ -251,10 +251,10 @@ public class QueryExecutionResultHandlerUnitTests {
Completable entity = Completable.complete();
Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("mono"));
assertThat(result, is(instanceOf(Mono.class)));
assertThat(result).isInstanceOf(Mono.class);
Mono mono = (Mono) result;
assertThat(mono.block(), is(nullValue()));
assertThat(mono.block()).isNull();
}
@Test(expected = InvalidDataAccessApiUsageException.class) // DATACMNS-836
@@ -264,7 +264,7 @@ public class QueryExecutionResultHandlerUnitTests {
Completable entity = Completable.error(new InvalidDataAccessApiUsageException("err"));
Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("mono"));
assertThat(result, is(instanceOf(Mono.class)));
assertThat(result).isInstanceOf(Mono.class);
Mono mono = (Mono) result;
mono.block();
@@ -278,10 +278,10 @@ public class QueryExecutionResultHandlerUnitTests {
Mono<Entity> entity = Mono.just(new Entity());
Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("observable"));
assertThat(result, is(instanceOf(Observable.class)));
assertThat(result).isInstanceOf(Observable.class);
Observable<Entity> observable = (Observable<Entity>) result;
assertThat(observable.toBlocking().first(), is(entity.block()));
assertThat(observable.toBlocking().first()).isEqualTo(entity.block());
}
@Test // DATACMNS-836
@@ -291,10 +291,10 @@ public class QueryExecutionResultHandlerUnitTests {
Flux<Entity> entity = Flux.just(new Entity());
Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("single"));
assertThat(result, is(instanceOf(Single.class)));
assertThat(result).isInstanceOf(Single.class);
Single<Entity> single = (Single<Entity>) result;
assertThat(single.toBlocking().value(), is(entity.next().block()));
assertThat(single.toBlocking().value()).isEqualTo(entity.next().block());
}
@Test // DATACMNS-836
@@ -304,10 +304,10 @@ public class QueryExecutionResultHandlerUnitTests {
Flux<Entity> entity = Flux.just(new Entity());
Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("observable"));
assertThat(result, is(instanceOf(Observable.class)));
assertThat(result).isInstanceOf(Observable.class);
Observable<Entity> observable = (Observable<Entity>) result;
assertThat(observable.toBlocking().first(), is(entity.next().block()));
assertThat(observable.toBlocking().first()).isEqualTo(entity.next().block());
}
@Test // DATACMNS-836
@@ -317,10 +317,10 @@ public class QueryExecutionResultHandlerUnitTests {
Flux<Entity> entity = Flux.just(new Entity());
Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("mono"));
assertThat(result, is(instanceOf(Mono.class)));
assertThat(result).isInstanceOf(Mono.class);
Mono<Entity> mono = (Mono<Entity>) result;
assertThat(mono.block(), is(entity.next().block()));
assertThat(mono.block()).isEqualTo(entity.next().block());
}
@Test // DATACMNS-836
@@ -330,10 +330,10 @@ public class QueryExecutionResultHandlerUnitTests {
Mono<Entity> entity = Mono.just(new Entity());
Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("flux"));
assertThat(result, is(instanceOf(Flux.class)));
assertThat(result).isInstanceOf(Flux.class);
Flux<Entity> flux = (Flux<Entity>) result;
assertThat(flux.next().block(), is(entity.block()));
assertThat(flux.next().block()).isEqualTo(entity.block());
}
private static TypeDescriptor getTypeDescriptorFor(String methodName) throws Exception {

6
src/test/java/org/springframework/data/repository/query/ParametersUnitTests.java
View File

@@ -17,6 +17,8 @@ package org.springframework.data.repository.query;
import static org.assertj.core.api.Assertions.*;
import rx.Single;
import java.lang.reflect.Method;
import java.util.Optional;
@@ -167,7 +169,7 @@ public class ParametersUnitTests {
Parameters<?, Parameter> parameters = getParametersFor("methodWithPublisher", Publisher.class);
assertThat(parameters.getParameter(0).getType(), is(typeCompatibleWith(Publisher.class)));
assertThat(parameters.getParameter(0).getType()).isAssignableFrom(Publisher.class);
}
@Test // DATACMNS-836
@@ -175,7 +177,7 @@ public class ParametersUnitTests {
Parameters<?, Parameter> parameters = getParametersFor("methodWithSingle", Single.class);
assertThat(parameters.getParameter(0).getType(), is(typeCompatibleWith(Single.class)));
assertThat(parameters.getParameter(0).getType()).isAssignableFrom(Single.class);
}
private Parameters<?, Parameter> getParametersFor(String methodName, Class<?>... parameterTypes)

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

@@ -223,11 +223,11 @@ public class ResultProcessorUnitTests {
Object result = getProcessor("findMonoSample").processResult(samples);
assertThat(result, is(instanceOf(Mono.class)));
assertThat(result).isInstanceOf(Mono.class);
Object content = ((Mono<Object>) result).block();
assertThat(content, is(instanceOf(Sample.class)));
assertThat(content).isInstanceOf(Sample.class);
}
@Test // DATACMNS-836
@@ -238,11 +238,11 @@ public class ResultProcessorUnitTests {
Object result = getProcessor("findSingleSample").processResult(samples);
assertThat(result, is(instanceOf(Single.class)));
assertThat(result).isInstanceOf(Single.class);
Object content = ((Single<Object>) result).toBlocking().value();
assertThat(content, is(instanceOf(Sample.class)));
assertThat(content).isInstanceOf(Sample.class);
}
@Test // DATACMNS-836
@@ -254,11 +254,11 @@ public class ResultProcessorUnitTests {
Object result = processor.processResult(Mono.just(new Sample("Dave", "Matthews")), source -> new SampleDto());
assertThat(result, is(instanceOf(Mono.class)));
assertThat(result).isInstanceOf(Mono.class);
Object content = ((Mono<Object>) result).block();
assertThat(content, is(instanceOf(SampleDto.class)));
assertThat(content).isInstanceOf(SampleDto.class);
}
@Test // DATACMNS-836
@@ -269,12 +269,12 @@ public class ResultProcessorUnitTests {
Object result = getProcessor("findFluxProjection").processResult(samples);
assertThat(result, is(instanceOf(Flux.class)));
assertThat(result).isInstanceOf(Flux.class);
List<Object> content = ((Flux<Object>) result).collectList().block();
assertThat(content, is(not(empty())));
assertThat(content.get(0), is(instanceOf(SampleProjection.class)));
assertThat(content).isNotEmpty();
assertThat(content.get(0)).isInstanceOf(SampleProjection.class);
}
@Test // DATACMNS-836
@@ -285,12 +285,12 @@ public class ResultProcessorUnitTests {
Object result = getProcessor("findObservableProjection").processResult(samples);
assertThat(result, is(instanceOf(Observable.class)));
assertThat(result).isInstanceOf(Observable.class);
List<Object> content = ((Observable<Object>) result).toList().toBlocking().single();
assertThat(content, is(not(empty())));
assertThat(content.get(0), is(instanceOf(SampleProjection.class)));
assertThat(content).isNotEmpty();
assertThat(content.get(0)).isInstanceOf(SampleProjection.class);
}
private static ResultProcessor getProcessor(String methodName, Class<?>... parameters) throws Exception {

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

@@ -15,9 +15,7 @@
*/
package org.springframework.data.repository.util;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.*;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.*;
import static org.springframework.data.repository.util.QueryExecutionConverters.*;
import javaslang.collection.HashMap;
@@ -40,7 +38,6 @@ import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Future;
import org.hamcrest.Matchers;
import org.junit.Before;
import org.junit.Test;
import org.reactivestreams.Publisher;
@@ -78,49 +75,49 @@ public class QueryExecutionConvertersUnitTests {
assertThat(QueryExecutionConverters.supports(Future.class)).isTrue();
assertThat(QueryExecutionConverters.supports(ListenableFuture.class)).isTrue();
assertThat(QueryExecutionConverters.supports(Option.class)).isTrue();
assertThat(QueryExecutionConverters.supports(javaslang.control.Option.class), is(true));
assertThat(QueryExecutionConverters.supports(javaslang.control.Option.class)).isTrue();
}
@Test // DATACMNS-836
public void registersReactiveWrapperTypes() {
assertThat(QueryExecutionConverters.supports(Publisher.class), is(true));
assertThat(QueryExecutionConverters.supports(Mono.class), is(true));
assertThat(QueryExecutionConverters.supports(Flux.class), is(true));
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));
assertThat(QueryExecutionConverters.supports(Publisher.class)).isTrue();
assertThat(QueryExecutionConverters.supports(Mono.class)).isTrue();
assertThat(QueryExecutionConverters.supports(Flux.class)).isTrue();
assertThat(QueryExecutionConverters.supports(Single.class)).isTrue();
assertThat(QueryExecutionConverters.supports(Completable.class)).isTrue();
assertThat(QueryExecutionConverters.supports(Observable.class)).isTrue();
assertThat(QueryExecutionConverters.supports(io.reactivex.Single.class)).isTrue();
assertThat(QueryExecutionConverters.supports(io.reactivex.Maybe.class)).isTrue();
assertThat(QueryExecutionConverters.supports(io.reactivex.Completable.class)).isTrue();
assertThat(QueryExecutionConverters.supports(io.reactivex.Flowable.class)).isTrue();
assertThat(QueryExecutionConverters.supports(io.reactivex.Observable.class)).isTrue();
}
@Test // DATACMNS-836
public void registersUnwrapperTypes() {
assertThat(QueryExecutionConverters.supportsUnwrapping(Optional.class), is(true));
assertThat(QueryExecutionConverters.supportsUnwrapping(java.util.Optional.class), is(true));
assertThat(QueryExecutionConverters.supportsUnwrapping(Future.class), is(true));
assertThat(QueryExecutionConverters.supportsUnwrapping(ListenableFuture.class), is(true));
assertThat(QueryExecutionConverters.supportsUnwrapping(Option.class), is(true));
assertThat(QueryExecutionConverters.supportsUnwrapping(Optional.class)).isTrue();
assertThat(QueryExecutionConverters.supportsUnwrapping(java.util.Optional.class)).isTrue();
assertThat(QueryExecutionConverters.supportsUnwrapping(Future.class)).isTrue();
assertThat(QueryExecutionConverters.supportsUnwrapping(ListenableFuture.class)).isTrue();
assertThat(QueryExecutionConverters.supportsUnwrapping(Option.class)).isTrue();
}
@Test // DATACMNS-836
public void doesNotRegisterReactiveUnwrapperTypes() {
assertThat(QueryExecutionConverters.supportsUnwrapping(Publisher.class), is(false));
assertThat(QueryExecutionConverters.supportsUnwrapping(Mono.class), is(false));
assertThat(QueryExecutionConverters.supportsUnwrapping(Flux.class), is(false));
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));
assertThat(QueryExecutionConverters.supportsUnwrapping(Publisher.class)).isFalse();
assertThat(QueryExecutionConverters.supportsUnwrapping(Mono.class)).isFalse();
assertThat(QueryExecutionConverters.supportsUnwrapping(Flux.class)).isFalse();
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
@@ -186,9 +183,10 @@ public class QueryExecutionConvertersUnitTests {
}
@Test // DATACMNS-937
@SuppressWarnings("unchecked")
public void turnsNullIntoJavaslangOption() {
assertThat(conversionService.convert(new NullableWrapper(null), javaslang.control.Option.class),
is((Object) optionNone()));
assertThat(conversionService.convert(new NullableWrapper(null), javaslang.control.Option.class))
.isEqualTo(optionNone());
}
@Test // DATACMNS-937
@@ -197,78 +195,78 @@ public class QueryExecutionConvertersUnitTests {
javaslang.control.Option<?> result = conversionService.convert(new NullableWrapper("string"),
javaslang.control.Option.class);
assertThat(result.isEmpty(), is(false));
assertThat(result.get(), is((Object) "string"));
assertThat(result.isEmpty()).isFalse();
assertThat(result.get()).isEqualTo("string");
}
@Test // DATACMNS-937
public void unwrapsEmptyJavaslangOption() {
assertThat(QueryExecutionConverters.unwrap(optionNone()), is(nullValue()));
assertThat(QueryExecutionConverters.unwrap(optionNone())).isNull();
}
@Test // DATACMNS-937
public void unwrapsJavaslangOption() {
assertThat(QueryExecutionConverters.unwrap(option("string")), is((Object) "string"));
assertThat(QueryExecutionConverters.unwrap(option("string"))).isEqualTo("string");
}
@Test // DATACMNS-940
public void conversListToJavaslang() {
assertThat(conversionService.canConvert(List.class, javaslang.collection.Traversable.class), is(true));
assertThat(conversionService.canConvert(List.class, javaslang.collection.List.class), is(true));
assertThat(conversionService.canConvert(List.class, javaslang.collection.Set.class), is(true));
assertThat(conversionService.canConvert(List.class, javaslang.collection.Map.class), is(false));
assertThat(conversionService.canConvert(List.class, javaslang.collection.Traversable.class)).isTrue();
assertThat(conversionService.canConvert(List.class, javaslang.collection.List.class)).isTrue();
assertThat(conversionService.canConvert(List.class, javaslang.collection.Set.class)).isTrue();
assertThat(conversionService.canConvert(List.class, javaslang.collection.Map.class)).isFalse();
List<Integer> integers = Arrays.asList(1, 2, 3);
Traversable<?> result = conversionService.convert(integers, Traversable.class);
assertThat(result, is(instanceOf(javaslang.collection.List.class)));
assertThat(result).isInstanceOf(javaslang.collection.List.class);
}
@Test // DATACMNS-940
public void convertsSetToJavaslang() {
assertThat(conversionService.canConvert(Set.class, javaslang.collection.Traversable.class), is(true));
assertThat(conversionService.canConvert(Set.class, javaslang.collection.Set.class), is(true));
assertThat(conversionService.canConvert(Set.class, javaslang.collection.List.class), is(true));
assertThat(conversionService.canConvert(Set.class, javaslang.collection.Map.class), is(false));
assertThat(conversionService.canConvert(Set.class, javaslang.collection.Traversable.class)).isTrue();
assertThat(conversionService.canConvert(Set.class, javaslang.collection.Set.class)).isTrue();
assertThat(conversionService.canConvert(Set.class, javaslang.collection.List.class)).isTrue();
assertThat(conversionService.canConvert(Set.class, javaslang.collection.Map.class)).isFalse();
Set<Integer> integers = Collections.singleton(1);
Traversable<?> result = conversionService.convert(integers, Traversable.class);
assertThat(result, is(instanceOf(javaslang.collection.Set.class)));
assertThat(result).isInstanceOf(javaslang.collection.Set.class);
}
@Test // DATACMNS-940
public void convertsMapToJavaslang() {
assertThat(conversionService.canConvert(Map.class, javaslang.collection.Traversable.class), is(true));
assertThat(conversionService.canConvert(Map.class, javaslang.collection.Map.class), is(true));
assertThat(conversionService.canConvert(Map.class, javaslang.collection.Set.class), is(false));
assertThat(conversionService.canConvert(Map.class, javaslang.collection.List.class), is(false));
assertThat(conversionService.canConvert(Map.class, javaslang.collection.Traversable.class)).isTrue();
assertThat(conversionService.canConvert(Map.class, javaslang.collection.Map.class)).isTrue();
assertThat(conversionService.canConvert(Map.class, javaslang.collection.Set.class)).isFalse();
assertThat(conversionService.canConvert(Map.class, javaslang.collection.List.class)).isFalse();
Map<String, String> map = Collections.singletonMap("key", "value");
Traversable<?> result = conversionService.convert(map, Traversable.class);
assertThat(result, is(instanceOf(javaslang.collection.Map.class)));
assertThat(result).isInstanceOf(javaslang.collection.Map.class);
}
@Test // DATACMNS-940
public void unwrapsJavaslangCollectionsToJavaOnes() {
assertThat(unwrap(javaslangList(1, 2, 3)), is(instanceOf(List.class)));
assertThat(unwrap(javaslangSet(1, 2, 3)), is(instanceOf(Set.class)));
assertThat(unwrap(javaslangMap("key", "value")), is(instanceOf(Map.class)));
assertThat(unwrap(javaslangList(1, 2, 3))).isInstanceOf(List.class);
assertThat(unwrap(javaslangSet(1, 2, 3))).isInstanceOf(Set.class);
assertThat(unwrap(javaslangMap("key", "value"))).isInstanceOf(Map.class);
}
@Test // DATACMNS-1005
public void registersAllowedPageabletypes() {
Set<Class<?>> allowedPageableTypes = QueryExecutionConverters.getAllowedPageableTypes();
assertThat(allowedPageableTypes, Matchers.<Class<?>> hasItems(Page.class, Slice.class, List.class, Seq.class));
assertThat(allowedPageableTypes).contains(Page.class, Slice.class, List.class, Seq.class);
}
@SuppressWarnings("unchecked")