refactor: extract collection randomisation

Author: Nylle

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

@@ -15,7 +15,6 @@
 import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.Deque;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -24,7 +23,6 @@
 import java.util.Map;
 import java.util.NavigableSet;
 import java.util.Queue;
-import java.util.Random;
 import java.util.Set;
 import java.util.SortedSet;
 import java.util.TreeSet;
@@ -37,12 +35,11 @@
 
 import static java.lang.String.format;
 import static java.util.Arrays.stream;
-import static java.util.stream.Collectors.toList;
 
 public class InstanceFactory {
 
     private final SpecimenFactory specimenFactory;
-    private final Random random;
+    private final PseudoRandom random;
 
     private static final Map<Class<?>, Object> primitiveDefaults = Map.of(
             Boolean.TYPE, false,
@@ -57,34 +54,27 @@ public class InstanceFactory {
 
     public InstanceFactory(SpecimenFactory specimenFactory) {
         this.specimenFactory = specimenFactory;
-        this.random = new Random();
+        this.random = new PseudoRandom();
     }
 
     public <T> T construct(final SpecimenType<T> type, CustomizationContext customizationContext) {
-        var constructors = type.getDeclaredConstructors()
+        return random.shuffled(type.getDeclaredConstructors())
                 .stream()
                 .filter(x -> Modifier.isPublic(x.getModifiers()))
-                .collect(toList());
-
-        if (constructors.isEmpty()) {
-            return manufacture(type, customizationContext);
-        }
-
-        return construct(type, constructors.get(random.nextInt(constructors.size())), customizationContext);
+                .findFirst()
+                .map(x -> construct(type, x, customizationContext))
+                .orElseGet(() -> manufacture(type, customizationContext));
     }
 
     public <T> T manufacture(final SpecimenType<T> type, CustomizationContext customizationContext) {
-        var factoryMethods = type.getFactoryMethods();
-        Collections.shuffle(factoryMethods);
-        var results = factoryMethods
+        return random.shuffled(type.getFactoryMethods())
                 .stream()
                 .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())));
+                .findFirst()
+                .orElseThrow(() -> new SpecimenException(format("Cannot create instance of %s", type.asClass())));
     }
 
     private <T> boolean hasSpecimenTypeAsParameter(Method m, SpecimenType<T> type) {
@@ -107,7 +97,7 @@ public <T> Object proxy(final SpecimenType<T> type) {
     public <T> Object proxy(final SpecimenType<T> type, final Map<String, ISpecimen<?>> specimens) {
         if (type.isInterface()) {
             var proxyFactory = new ProxyFactory();
-            proxyFactory.setInterfaces( new Class<?>[]{type.asClass()});
+            proxyFactory.setInterfaces(new Class<?>[]{type.asClass()});
             try {
                 return proxyFactory.create(new Class[0], new Object[0], new ProxyInvocationHandler(specimenFactory, specimens));
             } catch (Exception e) {
@@ -227,8 +217,7 @@ private <G, T extends Collection<G>> T createCollectionFromInterfaceType(final C
     private <G, T extends Collection<G>> T createCollectionFromConcreteType(final SpecimenType<T> type) {
         try {
             return type.asClass().getDeclaredConstructor().newInstance();
-        } catch (InstantiationException | IllegalAccessException | InvocationTargetException |
-                 NoSuchMethodException e) {
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
             throw new SpecimenException("Unable to create collection of type " + type.getName(), e);
         }
     }

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

@@ -3,6 +3,10 @@
 import com.github.nylle.javafixture.specimen.constraints.StringConstraints;
 
 import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
 import java.util.Random;
 import java.util.UUID;
 import java.util.stream.Collectors;
@@ -77,4 +81,10 @@ public Character nextChar() {
     public Byte nextByte() {
         return UUID.randomUUID().toString().getBytes(Charset.defaultCharset())[0];
     }
+
+    public <T> List<T> shuffled(Collection<T> collection) {
+        var result = new ArrayList<>(collection);
+        Collections.shuffle(result, random);
+        return result;
+    }
 }

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

@@ -96,7 +96,7 @@ void canOnlyUsePublicConstructor() {
 
             assertThatExceptionOfType(SpecimenException.class)
                     .isThrownBy(() -> sut.construct(fromClass(TestObjectWithPrivateConstructor.class), new CustomizationContext(List.of(), Map.of(), false)))
-                    .withMessageContaining("Cannot manufacture class")
+                    .withMessageContaining("Cannot create instance of class")
                     .withNoCause();
         }
 
@@ -111,7 +111,7 @@ void useFactoryMethodWhenNoConstructorExists() {
         }
 
         @Test
-        @DisplayName("will fallback to factor method when constructor fails")
+        @DisplayName("will fallback to factory method when constructor fails")
         void fallbackToFactoryMethodWhenConstructorThrowsException() {
             var sut = new InstanceFactory(new SpecimenFactory(new Context(Configuration.configure())));
 
@@ -190,7 +190,7 @@ void canOnlyUsePublicFactoryMethods() {
 
             assertThatExceptionOfType(SpecimenException.class)
                     .isThrownBy(() -> sut.manufacture(fromClass(TestObjectWithNonPublicFactoryMethods.class), noContext()))
-                    .withMessageContaining("Cannot manufacture class")
+                    .withMessageContaining("Cannot create instance of class")
                     .withNoCause();
         }
 
@@ -256,7 +256,7 @@ void factoryMethodWithGenericArgument() {
         }
 
         @Test
-        @DisplayName("method without arguments is used")
+        @DisplayName("generic method without arguments is used")
         void genericNoArgumentFactoryMethod() {
             var sut = new InstanceFactory(new SpecimenFactory(new Context(Configuration.configure())));
 

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

@@ -6,6 +6,8 @@
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
+import java.util.List;
+
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
@@ -84,4 +86,15 @@ void nextChar() {
     void nextByte() {
         assertThat(new PseudoRandom().nextByte()).isBetween(Byte.MIN_VALUE, Byte.MAX_VALUE);
     }
+
+    @Test
+    void shuffled() {
+        var input = List.of(0, 1, 2, 3, 4);
+
+        var actual = new PseudoRandom().shuffled(input);
+
+        assertThat(actual).isNotEqualTo(input);
+        assertThat(actual).isNotSameAs(input);
+        assertThat(actual).containsExactlyInAnyOrderElementsOf(input);
+    }
 }