refactor: inline method and adjust code style

In addition, tests for the new `Reflector` method were added.

Author: Nylle

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

@@ -61,34 +61,19 @@ public Stream<Field> getDeclaredFields() {
         return getDeclaredFields(clazz);
     }
 
-    private Stream<Field> getDeclaredFields(Class<?> type) {
-        return Stream.concat(
-                Stream.of(type.getDeclaredFields()).filter(field -> !Modifier.isStatic(field.getModifiers())),
-                Optional.ofNullable(type.getSuperclass())
-                        .map(superclass -> getDeclaredFields(superclass))
-                        .orElse(Stream.of()));
-    }
-
     public Annotation[] getFieldAnnotations(Field field) {
         try {
-            return getFieldAnnotations(field, clazz).toArray(Annotation[]::new);
+            return Stream.concat(Arrays.stream(Introspector.getBeanInfo(clazz).getPropertyDescriptors())
+                    .filter(property -> !Modifier.isStatic(field.getModifiers()))
+                    .filter(property -> property.getName().equals(field.getName()))
+                    .flatMap(propertyDescriptor -> Stream.of(propertyDescriptor.getReadMethod(), propertyDescriptor.getWriteMethod())
+                            .filter(x -> Objects.nonNull(x))
+                            .flatMap(method -> Stream.of(method.getAnnotations()))), Arrays.stream(field.getAnnotations())).toArray(x -> new Annotation[x]);
         } 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);
@@ -99,4 +84,12 @@ public void setField(Field field, Object value) {
             throw new SpecimenException(format("Unable to set field %s on object of type %s", field.getName(), clazz.getName()), e);
         }
     }
+
+    private Stream<Field> getDeclaredFields(Class<?> type) {
+        return Stream.concat(
+                Stream.of(type.getDeclaredFields()).filter(field -> !Modifier.isStatic(field.getModifiers())),
+                Optional.ofNullable(type.getSuperclass())
+                        .map(superclass -> getDeclaredFields(superclass))
+                        .orElse(Stream.of()));
+    }
 }

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

@@ -61,16 +61,14 @@ 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), reflector.getFieldAnnotations(field)))));
+                                            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/ReflectorTest.java

@@ -1,20 +1,30 @@
 package com.github.nylle.javafixture;
 
+import com.github.nylle.javafixture.testobjects.TestObjectWithJakartaValidationAnnotations;
+import com.github.nylle.javafixture.testobjects.TestObjectWithJakartaValidationAnnotationsOnMethod;
 import com.github.nylle.javafixture.testobjects.inheritance.GenericChild;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
 
+import jakarta.validation.constraints.Size;
+
+import java.beans.IntrospectionException;
 import java.lang.reflect.Field;
 import java.lang.reflect.InaccessibleObjectException;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatCode;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 class ReflectorTest {
 
@@ -120,4 +130,46 @@ void catchInaccessibleObjectException() {
         }
     }
 
+    @Nested
+    class GetFieldAnnotations {
+
+        @Test
+        void returnsSizeAnnotationOnPrivateField() {
+            var sut = new Reflector<>(new TestObjectWithJakartaValidationAnnotations());
+
+            var field = sut.getDeclaredFields().filter(x -> x.getName().equals("withMinMaxAnnotation")).findFirst().get();
+
+            var actual = Arrays.stream(sut.getFieldAnnotations(field)).collect(Collectors.toList());
+
+            assertThat(actual).hasSize(1);
+            assertThat(actual.get(0).annotationType()).isEqualTo(Size.class);
+        }
+
+        @Test
+        void returnsSizeAnnotationOnGetter() {
+            var sut = new Reflector<>(new TestObjectWithJakartaValidationAnnotationsOnMethod());
+
+            var field = sut.getDeclaredFields().filter(x -> x.getName().equals("withMinMaxAnnotation")).findFirst().get();
+
+            var actual = Arrays.stream(sut.getFieldAnnotations(field)).collect(Collectors.toList());
+
+            assertThat(actual).hasSize(1);
+            assertThat(actual.get(0).annotationType()).isEqualTo(Size.class);
+        }
+
+        @Test
+        void returnsSizeAnnotationOnFieldIfGetterThrowsIntrospectionException() {
+            var sut = new Reflector<>(new TestObjectWithJakartaValidationAnnotations());
+            var expected = sut.getDeclaredFields().filter(x -> x.getName().equals("withMinMaxAnnotation")).findFirst().get().getAnnotations();
+
+            var throwingField = mock(Field.class);
+            when(throwingField.getModifiers()).thenAnswer(x -> { throw new IntrospectionException("expected for test"); });
+            when(throwingField.getAnnotations()).thenReturn(expected);
+
+            var actual = Arrays.stream(sut.getFieldAnnotations(throwingField)).collect(Collectors.toList());
+
+            assertThat(actual).hasSize(1);
+            assertThat(actual.get(0).annotationType()).isEqualTo(Size.class);
+        }
+    }
 }