Collect annotations also on getter and setter methods

Author: dpezzoli-partec

src/main/java/com/github/nylle/javafixture/Reflector.java

@@ -1,8 +1,13 @@
 package com.github.nylle.javafixture;
 
+import java.beans.IntrospectionException;
+import java.beans.Introspector;
+import java.lang.annotation.Annotation;
 import java.lang.reflect.Field;
 import java.lang.reflect.InaccessibleObjectException;
 import java.lang.reflect.Modifier;
+import java.util.Arrays;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.stream.Stream;
 
@@ -64,6 +69,26 @@ private Stream<Field> getDeclaredFields(Class<?> type) {
                         .orElse(Stream.of()));
     }
 
+    public Annotation[] getFieldAnnotations(Field field) {
+        try {
+            return getFieldAnnotations(field, clazz).toArray(Annotation[]::new);
+        } catch (IntrospectionException e) {
+            return field.getAnnotations();
+        }
+    }
+
+    public Stream<Annotation> getFieldAnnotations(Field field, Class<?> type) throws IntrospectionException {
+
+        return Stream.concat(Arrays.stream(Introspector.getBeanInfo(type).getPropertyDescriptors())
+                .filter(property -> !Modifier.isStatic(field.getModifiers()))
+                .filter(property -> property.getName().equals(field.getName()))
+                .flatMap(propertyDescriptor -> Stream.of(propertyDescriptor.getReadMethod(), propertyDescriptor.getWriteMethod())
+                        .filter(Objects::nonNull)
+                        .flatMap(method -> Stream.of(method.getAnnotations()))
+                ), Arrays.stream(field.getAnnotations()));
+    }
+
+
     public void setField(Field field, Object value) {
         try {
             field.setAccessible(true);

src/main/java/com/github/nylle/javafixture/specimen/ObjectSpecimen.java

@@ -61,14 +61,16 @@ private T populate(CustomizationContext customizationContext) {
         var result = context.cached(type, instanceFactory.instantiate(type));
         var reflector = new Reflector<>(result).validateCustomization(customizationContext, type);
         try {
+
             reflector.getDeclaredFields()
                     .filter(field -> !customizationContext.getIgnoredFields().contains(field.getName()))
                     .forEach(field -> reflector.setField(field,
                             customizationContext.getCustomFields().getOrDefault(
                                     field.getName(),
                                     Map.<String, ISpecimen<?>>of().getOrDefault(
                                             field.getGenericType().getTypeName(),
-                                            specimenFactory.build(SpecimenType.fromClass(field.getGenericType()))).create(new CustomizationContext(List.of(), Map.of(), false), field.getAnnotations()))));
+                                            specimenFactory.build(SpecimenType.fromClass(field.getGenericType())))
+                                            .create(new CustomizationContext(List.of(), Map.of(), false), reflector.getFieldAnnotations(field)))));
         } catch (SpecimenException ex) {
             return context.overwrite(type, instanceFactory.construct(type, customizationContext));
         }

src/test/java/com/github/nylle/javafixture/FixtureWithValidationTest.java

@@ -2,6 +2,7 @@
 
 import com.github.nylle.javafixture.annotations.fixture.TestWithFixture;
 import com.github.nylle.javafixture.testobjects.TestObjectWithJakartaValidationAnnotations;
+import com.github.nylle.javafixture.testobjects.TestObjectWithJakartaValidationAnnotationsOnMethod;
 import com.github.nylle.javafixture.testobjects.TestObjectWithJavaxValidationAnnotations;
 import org.junit.jupiter.api.Test;
 
@@ -29,6 +30,18 @@ void jakartaSizeAnnotationIsSupported() {
         assertThat(sut.getWithMaxAnnotation().length()).isLessThanOrEqualTo(100);
         assertThat(sut.getWithMinMaxAnnotation().length()).isBetween(3, 6);
         assertThat(sut.getWithColumnLengthAnnotation().length()).isBetween(0, 5);
+        assertThat(sut.getWithColumnLengthAnnotationAndMaxAnnotation().length()).isBetween(0, 5);
+    }
+
+    @Test
+    void jakartaSizeAnnotationOnMethodIsSupported() {
+        var sut = new Fixture().create(TestObjectWithJakartaValidationAnnotationsOnMethod.class);
+
+        assertThat(sut.getWithMinAnnotation().length()).isGreaterThanOrEqualTo(5);
+        assertThat(sut.getWithMaxAnnotation().length()).isLessThanOrEqualTo(100);
+        assertThat(sut.getWithMinMaxAnnotation().length()).isBetween(3, 6);
+        assertThat(sut.getWithColumnLengthAnnotation().length()).isBetween(0, 5);
+        assertThat(sut.getWithMaxAnnotationAndColumnLengthAnnotation().length()).isBetween(0, 5);
     }
 
     @Test

src/test/java/com/github/nylle/javafixture/testobjects/TestObjectWithJakartaValidationAnnotationsOnMethod.java

@@ -0,0 +1,44 @@
+package com.github.nylle.javafixture.testobjects;
+
+
+import jakarta.persistence.Column;
+import jakarta.validation.constraints.Size;
+
+public class TestObjectWithJakartaValidationAnnotationsOnMethod {
+
+    private String withMinMaxAnnotation;
+
+
+    private String withMinAnnotation;
+
+
+    private String withMaxAnnotation;
+
+
+    private String withColumnLengthAnnotation;
+
+
+    private String withMaxAnnotationAndColumnLengthAnnotation;
+
+    @Size(min = 3, max = 6)
+    public String getWithMinMaxAnnotation() {
+        return withMinMaxAnnotation;
+    }
+    @Size(min = 5)
+    public String getWithMinAnnotation() {
+        return withMinAnnotation;
+    }
+    @Size(max = 100)
+    public String getWithMaxAnnotation() {
+        return withMaxAnnotation;
+    }
+    @Column(length = 5)
+    public String getWithColumnLengthAnnotation() {
+        return withColumnLengthAnnotation;
+    }
+    @Size(max = 100)
+    @Column(length = 5)
+    public String getWithMaxAnnotationAndColumnLengthAnnotation() {
+        return withMaxAnnotationAndColumnLengthAnnotation;
+    }
+}