GitHub-Spring
/
spring-data-commons
mirror of https://github.com/spring-projects/spring-data-commons.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Simplify PreferredConstructorDiscovererUnitTests. 

Leverage things like Java var keyword to simplify test cases.

Resolves #2695.
Related: #2694.
Original pull request: #2724.
pull/2823/head
p.anisimov 3 years ago committed by Greg L. Turnquist
parent
c71f2fb8fe
commit
ccd56ef56e
No known key found for this signature in database
GPG Key ID: CB2FA4D512B5C413
1 changed files with 65 additions and 62 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 127
      src/test/java/org/springframework/data/mapping/PreferredConstructorDiscovererUnitTests.java

127
src/test/java/org/springframework/data/mapping/PreferredConstructorDiscovererUnitTests.java
Unescape View File

@ -39,56 +39,55 @@ import org.springframework.data.util.TypeInformation;
* @author Roman Rodov * @author Roman Rodov
* @author Mark Paluch * @author Mark Paluch
* @author Christoph Strobl * @author Christoph Strobl
* @author Pavel Anisimov
*/ */
class PreferredConstructorDiscovererUnitTests<P extends PersistentProperty<P>> { class PreferredConstructorDiscovererUnitTests<P extends PersistentProperty<P>> {
@Test // DATACMNS-1126 @Test // DATACMNS-1126
void findsNoArgConstructorForClassWithoutExplicitConstructor() { void findsNoArgConstructorForClassWithoutExplicitConstructor() {
assertThat(PreferredConstructorDiscoverer.discover(EntityWithoutConstructor.class)).satisfies(constructor -> { var constructor = PreferredConstructorDiscoverer.discover(EntityWithoutConstructor.class);
assertThat(constructor).isNotNull(); assertThat(constructor).isNotNull();
assertThat(constructor.isNoArgConstructor()).isTrue(); assertThat(constructor.isNoArgConstructor()).isTrue();
assertThat(constructor.isExplicitlyAnnotated()).isFalse(); assertThat(constructor.isExplicitlyAnnotated()).isFalse();
});
} }
@Test // DATACMNS-1126 @Test // DATACMNS-1126
void findsNoArgConstructorForClassWithMultipleConstructorsAndNoArgOne() { void findsNoArgConstructorForClassWithMultipleConstructorsAndNoArgOne() {
assertThat(PreferredConstructorDiscoverer.discover(ClassWithEmptyConstructor.class)).satisfies(constructor -> { var constructor = PreferredConstructorDiscoverer.discover(ClassWithEmptyConstructor.class);
assertThat(constructor).isNotNull(); assertThat(constructor).isNotNull();
assertThat(constructor.isNoArgConstructor()).isTrue(); assertThat(constructor.isNoArgConstructor()).isTrue();
assertThat(constructor.isExplicitlyAnnotated()).isFalse(); assertThat(constructor.isExplicitlyAnnotated()).isFalse();
});
} }
@Test // DATACMNS-1126 @Test // DATACMNS-1126
void doesNotThrowExceptionForMultipleConstructorsAndNoNoArgConstructorWithoutAnnotation() { void doesNotThrowExceptionForMultipleConstructorsAndNoNoArgConstructorWithoutAnnotation() {
assertThat(PreferredConstructorDiscoverer.discover(ClassWithMultipleConstructorsWithoutEmptyOne.class)).isNull(); var constructor = PreferredConstructorDiscoverer.discover(ClassWithMultipleConstructorsWithoutEmptyOne.class);
assertThat(constructor).isNull();
} }
@Test // DATACMNS-1126 @Test // DATACMNS-1126
@SuppressWarnings({ "unchecked", "rawtypes" })
void usesConstructorWithAnnotationOverEveryOther() { void usesConstructorWithAnnotationOverEveryOther() {
assertThat(PreferredConstructorDiscoverer.discover(ClassWithMultipleConstructorsAndAnnotation.class)) PreferredConstructor<ClassWithMultipleConstructorsAndAnnotation, P> constructor = PreferredConstructorDiscoverer
.satisfies(constructor -> { .discover(ClassWithMultipleConstructorsAndAnnotation.class);
assertThat(constructor).isNotNull(); assertThat(constructor).isNotNull();
assertThat(constructor.isNoArgConstructor()).isFalse(); assertThat(constructor.isNoArgConstructor()).isFalse();
assertThat(constructor.isExplicitlyAnnotated()).isTrue(); assertThat(constructor.isExplicitlyAnnotated()).isTrue();
assertThat(constructor.hasParameters()).isTrue(); assertThat(constructor.hasParameters()).isTrue();
Iterator<Parameter<Object, P>> parameters = (Iterator) constructor.getParameters().iterator(); Iterator<Parameter<Object, P>> parameters = constructor.getParameters().iterator();
Parameter<?, P> parameter = parameters.next(); Parameter<?, P> parameter = parameters.next();
assertThat(parameter.getType().getType()).isEqualTo(Long.class); assertThat(parameter.getType().getType()).isEqualTo(Long.class);
assertThat(parameters.hasNext()).isFalse(); assertThat(parameters.hasNext()).isFalse();
});
} }
@Test // DATACMNS-134, DATACMNS-1126 @Test // DATACMNS-134, DATACMNS-1126
@ -96,11 +95,12 @@ class PreferredConstructorDiscovererUnitTests<P extends PersistentProperty<P>> {
PersistentEntity<Inner, P> entity = new BasicPersistentEntity<>(TypeInformation.of(Inner.class)); PersistentEntity<Inner, P> entity = new BasicPersistentEntity<>(TypeInformation.of(Inner.class));
assertThat(PreferredConstructorDiscoverer.discover(entity)).satisfies(constructor -> { var constructor = PreferredConstructorDiscoverer.discover(entity);
assertThat(constructor).isNotNull();
Parameter<?, P> parameter = constructor.getParameters().iterator().next(); Parameter<?, P> parameter = constructor.getParameters().iterator().next();
assertThat(constructor.isParentParameter(parameter)).isTrue(); assertThat(constructor.isParentParameter(parameter)).isTrue();
});
} }
@Test // DATACMNS-1082, DATACMNS-1126 @Test // DATACMNS-1082, DATACMNS-1126
@ -109,73 +109,76 @@ class PreferredConstructorDiscovererUnitTests<P extends PersistentProperty<P>> {
PersistentEntity<SyntheticConstructor, P> entity = new BasicPersistentEntity<>( PersistentEntity<SyntheticConstructor, P> entity = new BasicPersistentEntity<>(
TypeInformation.of(SyntheticConstructor.class)); TypeInformation.of(SyntheticConstructor.class));
assertThat(PreferredConstructorDiscoverer.discover(entity)).satisfies(constructor -> { var constructor = PreferredConstructorDiscoverer.discover(entity);
assertThat(constructor).isNotNull();
var annotation = constructor.getConstructor().getAnnotation(PersistenceConstructor.class); var annotation = constructor.getConstructor().getAnnotation(PersistenceConstructor.class);
assertThat(annotation).isNotNull(); assertThat(annotation).isNotNull();
assertThat(constructor.getConstructor().isSynthetic()).isFalse(); assertThat(constructor.getConstructor().isSynthetic()).isFalse();
});
} }
@Test // GH-2313 @Test // GH-2313
void capturesEnclosingTypeParameterOfNonStaticInnerClass() { void capturesEnclosingTypeParameterOfNonStaticInnerClass() {
assertThat(PreferredConstructorDiscoverer.discover(NonStaticWithGenericTypeArgUsedInCtor.class)).satisfies(ctor -> { var constructor = PreferredConstructorDiscoverer.discover(NonStaticWithGenericTypeArgUsedInCtor.class);
assertThat(ctor.getParameters()).hasSize(2); assertThat(constructor).isNotNull();
assertThat(ctor.getParameters().get(0).getName()).isEqualTo("this$0"); assertThat(constructor.getParameters()).hasSize(2);
assertThat(ctor.getParameters().get(1).getName()).isEqualTo("value"); assertThat(constructor.getParameters().get(0).getName()).isEqualTo("this$0");
}); assertThat(constructor.getParameters().get(1).getName()).isEqualTo("value");
} }
@Test // GH-2313 @Test // GH-2313
void capturesSuperClassEnclosingTypeParameterOfNonStaticInnerClass() { void capturesSuperClassEnclosingTypeParameterOfNonStaticInnerClass() {
assertThat(PreferredConstructorDiscoverer.discover(NonStaticInnerWithGenericArgUsedInCtor.class)) var constructor = PreferredConstructorDiscoverer.discover(NonStaticInnerWithGenericArgUsedInCtor.class);
.satisfies(ctor -> {
assertThat(ctor.getParameters()).hasSize(2); assertThat(constructor).isNotNull();
assertThat(ctor.getParameters().get(0).getName()).isEqualTo("this$0"); assertThat(constructor.getParameters()).hasSize(2);
assertThat(ctor.getParameters().get(1).getName()).isEqualTo("value"); assertThat(constructor.getParameters().get(0).getName()).isEqualTo("this$0");
}); assertThat(constructor.getParameters().get(1).getName()).isEqualTo("value");
} }
@Test // GH-2332 @Test // GH-2332
void detectsMetaAnnotatedValueAnnotation() { void detectsMetaAnnotatedValueAnnotation() {
assertThat(PreferredConstructorDiscoverer.discover(ClassWithMetaAnnotatedParameter.class)).satisfies(ctor -> { var constructor = PreferredConstructorDiscoverer.discover(ClassWithMetaAnnotatedParameter.class);
assertThat(ctor.getParameters().get(0).getSpelExpression()).isEqualTo("${hello-world}"); assertThat(constructor).isNotNull();
assertThat(ctor.getParameters().get(0).getAnnotations()).isNotNull(); assertThat(constructor.getParameters().get(0).getSpelExpression()).isEqualTo("${hello-world}");
}); assertThat(constructor.getParameters().get(0).getAnnotations()).isNotNull();
} }
@Test // GH-2332 @Test // GH-2332
void detectsCanonicalRecordConstructor() { void detectsCanonicalRecordConstructorWhenRecordHasSingleArgConstructor() {
assertThat(PreferredConstructorDiscoverer.discover(RecordWithSingleArgConstructor.class)).satisfies(ctor -> { var constructor = PreferredConstructorDiscoverer.discover(RecordWithSingleArgConstructor.class);
assertThat(ctor.getParameters()).hasSize(2); assertThat(constructor).isNotNull();
assertThat(ctor.getParameters().get(0).getRawType()).isEqualTo(Long.class); assertThat(constructor.getParameters()).hasSize(2);
assertThat(ctor.getParameters().get(1).getRawType()).isEqualTo(String.class); assertThat(constructor.getParameters().get(0).getRawType()).isEqualTo(Long.class);
}); assertThat(constructor.getParameters().get(1).getRawType()).isEqualTo(String.class);
}
@Test // GH-2332
void detectsCanonicalRecordConstructorWhenRecordHasNoArgConstructor() {
assertThat(PreferredConstructorDiscoverer.discover(RecordWithNoArgConstructor.class)).satisfies(ctor -> { var constructor = PreferredConstructorDiscoverer.discover(RecordWithNoArgConstructor.class);
assertThat(ctor.getParameters()).hasSize(2); assertThat(constructor).isNotNull();
assertThat(ctor.getParameters().get(0).getRawType()).isEqualTo(Long.class); assertThat(constructor.getParameters()).hasSize(2);
assertThat(ctor.getParameters().get(1).getRawType()).isEqualTo(String.class); assertThat(constructor.getParameters().get(0).getRawType()).isEqualTo(Long.class);
}); assertThat(constructor.getParameters().get(1).getRawType()).isEqualTo(String.class);
} }
@Test // GH-2332 @Test // GH-2332
void detectsAnnotatedRecordConstructor() { void detectsAnnotatedRecordConstructor() {
assertThat(PreferredConstructorDiscoverer.discover(RecordWithPersistenceCreator.class)).satisfies(ctor -> { var constructor = PreferredConstructorDiscoverer.discover(RecordWithPersistenceCreator.class);
assertThat(ctor.getParameters()).hasSize(1); assertThat(constructor).isNotNull();
assertThat(ctor.getParameters().get(0).getRawType()).isEqualTo(String.class); assertThat(constructor.getParameters()).hasSize(1);
}); assertThat(constructor.getParameters().get(0).getRawType()).isEqualTo(String.class);
} }
static class SyntheticConstructor { static class SyntheticConstructor {

Write Preview
Loading…
Cancel
Save