fix: pick constructor matching customization

When a field is customized, using a random constructor might pick one
that does not contain the customized field therefore ignoring the
customization. Instead, we select all constructors that contain the
customized fields and pick a random one out of those. If no constructor
with the customized fields is found, an exception is thrown. This will
only work for records since traditional classes do not store proper
constructor argument names (instead use arg0, arg1, etc.) and cannot
match those to customized field-names.

Author: Nylle

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

@@ -14,6 +14,7 @@
 import java.lang.reflect.Parameter;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Deque;
 import java.util.HashMap;
@@ -32,9 +33,12 @@
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.LinkedTransferQueue;
 import java.util.concurrent.TransferQueue;
+import java.util.stream.Stream;
 
 import static java.lang.String.format;
 import static java.util.Arrays.stream;
+import static java.util.stream.Collectors.joining;
+import static java.util.stream.Collectors.toList;
 
 public class InstanceFactory {
 
@@ -58,9 +62,8 @@ public InstanceFactory(SpecimenFactory specimenFactory) {
     }
 
     public <T> T construct(SpecimenType<T> type, CustomizationContext customizationContext) {
-        return random.shuffled(type.getDeclaredConstructors())
+        return random.shuffled(findValidConstructors(type, customizationContext))
                 .stream()
-                .filter(x -> Modifier.isPublic(x.getModifiers()))
                 .findFirst()
                 .map(x -> construct(type, x, customizationContext))
                 .orElseGet(() -> manufacture(type, customizationContext, new SpecimenException("No public constructor found")));
@@ -223,4 +226,42 @@ private <G, T extends Collection<G>> T createCollectionFromConcreteType(final Sp
             throw new SpecimenException("Unable to create collection of type " + type.getName(), e);
         }
     }
+
+    private static <T> List<Constructor<T>> findValidConstructors(SpecimenType<T> type, CustomizationContext customizationContext) {
+        var publicConstructors = type.getDeclaredConstructors().stream().filter(x -> Modifier.isPublic(x.getModifiers())).collect(toList());
+
+        if (publicConstructors.isEmpty()) {
+            return publicConstructors;
+        }
+
+        if (customizationContext.getCustomFields().isEmpty() && customizationContext.getIgnoredFields().isEmpty()) {
+            return publicConstructors;
+        }
+
+        var candidates = publicConstructors.stream()
+                .map(constructor -> {
+                    var parameterNames = stream(constructor.getParameters()).map(x -> x.getName()).collect(toList());
+                    var missingParameters = customizationContext.findAllCustomizedFieldNames()
+                            .map(entry -> entry.replaceAll("\\..+", ""))
+                            .filter(entry -> !parameterNames.contains(entry))
+                            .collect(toList());
+                    return Map.<Constructor<T>, List<String>>entry(constructor, missingParameters);
+                })
+                .collect(toList());
+
+
+        var result = candidates.stream().filter(x -> x.getValue().isEmpty()).map(x -> x.getKey()).collect(toList());
+
+        if (result.isEmpty()) {
+            throw new SpecimenException(Stream.concat(
+                            Stream.of("Cannot customize fields because no suitable constructor was found. Candidates are:"),
+                            candidates.stream().map(x -> String.format("  %s(%s) (Missing fields: %s)",
+                                    x.getKey().getName(),
+                                    Arrays.stream(x.getKey().getParameters()).map(p -> p.getName()).collect(joining(",")),
+                                    new HashSet<>(x.getValue()))))
+                    .collect(joining(format("%n"))));
+        }
+
+        return result;
+    }
 }

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

@@ -16,6 +16,7 @@
 import com.github.nylle.javafixture.testobjects.withconstructor.TestObjectWithConstructedField;
 import com.github.nylle.javafixture.testobjects.withconstructor.TestObjectWithGenericConstructor;
 import com.github.nylle.javafixture.testobjects.withconstructor.TestObjectWithPrivateConstructor;
