feat: construct fixture without class as param

It makes little sense to call a factory method with an object of the same class
that we want to fixture, therefore creating a (potentially endless) recursion.

Refs: JF-77

Author: akutschera

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

@@ -52,6 +52,7 @@ public InstanceFactory(SpecimenFactory specimenFactory) {
     public <T> T construct(final SpecimenType<T> type) {
         return construct(type, new CustomizationContext(true));
     }
+
     public <T> T construct(final SpecimenType<T> type, CustomizationContext customizationContext) {
         var constructors = type.getDeclaredConstructors()
                 .stream()
@@ -70,14 +71,20 @@ public <T> T manufacture(final SpecimenType<T> type, CustomizationContext custom
         Collections.shuffle(factoryMethods);
         var results = factoryMethods
                 .stream()
-                .filter(x -> Modifier.isPublic(x.getModifiers()))
+                .filter(method -> Modifier.isPublic(method.getModifiers()))
+                .filter(method -> !hasSpecimenTypeAsParameter(method, type))
                 .map(x -> manufactureOrNull(x, type, customizationContext))
                 .filter(x -> x != null)
                 .findFirst();
 
         return results.orElseThrow(() -> new SpecimenException(format("Cannot manufacture %s", type.asClass())));
     }
 
+    private <T> boolean hasSpecimenTypeAsParameter(Method m, SpecimenType<T> type) {
+        return stream(m.getGenericParameterTypes())
+                .anyMatch(t -> t.getTypeName().equals(type.asClass().getName()));
+    }
+
     public <T> T instantiate(final SpecimenType<T> type) {
         try {
             return type.asClass().getDeclaredConstructor().newInstance();

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

@@ -3,6 +3,8 @@
 import com.github.nylle.javafixture.testobjects.factorymethod.ConstructorExceptionAndFactoryMethod;
 import com.github.nylle.javafixture.testobjects.factorymethod.FactoryMethodWithArgument;
 import com.github.nylle.javafixture.testobjects.factorymethod.FactoryMethodWithGenericArgument;
+import com.github.nylle.javafixture.testobjects.factorymethod.FactoryMethodWithItselfAsArgument;
+import com.github.nylle.javafixture.testobjects.factorymethod.FactoryMethodWithOnlyItselfAsArgument;
 import com.github.nylle.javafixture.testobjects.factorymethod.FactoryMethodWithoutArgument;
 import com.github.nylle.javafixture.testobjects.factorymethod.GenericClassWithFactoryMethodWithoutArgument;
 import com.github.nylle.javafixture.testobjects.factorymethod.TestObjectWithNonPublicFactoryMethods;
@@ -55,6 +57,7 @@ void canCreateInstanceFromConstructor() {
             assertThat(result.getValue()).isInstanceOf(String.class);
             assertThat(result.getInteger()).isInstanceOf(Optional.class);
         }
+
         @Test
         @DisplayName("fields not set by constructor are null")
         void fieldsNotSetByConstructorAreNull() {
@@ -66,6 +69,7 @@ void fieldsNotSetByConstructorAreNull() {
             assertThat(result).isInstanceOf(TestObjectWithGenericConstructor.class);
             assertThat(result.getPrivateField()).isNull();
         }
+
         @Test
         @DisplayName("using constructor is used for all instances")
         void usingConstructorIsRecursive() {
@@ -146,6 +150,26 @@ void factoryMethodWithArgument() {
             assertThat(result.getValue()).isNotNull();
         }
 
+        @Test
+        @DisplayName("methods with class itself as argument should be filtered out")
+        void shouldFilter() {
+            var sut = new InstanceFactory(new SpecimenFactory(new Context(Configuration.configure())));
+
+            FactoryMethodWithItselfAsArgument result = sut.manufacture(fromClass(FactoryMethodWithItselfAsArgument.class), CustomizationContext.noContext());
+
+            assertThat(result.getValue()).isNull();
+        }
+
+        @Test
+        @DisplayName("if only methods with class itself are available, we should fail")
+        void shouldFailWithoutValidFactoryMethod() {
+            var sut = new InstanceFactory(new SpecimenFactory(new Context(Configuration.configure())));
+
+            assertThatExceptionOfType(SpecimenException.class)
+                    .isThrownBy(() -> sut.manufacture(fromClass(FactoryMethodWithOnlyItselfAsArgument.class), CustomizationContext.noContext()));
+
+        }
+
         @Test
         @DisplayName("optional can be created (and may be empty)")
         void createOptional() {

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

@@ -0,0 +1,20 @@
+package com.github.nylle.javafixture.testobjects.factorymethod;
+
+public class FactoryMethodWithItselfAsArgument {
+
+    private String value;
+
+    private FactoryMethodWithItselfAsArgument(String value) {
+        this.value = value;
+    }
+    public static FactoryMethodWithItselfAsArgument factoryMethod() {
+        return new FactoryMethodWithItselfAsArgument(null);
+    }
+    public static FactoryMethodWithItselfAsArgument factoryMethodWithItselfAsArgument(FactoryMethodWithItselfAsArgument arg) {
+        return new FactoryMethodWithItselfAsArgument("this factory method should have been filtered out!");
+    }
+
+    public String getValue() {
+        return value;
+    }
+}

src/test/java/com/github/nylle/javafixture/testobjects/factorymethod/FactoryMethodWithItselfAsArgument.java

@@ -0,0 +1,10 @@
+package com.github.nylle.javafixture.testobjects.factorymethod;
+
+public class FactoryMethodWithOnlyItselfAsArgument {
+
+    private FactoryMethodWithOnlyItselfAsArgument() {}
+
+    public static FactoryMethodWithOnlyItselfAsArgument factoryMethodWithItselfAsArgument(FactoryMethodWithOnlyItselfAsArgument arg) {
+        return new FactoryMethodWithOnlyItselfAsArgument();
+    }
+}