Retrieve the no-argument constructor (#1690)

* Retrieve the no-argument constructor using a method called getParameterlessPublicConstructor

This fixes issue #1689 where the no-argument constructor is not always the one you get

* Update JavaObjectTransformer.java

* Filter for public only constructors

Add a test to cover the scenarios where the no-arg constructor is public, protected and private

Improve the code slightly that finds tries to find an alternative constructor. This could be improved further to find one that matches the schema. Currently it just finds the first public constructor in the array returned by clazz.getConstructors()

---------

Co-authored-by: Matthew Tatum <[email protected]>
Co-authored-by: Rick M <[email protected]>

Author: 3 people

src/main/java/net/datafaker/transformations/JavaObjectTransformer.java

@@ -5,6 +5,7 @@
 import java.io.OutputStream;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Modifier;
 import java.lang.reflect.RecordComponent;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -51,14 +52,22 @@ public Object apply(Object input, Schema<Object, ?> schema) {
 
             result = getObject(schema, result, recordConstructor);
         } else if (!hasParameterlessPublicConstructor(clazz)) {
-            Constructor<?> primaryConstructor = CLASS2CONSTRUCTOR.computeIfAbsent(clazz, c -> c.getDeclaredConstructors()[0]);
+            Constructor<?> primaryConstructor = CLASS2CONSTRUCTOR.computeIfAbsent(clazz, c -> getAnyPublicConstructor(c).orElse(null));
+
+            if (primaryConstructor == null) {
+                throw new RuntimeException("Failed to initialize class " + clazz.getName() + ", no appropriate public constructor found");
+            }
 
             result = getObject(schema, result, primaryConstructor);
         } else {
             if (result == null) {
                 try {
-                    Constructor<?> primaryConstructor = CLASS2CONSTRUCTOR.computeIfAbsent(clazz, c -> c.getDeclaredConstructors()[0]);
-                    result = primaryConstructor.newInstance();
+                    Constructor<?> primaryConstructor = CLASS2CONSTRUCTOR.computeIfAbsent(clazz, c -> getParameterlessPublicConstructor(c).orElse(null));
+                    if (primaryConstructor != null) {
+                        result = primaryConstructor.newInstance();
+                    } else {
+                        throw new RuntimeException("Failed to locate a parameterless public constructor for class " + clazz.getName());
+                    }
                 } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
                     throw new RuntimeException(e);
                 }
@@ -167,11 +176,19 @@ private Object getObject(Schema<Object, ?> schema, Object result, Constructor<?>
     }
 
     private boolean hasParameterlessPublicConstructor(Class<?> clazz) {
-        for (Constructor<?> constructor : clazz.getConstructors()) {
-            if (constructor.getParameterCount() == 0) {
-                return true;
-            }
-        }
-        return false;
+        return getParameterlessPublicConstructor(clazz).isPresent();
+    }
+
+    private Optional<Constructor<?>> getParameterlessPublicConstructor(Class<?> clazz) {
+        return Arrays.stream(clazz.getConstructors())
+            .filter(constructor -> constructor.getParameterCount() == 0)
+            .filter(constructor -> Modifier.isPublic(constructor.getModifiers()))
+            .findFirst();
+    }
+
+    private Optional<Constructor<?>> getAnyPublicConstructor(Class<?> clazz) {
+        return Arrays.stream(clazz.getConstructors())
+            .filter(constructor -> Modifier.isPublic(constructor.getModifiers()))
+            .findFirst();
     }
 }

src/test/java/net/datafaker/transformations/JavaObjectTransformerConstructorTest.java

@@ -0,0 +1,100 @@
+package net.datafaker.transformations;
+
+import net.datafaker.Faker;
+import org.junit.jupiter.api.Test;
+
+import static net.datafaker.transformations.Field.field;
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class JavaObjectTransformerConstructorTest {
+
+    public static class Person {
+
+        private int id;
+
+        public Person() {
+        }
+
+        public Person(int id) {
+            throw new RuntimeException("This should not be called");
+        }
+    }
+
+    public static class ProtectedPerson {
+
+        private int id;
+
+        protected ProtectedPerson() {
+            throw new RuntimeException("This should not be called");
+        }
+
+        public ProtectedPerson(int id) {
+            this.id = id;
+        }
+    }
+
+    public static class PrivatePerson {
+
+        private int id;
+
+        private PrivatePerson() {
+            throw new RuntimeException("This should not be called");
+        }
+
+        public PrivatePerson(int id) {
+            this.id = id;
+        }
+    }
+
+    private final Faker faker = new Faker();
+
+    @Test
+    void javaNoArgConstructorTest() {
+        JavaObjectTransformer jTransformer = (new JavaObjectTransformer()).from(Person.class);
+        Schema<Object, ?> schema = Schema.of(
+            field("id", () -> faker.number().positive())
+        );
+
+        jTransformer
+            .generate(schema, 10)
+            .stream()
+            .map(object -> (Person) object)
+            .forEach(person -> {
+                assertThat(person.id).isNotNull();
+            });
+
+    }
+
+    @Test
+    void javaNoArgConstructorProtectedTest() {
+        JavaObjectTransformer jTransformer = (new JavaObjectTransformer()).from(ProtectedPerson.class);
+        Schema<Object, ?> schema = Schema.of(
+            field("id", () -> faker.number().positive())
+        );
+
+        jTransformer
+            .generate(schema, 10)
+            .stream()
+            .map(object -> (ProtectedPerson) object)
+            .forEach(person -> {
+                assertThat(person.id).isNotNull();
+            });
+    }
+
+    @Test
+    void javaNoArgConstructorPrivateTest() {
+        JavaObjectTransformer jTransformer = (new JavaObjectTransformer()).from(PrivatePerson.class);
+        Schema<Object, ?> schema = Schema.of(
+            field("id", () -> faker.number().positive())
+        );
+
+        jTransformer
+            .generate(schema, 10)
+            .stream()
+            .map(object -> (PrivatePerson) object)
+            .forEach(person -> {
+                assertThat(person.id).isNotNull();
+            });
+
+    }
+}