+import com.github.nylle.javafixture.testobjects.withconstructor.TestObjectWithTwoConstructors;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
@@ -49,12 +50,61 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 
+/*
+  We use "arg0" as constructor argument-names, because .class files do not store formal parameter names by default.
+  For records (Java 17+) proper names should work.
+ */
 class InstanceFactoryTest {
 
     @Nested
     @DisplayName("when using constructor")
     class UsingConstructor {
 
+        @Test
+        @DisplayName("throws exception for invalid customization")
+        void throwsExceptionForInvalidCustomization() {
+            var sut = new InstanceFactory(new SpecimenFactory(new Context(Configuration.configure())));
+
+            var type = new SpecimenType<TestObjectWithTwoConstructors>(){};
+            var context = new CustomizationContext(List.of("arg0.nested", "missingExclusion"), Map.of(
+                    "arg1.nested", new Object(),
+                    "missingCustomization", new Object()), false);
+
+            assertThatExceptionOfType(SpecimenException.class)
+                    .isThrownBy(() -> sut.construct(type, context))
+                    .withMessageContaining("Cannot customize fields because no suitable constructor was found. Candidates are:\n")
+                    .withMessageContaining("  com.github.nylle.javafixture.testobjects.withconstructor.TestObjectWithTwoConstructors(arg0,arg1) (Missing fields: [missingCustomization, missingExclusion])\n")
+                    .withMessageContaining("  com.github.nylle.javafixture.testobjects.withconstructor.TestObjectWithTwoConstructors(arg0) (Missing fields: [missingCustomization, arg1, missingExclusion])");
+        }
+
+        @Test
+        @DisplayName("instance is created from suitable constructor for customized field")
+        void canCreateInstanceFromSuitableConstructorForCustomizedField() {
+            var sut = new InstanceFactory(new SpecimenFactory(new Context(Configuration.configure())));
+
+            var context = new CustomizationContext(List.of(), Map.of("arg1", "other"), false);
+
+            TestObjectWithTwoConstructors result = sut.construct(fromClass(TestObjectWithTwoConstructors.class), context);
+
+            assertThat(result).isInstanceOf(TestObjectWithTwoConstructors.class);
+            assertThat(result.getValue()).isInstanceOf(String.class).isNotNull().isNotEqualTo("other");
+            assertThat(result.getOther()).isEqualTo("other");
+        }
+
+        @Test
+        @DisplayName("instance is created from suitable constructor for omitted field")
+        void canCreateInstanceFromSuitableConstructorForOmittedField() {
+            var sut = new InstanceFactory(new SpecimenFactory(new Context(Configuration.configure())));
+
+            var context = new CustomizationContext(List.of("arg1"), Map.of(), false);
+
+            TestObjectWithTwoConstructors result = sut.construct(fromClass(TestObjectWithTwoConstructors.class), context);
+
+            assertThat(result).isInstanceOf(TestObjectWithTwoConstructors.class);
+            assertThat(result.getValue()).isInstanceOf(String.class).isNotNull();
+            assertThat(result.getOther()).isNull();
+        }
+
         @Test
         @DisplayName("instance is created from random constructor")
         void canCreateInstanceFromConstructor() {
@@ -163,7 +213,6 @@ void passExceptionToFallbackWhenConstructorThrows() {
         void argumentsCanBeCustomized() {
             var sut = new InstanceFactory(new SpecimenFactory(new Context(Configuration.configure())));
 
-            // use arg0, because .class files do not store formal parameter names by default
             var customizationContext = new CustomizationContext(List.of(), Map.of("arg0", "customized"), true);
             TestObject result = sut.construct(fromClass(TestObject.class), customizationContext);
 

src/test/java/com/github/nylle/javafixture/testobjects/withconstructor/TestObjectWithTwoConstructors.java

@@ -0,0 +1,24 @@
+package com.github.nylle.javafixture.testobjects.withconstructor;
+
+public class TestObjectWithTwoConstructors {
+    private String value;
+    private String other;
+
+    public TestObjectWithTwoConstructors(String value, String other) {
+        this.value = value;
+        this.other = other;
+    }
+
+    public TestObjectWithTwoConstructors(String value) {
+        this.value = value;
+        this.other = "default";
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public String getOther() {
+        return other;
+    }
+}