Skip to content

Commit 7fb57f4

Browse files
mp911demp911de
committed
Polishing.
Split tests into parametrized tests.
1 parent 048f259 commit 7fb57f4

File tree

5 files changed

+139
-109
lines changed

5 files changed

+139
-109
lines changed

‎src/main/java/org/springframework/data/javapoet/TypeNames.java‎

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -84,24 +84,24 @@ public static TypeName resolvedTypeName(ResolvableType resolvableType) {
8484
return TypeName.get(Object.class);
8585
}
8686

87+
if (resolvableType.hasResolvableGenerics()) {
88+
return ParameterizedTypeName.get(ClassName.get(resolvableType.toClass()),
89+
Arrays.stream(resolvableType.getGenerics()).map(TypeNames::resolvedTypeName).toArray(TypeName[]::new));
90+
}
91+
8792
if (!resolvableType.hasGenerics()) {
93+
8894
Class<?> resolvedType = resolvableType.toClass();
89-
if (!resolvableType.isArray()) {
90-
return TypeName.get(resolvedType);
91-
}
9295

93-
if (resolvedType.isArray()) {
96+
if (!resolvableType.isArray() || resolvedType.isArray()) {
9497
return TypeName.get(resolvedType);
9598
}
99+
96100
if (resolvableType.isArray()) {
97101
return ArrayTypeName.of(resolvedType);
98102
}
99-
return TypeName.get(resolvedType);
100-
}
101103

102-
if (resolvableType.hasResolvableGenerics()) {
103-
return ParameterizedTypeName.get(ClassName.get(resolvableType.toClass()),
104-
Arrays.stream(resolvableType.getGenerics()).map(TypeNames::resolvedTypeName).toArray(TypeName[]::new));
104+
return TypeName.get(resolvedType);
105105
}
106106

107107
return ClassName.get(resolvableType.toClass());

‎src/main/java/org/springframework/data/repository/aot/generate/AotRepositoryCreator.java‎

Lines changed: 40 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -290,6 +290,7 @@ private void contributeMethod(Method method, @Nullable MethodContributorFactory
290290
MethodContributor<? extends QueryMethod> contributor = contributorFactory.create(method);
291291

292292
if (contributor == null) {
293+
293294
if (logger.isTraceEnabled()) {
294295
logger.trace("Skipping method [%s.%s] contribution, no MethodContributor available"
295296
.formatted(repositoryInformation.getRepositoryInterface().getName(), method.getName()));
@@ -298,24 +299,55 @@ private void contributeMethod(Method method, @Nullable MethodContributorFactory
298299
return;
299300
}
300301

301-
// TODO: should we do this even before we do something with the method to protect the modules?
302-
if (ResolvableType.forMethodReturnType(method, repositoryInformation.getRepositoryInterface())
303-
.hasUnresolvableGenerics()) {
302+
if (hasUnresolvableGenerics(method)) {
304303

305304
if (logger.isTraceEnabled()) {
306-
logger.trace("Skipping method [%s.%s] contribution, unresolvable generic return"
307-
.formatted(repositoryInformation.getRepositoryInterface().getName(), method.getName()));
305+
logger.trace(
306+
"Skipping implementation method [%s.%s] contribution. Method uses generics that currently cannot be resolved."
307+
.formatted(repositoryInformation.getRepositoryInterface().getName(), method.getName()));
308308
}
309309

310310
generationMetadata.addDelegateMethod(method, contributor);
311311
return;
312312
}
313313

314-
if (contributor.contributesMethodSpec() && !repositoryInformation.isReactiveRepository()) {
315-
generationMetadata.addRepositoryMethod(method, contributor);
316-
} else {
314+
if (!contributor.contributesMethodSpec() || repositoryInformation.isReactiveRepository()) {
315+
316+
if (repositoryInformation.isReactiveRepository() && logger.isTraceEnabled()) {
317+
logger.trace(
318+
"Skipping implementation method [%s.%s] contribution. AOT repositories are not supported for reactive repositories."
319+
.formatted(repositoryInformation.getRepositoryInterface().getName(), method.getName()));
320+
}
321+
322+
if (!contributor.contributesMethodSpec() && logger.isTraceEnabled()) {
323+
logger.trace(
324+
"Skipping implementation method [%s.%s] contribution. Spring Data %s did not provide a method implementation."
325+
.formatted(repositoryInformation.getRepositoryInterface().getName(), method.getName(), moduleName));
326+
}
327+
317328
generationMetadata.addDelegateMethod(method, contributor);
329+
return;
330+
}
331+
332+
generationMetadata.addRepositoryMethod(method, contributor);
333+
}
334+
335+
private boolean hasUnresolvableGenerics(Method method) {
336+
337+
if (ResolvableType.forMethodReturnType(method, repositoryInformation.getRepositoryInterface())
338+
.hasUnresolvableGenerics()) {
339+
return true;
318340
}
341+
342+
for (int i = 0; i < method.getParameterCount(); i++) {
343+
344+
if (ResolvableType.forMethodParameter(method, i, repositoryInformation.getRepositoryInterface())
345+
.hasUnresolvableGenerics()) {
346+
return true;
347+
}
348+
}
349+
350+
return false;
319351
}
320352

321353
/**

‎src/test/java/example/BaseRepository.java‎

Lines changed: 0 additions & 28 deletions
This file was deleted.

‎src/test/java/example/UserRepository.java‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -24,7 +24,7 @@
2424
/**
2525
* @author Christoph Strobl
2626
*/
27-
public interface UserRepository extends BaseRepository<User, Long>, UserRepositoryExtension {
27+
public interface UserRepository extends CrudRepository<User, Long>, UserRepositoryExtension {
2828

2929
User findByFirstname(String firstname);
3030

‎src/test/java/org/springframework/data/javapoet/TypeNamesUnitTests.java‎

Lines changed: 89 additions & 63 deletions
Original file line numberDiff line numberDiff line change
@@ -15,8 +15,10 @@
1515
*/
1616
package org.springframework.data.javapoet;
1717

18-
import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat;
18+
import static org.assertj.core.api.AssertionsForInterfaceTypes.*;
1919

20+
import java.lang.reflect.Method;
21+
import java.util.ArrayList;
2022
import java.util.List;
2123
import java.util.Set;
2224
import java.util.stream.Stream;
@@ -25,6 +27,7 @@
2527
import org.junit.jupiter.params.ParameterizedTest;
2628
import org.junit.jupiter.params.provider.Arguments;
2729
import org.junit.jupiter.params.provider.MethodSource;
30+
2831
import org.springframework.core.MethodParameter;
2932
import org.springframework.core.ResolvableType;
3033
import org.springframework.data.geo.Distance;
@@ -37,7 +40,10 @@
3740
import org.springframework.util.ReflectionUtils;
3841

3942
/**
43+
* Tests for {@link TypeNames}.
44+
*
4045
* @author Christoph Strobl
46+
* @author Mark Paluch
4147
*/
4248
class TypeNamesUnitTests {
4349

@@ -75,84 +81,104 @@ void resolvedTypeNamesWithoutGenerics() {
7581
assertThat(TypeNames.resolvedTypeName(resolvableType)).extracting(TypeName::toString).isEqualTo("java.util.List");
7682
}
7783

78-
@Test // GH-3374
79-
void resolvedTypeNamesForMethodParameters() {
84+
static List<Method> concreteMethods() {
85+
86+
List<Method> methods = new ArrayList<>();
8087

8188
ReflectionUtils.doWithMethods(Concrete.class, method -> {
8289
if (!method.getName().contains("baseMethod")) {
8390
return;
8491
}
85-
86-
MethodParameter refiedObjectMethodParameter = new MethodParameter(method, 0).withContainingClass(Concrete.class);
87-
ResolvableType resolvedObjectParameterType = ResolvableType.forMethodParameter(refiedObjectMethodParameter);
88-
assertThat(TypeNames.typeName(resolvedObjectParameterType)).isEqualTo(TypeVariableName.get("T"));
89-
assertThat(TypeNames.resolvedTypeName(resolvedObjectParameterType)).isEqualTo(TypeName.get(MyType.class));
90-
91-
MethodParameter refiedCollectionMethodParameter = new MethodParameter(method, 1)
92-
.withContainingClass(Concrete.class);
93-
ResolvableType resolvedCollectionParameterType = ResolvableType
94-
.forMethodParameter(refiedCollectionMethodParameter);
95-
assertThat(TypeNames.typeName(resolvedCollectionParameterType))
96-
.isEqualTo(ParameterizedTypeName.get(ClassName.get(java.util.List.class), TypeVariableName.get("T")));
97-
assertThat(TypeNames.resolvedTypeName(resolvedCollectionParameterType))
98-
.isEqualTo(ParameterizedTypeName.get(java.util.List.class, MyType.class));
99-
100-
MethodParameter refiedArrayMethodParameter = new MethodParameter(method, 2).withContainingClass(Concrete.class);
101-
ResolvableType resolvedArrayParameterType = ResolvableType.forMethodParameter(refiedArrayMethodParameter);
102-
assertThat(TypeNames.typeName(resolvedArrayParameterType)).extracting(TypeName::toString).isEqualTo("T[]");
103-
assertThat(TypeNames.resolvedTypeName(resolvedArrayParameterType)).extracting(TypeName::toString)
104-
.isEqualTo("org.springframework.data.javapoet.TypeNamesUnitTests.MyType[]");
105-
106-
ResolvableType resolvedReturnType = ResolvableType.forMethodReturnType(method, Concrete.class);
107-
assertThat(TypeNames.typeName(resolvedReturnType))
108-
.isEqualTo(ParameterizedTypeName.get(ClassName.get(java.util.List.class), TypeVariableName.get("T")));
109-
assertThat(TypeNames.resolvedTypeName(resolvedReturnType))
110-
.isEqualTo(ParameterizedTypeName.get(java.util.List.class, MyType.class));
92+
methods.add(method);
11193
});
11294

95+
return methods;
96+
}
97+
98+
static List<Method> otherMethods() {
99+
100+
List<Method> methods = new ArrayList<>();
101+
113102
ReflectionUtils.doWithMethods(Concrete.class, method -> {
114103
if (!method.getName().contains("otherMethod")) {
115104
return;
116105
}
117-
118-
MethodParameter refiedObjectMethodParameter = new MethodParameter(method, 0).withContainingClass(Concrete.class);
119-
ResolvableType resolvedObjectParameterType = ResolvableType.forMethodParameter(refiedObjectMethodParameter);
120-
assertThat(TypeNames.typeName(resolvedObjectParameterType)).isEqualTo(TypeVariableName.get("RT"));
121-
assertThat(TypeNames.resolvedTypeName(resolvedObjectParameterType)).isEqualTo(TypeName.get(Object.class));
122-
123-
MethodParameter refiedCollectionMethodParameter = new MethodParameter(method, 1)
124-
.withContainingClass(Concrete.class);
125-
ResolvableType resolvedCollectionParameterType = ResolvableType
126-
.forMethodParameter(refiedCollectionMethodParameter);
127-
assertThat(TypeNames.typeName(resolvedCollectionParameterType))
128-
.isEqualTo(ParameterizedTypeName.get(ClassName.get(java.util.List.class), TypeVariableName.get("RT")));
129-
assertThat(TypeNames.resolvedTypeName(resolvedCollectionParameterType))
130-
.isEqualTo(ClassName.get(java.util.List.class));
131-
132-
MethodParameter refiedArrayMethodParameter = new MethodParameter(method, 2).withContainingClass(Concrete.class);
133-
ResolvableType resolvedArrayParameterType = ResolvableType.forMethodParameter(refiedArrayMethodParameter);
134-
assertThat(TypeNames.typeName(resolvedArrayParameterType)).extracting(TypeName::toString).isEqualTo("RT[]");
135-
assertThat(TypeNames.resolvedTypeName(resolvedArrayParameterType)).extracting(TypeName::toString)
136-
.isEqualTo("java.lang.Object[]");
137-
138-
ResolvableType resolvedReturnType = ResolvableType.forMethodReturnType(method, Concrete.class);
139-
assertThat(TypeNames.typeName(resolvedReturnType)).extracting(TypeName::toString).isEqualTo("RT");
140-
assertThat(TypeNames.resolvedTypeName(resolvedReturnType)).isEqualTo(TypeName.get(Object.class));
106+
methods.add(method);
141107
});
142108

143-
ReflectionUtils.doWithMethods(Concrete.class, method -> {
144-
if (!method.getName().contains("findByLocationNear")) {
145-
return;
146-
}
109+
return methods;
110+
}
147111

148-
ResolvableType resolvedReturnType = ResolvableType.forMethodReturnType(method, Concrete.class);
112+
@ParameterizedTest // GH-3374
113+
@MethodSource("concreteMethods")
114+
void resolvedTypeNamesForMethodParameters(Method method) {
115+
116+
MethodParameter refiedObjectMethodParameter = new MethodParameter(method, 0).withContainingClass(Concrete.class);
117+
ResolvableType resolvedObjectParameterType = ResolvableType.forMethodParameter(refiedObjectMethodParameter);
118+
assertThat(TypeNames.typeName(resolvedObjectParameterType)).isEqualTo(TypeVariableName.get("T"));
119+
assertThat(TypeNames.resolvedTypeName(resolvedObjectParameterType)).isEqualTo(TypeName.get(MyType.class));
120+
121+
MethodParameter refiedCollectionMethodParameter = new MethodParameter(method, 1)
122+
.withContainingClass(Concrete.class);
123+
ResolvableType resolvedCollectionParameterType = ResolvableType.forMethodParameter(refiedCollectionMethodParameter);
124+
assertThat(TypeNames.typeName(resolvedCollectionParameterType))
125+
.isEqualTo(ParameterizedTypeName.get(ClassName.get(java.util.List.class), TypeVariableName.get("T")));
126+
assertThat(TypeNames.resolvedTypeName(resolvedCollectionParameterType))
127+
.isEqualTo(ParameterizedTypeName.get(java.util.List.class, MyType.class));
128+
129+
MethodParameter refiedArrayMethodParameter = new MethodParameter(method, 2).withContainingClass(Concrete.class);
130+
ResolvableType resolvedArrayParameterType = ResolvableType.forMethodParameter(refiedArrayMethodParameter);
131+
assertThat(TypeNames.typeName(resolvedArrayParameterType)).extracting(TypeName::toString).isEqualTo("T[]");
132+
assertThat(TypeNames.resolvedTypeName(resolvedArrayParameterType)).extracting(TypeName::toString)
133+
.isEqualTo("org.springframework.data.javapoet.TypeNamesUnitTests.MyType[]");
134+
135+
ResolvableType resolvedReturnType = ResolvableType.forMethodReturnType(method, Concrete.class);
136+
assertThat(TypeNames.typeName(resolvedReturnType))
137+
.isEqualTo(ParameterizedTypeName.get(ClassName.get(java.util.List.class), TypeVariableName.get("T")));
138+
assertThat(TypeNames.resolvedTypeName(resolvedReturnType))
139+
.isEqualTo(ParameterizedTypeName.get(java.util.List.class, MyType.class));
149140

150-
assertThat(TypeNames.typeName(resolvedReturnType)).extracting(TypeName::toString).isEqualTo(
151-
"java.util.List<org.springframework.data.geo.GeoResult<org.springframework.data.javapoet.TypeNamesUnitTests.MyType>>");
152-
assertThat(TypeNames.resolvedTypeName(resolvedReturnType)).isEqualTo(ParameterizedTypeName
153-
.get(ClassName.get(java.util.List.class), ParameterizedTypeName.get(GeoResult.class, MyType.class)));
154-
});
141+
}
142+
143+
@ParameterizedTest // GH-3374
144+
@MethodSource("otherMethods")
145+
void resolvedTypeNamesForOtherMethodParameters(Method method) {
146+
147+
MethodParameter refiedObjectMethodParameter = new MethodParameter(method, 0).withContainingClass(Concrete.class);
148+
ResolvableType resolvedObjectParameterType = ResolvableType.forMethodParameter(refiedObjectMethodParameter);
149+
assertThat(TypeNames.typeName(resolvedObjectParameterType)).isEqualTo(TypeVariableName.get("RT"));
150+
assertThat(TypeNames.resolvedTypeName(resolvedObjectParameterType)).isEqualTo(TypeName.get(Object.class));
151+
152+
MethodParameter refiedCollectionMethodParameter = new MethodParameter(method, 1)
153+
.withContainingClass(Concrete.class);
154+
ResolvableType resolvedCollectionParameterType = ResolvableType.forMethodParameter(refiedCollectionMethodParameter);
155+
assertThat(TypeNames.typeName(resolvedCollectionParameterType))
156+
.isEqualTo(ParameterizedTypeName.get(ClassName.get(java.util.List.class), TypeVariableName.get("RT")));
157+
assertThat(TypeNames.resolvedTypeName(resolvedCollectionParameterType))
158+
.isEqualTo(ClassName.get(java.util.List.class));
159+
160+
MethodParameter refiedArrayMethodParameter = new MethodParameter(method, 2).withContainingClass(Concrete.class);
161+
ResolvableType resolvedArrayParameterType = ResolvableType.forMethodParameter(refiedArrayMethodParameter);
162+
assertThat(TypeNames.typeName(resolvedArrayParameterType)).extracting(TypeName::toString).isEqualTo("RT[]");
163+
assertThat(TypeNames.resolvedTypeName(resolvedArrayParameterType)).extracting(TypeName::toString)
164+
.isEqualTo("java.lang.Object[]");
165+
166+
ResolvableType resolvedReturnType = ResolvableType.forMethodReturnType(method, Concrete.class);
167+
assertThat(TypeNames.typeName(resolvedReturnType)).extracting(TypeName::toString).isEqualTo("RT");
168+
assertThat(TypeNames.resolvedTypeName(resolvedReturnType)).isEqualTo(TypeName.get(Object.class));
169+
}
170+
171+
@Test // GH-3374
172+
void resolvesTypeNamesForMethodParameters() throws NoSuchMethodException {
173+
174+
Method method = Concrete.class.getDeclaredMethod("findByLocationNear", Point.class, Distance.class);
175+
176+
ResolvableType resolvedReturnType = ResolvableType.forMethodReturnType(method, Concrete.class);
155177

178+
assertThat(TypeNames.typeName(resolvedReturnType)).extracting(TypeName::toString).isEqualTo(
179+
"java.util.List<org.springframework.data.geo.GeoResult<org.springframework.data.javapoet.TypeNamesUnitTests.MyType>>");
180+
assertThat(TypeNames.resolvedTypeName(resolvedReturnType)).isEqualTo(ParameterizedTypeName
181+
.get(ClassName.get(java.util.List.class), ParameterizedTypeName.get(GeoResult.class, MyType.class)));
156182
}
157183

158184
interface GenericBase<T> {

0 commit comments

Comments
 (0)