refactor: clean up code

Author: Nylle

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

@@ -14,10 +14,12 @@
 import com.github.nylle.javafixture.specimen.TimeSpecimen;
 
 import io.github.classgraph.ClassGraph;
+import io.github.classgraph.ClassInfo;
 import io.github.classgraph.ScanResult;
 
 import java.lang.reflect.Type;
 import java.util.Random;
+import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
 import static java.util.stream.Collectors.toMap;
@@ -93,37 +95,44 @@ public <T> ISpecimen<T> build(final SpecimenType<T> type) {
 
     private <T> ISpecimen<T> implementationOrProxy(final SpecimenType<T> interfaceType) {
         try (ScanResult scanResult = new ClassGraph().enableAllInfo().scan()) {
-            var implementingClasses = scanResult.getClassesImplementing(interfaceType.asClass());
+            var implementingClasses = scanResult.getClassesImplementing(interfaceType.asClass()).stream()
+                    .filter(x -> interfaceType.isParameterized() || isNotParametrized(x))
+                    .collect(Collectors.toList());
+
             if (implementingClasses.isEmpty()) {
                 return new InterfaceSpecimen<>(interfaceType, context, this);
             }
 
             var implementingClass = implementingClasses.get(new Random().nextInt(implementingClasses.size()));
-            if (implementingClass.getTypeSignature() == null || implementingClass.getTypeSignature().getTypeParameters().isEmpty()) {
+            if (isNotParametrized(implementingClass)) {
                 return new ObjectSpecimen<>(SpecimenType.fromClass(implementingClass.loadClass()), context, this);
             }
 
-            if (!interfaceType.isParameterized()) {
-                return new InterfaceSpecimen<>(interfaceType, context, this);
-            }
-
-            var typeParameters = IntStream.range(0, interfaceType.getGenericTypeArguments().length)
-                    .boxed()
-                    .collect(toMap(
-                            i -> interfaceType.getTypeParameterName(i),
-                            i -> SpecimenType.fromClass(interfaceType.getGenericTypeArgument(i))));
-
-            var actualTypeArguments = implementingClass.getTypeSignature().getTypeParameters().stream()
-                    .map(x -> typeParameters.get(x.getName()).asClass())
-                    .toArray(size -> new Type[size]);
-
             return new GenericSpecimen<>(
-                    SpecimenType.fromRawType(implementingClass.loadClass(), actualTypeArguments),
+                    SpecimenType.fromRawType(implementingClass.loadClass(), resolveTypeArguments(interfaceType, implementingClass)),
                     context,
                     this);
         } catch (Exception ex) {
             return new InterfaceSpecimen<>(interfaceType, context, this);
         }
     }
+
+    private static boolean isNotParametrized(ClassInfo classInfo) {
+        return classInfo.getTypeSignature() == null || classInfo.getTypeSignature().getTypeParameters().isEmpty();
+    }
+
+    private static <T> Type[] resolveTypeArguments(SpecimenType<T> genericType, ClassInfo implementingClass) {
+        // throws NPE if implementing class has more type arguments than interface
+        // this was not intended, but luckily causes a fallback to proxy, because we wouldn't be able to resolve the additional type anyway
+        var typeParameters = IntStream.range(0, genericType.getGenericTypeArguments().length)
+                .boxed()
+                .collect(toMap(
+                        i -> genericType.getTypeParameterName(i),
+                        i -> SpecimenType.fromClass(genericType.getGenericTypeArgument(i))));
+
+        return implementingClass.getTypeSignature().getTypeParameters().stream()
+                .map(x -> typeParameters.get(x.getName()).asClass())
+                .toArray(size -> new Type[size]);
+    }
 }
 

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

@@ -20,6 +20,7 @@
 import com.github.nylle.javafixture.testobjects.interfaces.GenericInterfaceTUWithGenericImplementationT;
 import com.github.nylle.javafixture.testobjects.interfaces.GenericInterfaceTUWithGenericImplementationTU;
 import com.github.nylle.javafixture.testobjects.interfaces.GenericInterfaceTUWithGenericImplementationU;
+import com.github.nylle.javafixture.testobjects.interfaces.GenericInterfaceTWithGenericImplementationTU;
 import com.github.nylle.javafixture.testobjects.interfaces.GenericInterfaceWithImplementation;
 import com.github.nylle.javafixture.testobjects.interfaces.InterfaceWithGenericImplementation;
 import com.github.nylle.javafixture.testobjects.interfaces.InterfaceWithImplementation;
@@ -111,17 +112,24 @@ class CreatesInterfaceSpecimen {
 
             @Test
             @DisplayName("no implementations found")
-            void createsInterfaceSpecimenIfInterfaceHasNoImplementations() {
+            void ifInterfaceHasNoImplementations() {
                 assertThat(new SpecimenFactory(context).build(SpecimenType.fromClass(InterfaceWithoutImplementation.class)))
                         .isExactlyInstanceOf(InterfaceSpecimen.class);
             }
 
             @Test
             @DisplayName("implementation is generic and interface is not")
-            void createsInterfaceSpecimenIfImplementationIsGenericAndInterfaceIsNot() {
+            void ifImplementationIsGenericAndInterfaceIsNot() {
                 assertThat(new SpecimenFactory(context).build(SpecimenType.fromClass(InterfaceWithGenericImplementation.class)))
                         .isExactlyInstanceOf(InterfaceSpecimen.class);
             }
+
+            @Test
+            @DisplayName("implementation has more type arguments than interface")
+            void ifImplementationHasMoreTypeArgumentsThanInterface() {
+                assertThat(new SpecimenFactory(context).build(new SpecimenType<GenericInterfaceTWithGenericImplementationTU<String>>() {}))
+                        .isExactlyInstanceOf(InterfaceSpecimen.class);
+            }
         }
 
         @Nested
@@ -130,14 +138,14 @@ class CreatesObjectSpecimen {
 
             @Test
             @DisplayName("implementation is not generic and interface is not generic")
-            void createsObjectSpecimenIfBothImplementationAndInterfaceAreNotGeneric() {
+            void ifBothImplementationAndInterfaceAreNotGeneric() {
                 assertThat(new SpecimenFactory(context).build(SpecimenType.fromClass(InterfaceWithImplementation.class)))
                         .isExactlyInstanceOf(ObjectSpecimen.class);
             }
 
             @Test
             @DisplayName("implementation is not generic and interface is generic")
-            void createsObjectSpecimenIfImplementationIsNotGenericAndInterfaceIs() {
+            void ifImplementationIsNotGenericAndInterfaceIs() {
                 assertThat(new SpecimenFactory(context).build(new SpecimenType<GenericInterfaceWithImplementation<Integer, String>>() {}))
                         .isExactlyInstanceOf(ObjectSpecimen.class);
             }
@@ -149,21 +157,21 @@ class CreatesGenericSpecimen {
 
             @Test
             @DisplayName("implementation is generic and interface is generic")
-            void createsGenericSpecimenIfImplementationAndInterfaceAreGeneric() {
+            void ifImplementationAndInterfaceAreGeneric() {
                 assertThat(new SpecimenFactory(context).build(new SpecimenType<GenericInterfaceTUWithGenericImplementationTU<String, Integer>>() {}))
                         .isExactlyInstanceOf(GenericSpecimen.class);
             }
 
             @Test
             @DisplayName("generic implementation only uses first type-argument of generic interface")
-            void createsGenericSpecimenIfGenericImplementationOnlyUsesFirstTypeArgumentOfGenericInterface() {
+            void ifGenericImplementationOnlyUsesFirstTypeArgumentOfGenericInterface() {
                 assertThat(new SpecimenFactory(context).build(new SpecimenType<GenericInterfaceTUWithGenericImplementationT<String, Integer>>() {}))
                         .isExactlyInstanceOf(GenericSpecimen.class);
             }
 
             @Test
             @DisplayName("generic implementation only uses second type-argument of generic interface")
-            void createsGenericSpecimenIfGenericImplementationOnlyUsesSecondTypeArgumentOfGenericInterface() {
+            void ifGenericImplementationOnlyUsesSecondTypeArgumentOfGenericInterface() {
                 assertThat(new SpecimenFactory(context).build(new SpecimenType<GenericInterfaceTUWithGenericImplementationU<String, Integer>>() {}))
                         .isExactlyInstanceOf(GenericSpecimen.class);
             }

src/test/java/com/github/nylle/javafixture/testobjects/interfaces/GenericInterfaceTWithGenericImplementationTU.java

@@ -0,0 +1,9 @@
+package com.github.nylle.javafixture.testobjects.interfaces;
+
+public interface GenericInterfaceTWithGenericImplementationTU<T> {
+    int publicField = 1;
+
+    T getT();
+
+    void setT(T value);
+}

src/test/java/com/github/nylle/javafixture/testobjects/interfaces/GenericInterfaceTWithGenericImplementationTUImpl.java

@@ -0,0 +1,21 @@
+package com.github.nylle.javafixture.testobjects.interfaces;
+
+public class GenericInterfaceTWithGenericImplementationTUImpl<T, U> implements GenericInterfaceTWithGenericImplementationTU<T> {
+    private U u;
+    private T t;
+
+    @Override
+    public T getT() {
+        return t;
+    }
+
+    @Override
+    public void setT(T value) {
+        t = value;
+    }
+
+    public U getU() {
+        return u;
+    }
+
+}