make a public generate method that takes oneTimeConfig and remove methods that take sizes

Author: HamzaBenyazid

src/main/java/io/javarig/RandomInstanceGenerator.java

@@ -1,15 +1,13 @@
 package io.javarig;
 
-import io.javarig.config.JavaRIGConfig;
+import io.javarig.config.Configuration;
 import io.javarig.exception.InstanceGenerationException;
 import io.javarig.exception.NestedObjectRecursionException;
 import io.javarig.generator.TypeGenerator;
-import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NonNull;
 import lombok.RequiredArgsConstructor;
 
-import org.apache.commons.lang3.Validate;
 
 import java.lang.reflect.Type;
 import java.util.Stack;
@@ -20,19 +18,23 @@ public class RandomInstanceGenerator {
 
     private final Stack<Type> objectStack = new Stack<>();
     private final TypeGeneratorFactory typeGeneratorFactory = new TypeGeneratorFactory();
-    private final JavaRIGConfig generalConfig;
-    private JavaRIGConfig oneTimeConfig = null;
+    private final Configuration generalConfig;
+    private Configuration oneTimeConfig = null;
 
     public RandomInstanceGenerator() {
-        this.generalConfig = JavaRIGConfig.builder().build();
+        this.generalConfig = Configuration.builder().build();
     }
 
     /**
      * generate a random instance of the given type
-     *
+     * 
+     * @param objectType type of the object
      * @return the generated object
-     * @throws InstanceGenerationException if the instance cannot be generated for some reason (class doesn't have
-     * a default constructor , class have a non-public default constructor , setter cannot be invoked ... )
+     * @throws InstanceGenerationException if the instance cannot be generated for
+     *                                     some reason (class doesn't have a default
+     *                                     constructor , class have a non-public
+     *                                     default constructor , setter cannot be
+     *                                     invoked ... )
      */
     @SuppressWarnings({"unchecked"})
     public <T> T generate(@NonNull Type objectType) throws InstanceGenerationException {
@@ -45,52 +47,36 @@ public <T> T generate(@NonNull Type objectType) throws InstanceGenerationExcepti
     }
 
     /**
-     * generate a random instance for a collection, with a fixed size
-     *
-     * @param collectionSize the size of the collection to generate
-     * @return the generated object
-     * @throws InstanceGenerationException if the instance cannot be generated for some reason (class doesn't have
-     * a default constructor , class have a non-public default constructor , setter cannot be invoked ... )
-     */
-    public <T> T generate(
-            @NonNull Type type,
-            int collectionSize
-    ) throws InstanceGenerationException {
-        validateSize(collectionSize);
-        JavaRIGConfig oneTimeConfig = JavaRIGConfig.builder()
-            .maxSizeExclusive(collectionSize + 1)
-            .minSizeInclusive(collectionSize)
-            .build();
-        return generateWithOneTimeConfig(type, oneTimeConfig);
-    }
-
-    /**
-     * generate a random instance for a collection, with size between a range
+     * generate a random instance for a collection, with a one time configuration
      *
-     * @param <T> the generic type of the object to generate
+     * @param objectType    type of the object
+     * @param oneTimeConfig a configuration for the generator that gets applied one
+     *                      time and doesn't overide the general configuration
+     *                      provided at the creation
      * @return the generated object
-     * @throws InstanceGenerationException if the instance cannot be generated for some reason (class doesn't have
-     * a default constructor , class have a non-public default constructor , setter cannot be invoked ... )
+     * @throws InstanceGenerationException if the instance cannot be generated for
+     *                                     some reason (class doesn't have a default
+     *                                     constructor , class have a non-public
+     *                                     default constructor , setter cannot be
+     *                                     invoked ... )
      */
     public <T> T generate(@NonNull Type objectType,
-            int minSizeInclusive,
-            int maxSizeExclusive
+            Configuration oneTimeConfig
     ) throws InstanceGenerationException {
-        validateSize(minSizeInclusive, maxSizeExclusive);
-        JavaRIGConfig oneTimeConfig = JavaRIGConfig.builder()
-                .maxSizeExclusive(maxSizeExclusive)
-                .minSizeInclusive(minSizeInclusive)
-                .build();
         return generateWithOneTimeConfig(objectType, oneTimeConfig);
     }
 
     /**
      * generate a random instance of a generic type
      *
+     * @param objectType   type of the object
      * @param genericTypes types of generic parameters
      * @return the generated object
-     * @throws InstanceGenerationException if the instance cannot be generated for some reason (class doesn't have
-     * a default constructor , class have a non-public default constructor , setter cannot be invoked ... )
+     * @throws InstanceGenerationException if the instance cannot be generated for
+     *                                     some reason (class doesn't have a default
+     *                                     constructor , class have a non-public
+     *                                     default constructor , setter cannot be
+     *                                     invoked ... )
      */
     public <T> T generate(
             @NonNull Type objectType,
@@ -103,41 +89,30 @@ public <T> T generate(
     /**
      * generate a random instance of a generic collection with a fixed size
      *
-     * @param genericTypes types of generic parameters
-     * @return the generated object
-     * @throws InstanceGenerationException if the instance cannot be generated for some reason (class doesn't have
-     * a default constructor , class have a non-public default constructor , setter cannot be invoked ... )
-     */
-    public <T> T generate(
-            @NonNull Type type,
-            int collectionSize,
-            @NonNull Type... genericTypes
-    ) throws InstanceGenerationException {
-        Type parameterizedType = new ParameterizedTypeImpl(genericTypes, (Class<?>) type);
-        return generate(parameterizedType, collectionSize);
-    }
-
-    /**
-     * generate a random instance of a generic collection with a size between a range
-     *
-     * @param genericTypes types of generic parameters
+     * @param objectType    type of the object
+     * @param oneTimeConfig a configuration for the generator that gets applied one
+     *                      time and doesn't overide the general configuration
+     *                      provided at the creation
+     * @param genericTypes  types of generic parameters
      * @return the generated object
-     * @throws InstanceGenerationException if the instance cannot be generated for some reason (class doesn't have
-     * a default constructor , class have a non-public default constructor , setter cannot be invoked ... )
+     * @throws InstanceGenerationException if the instance cannot be generated for
+     *                                     some reason (class doesn't have
+     *                                     a default constructor , class have a
+     *                                     non-public default constructor , setter
+     *                                     cannot be invoked ... )
      */
     public <T> T generate(
-            @NonNull Type type,
-            int minSizeInclusive,
-            int maxSizeExclusive,
+            @NonNull Type objectType,
+            Configuration oneTimeConfig,
             @NonNull Type... genericTypes
     ) throws InstanceGenerationException {
-        Type parameterizedType = new ParameterizedTypeImpl(genericTypes, (Class<?>) type);
-        return generate(parameterizedType, minSizeInclusive, maxSizeExclusive);
+        Type parameterizedType = new ParameterizedTypeImpl(genericTypes, (Class<?>) objectType);
+        return generate(parameterizedType, oneTimeConfig);
     }
 
-    private <T> T generateWithOneTimeConfig(@NonNull Type type, JavaRIGConfig oneTimeConfig) {
+    private <T> T generateWithOneTimeConfig(@NonNull Type objectType, Configuration oneTimeConfig) {
         this.oneTimeConfig = oneTimeConfig;
-        T generatedObject = generate(type);
+        T generatedObject = generate(objectType);
         this.oneTimeConfig = null;
         return generatedObject;
     }
@@ -149,19 +124,12 @@ private <T> T generateWithOneTimeConfig(@NonNull Type type, JavaRIGConfig oneTim
      *
      * @param type - a type to search for in the stack
      */
-    private void checkForRecursion(Type type) {
-        if (!objectStack.isEmpty() && objectStack.contains(type)) {
-            throw new NestedObjectRecursionException(type);
+    private void checkForRecursion(Type objectType) {
+        if (!objectStack.isEmpty() && objectStack.contains(objectType)) {
+            throw new NestedObjectRecursionException(objectType);
         }
     }
 
-    private void validateSize(int minSizeInclusive, int maxSizeExclusive) {
-        Validate.isTrue(maxSizeExclusive > minSizeInclusive, "Start value must be smaller than end value.");
-        Validate.isTrue(minSizeInclusive >= 0, "Both range values must be non-negative.");
-    }
 
-    private void validateSize(int size) {
-        Validate.isTrue(size >= 0, "Size must be non-negative.");
-    }
 
 }

src/main/java/io/javarig/config/Configuration.java

@@ -0,0 +1,41 @@
+package io.javarig.config;
+
+import org.apache.commons.lang3.Validate;
+
+import lombok.Builder;
+import lombok.Getter;
+
+@Getter
+@Builder
+public class Configuration {
+
+    @Builder.Default
+    private int maxSizeExclusive = DefaultConfigValues.DEFAULT_MAX_SIZE_EXCLUSIVE;
+    @Builder.Default
+    private int minSizeInclusive = DefaultConfigValues.DEFAULT_MIN_SIZE_INCLUSIVE;
+
+    public static Configuration withSize(int size) {
+        validateSize(size);
+        return Configuration.builder()
+                .maxSizeExclusive(size + 1)
+                .minSizeInclusive(size)
+                .build();
+    }
+
+    public static Configuration withSize(int minSizeInclusive, int maxSizeExclusive) {
+        validateSize(minSizeInclusive, maxSizeExclusive);
+        return Configuration.builder()
+                .maxSizeExclusive(maxSizeExclusive + 1)
+                .minSizeInclusive(minSizeInclusive)
+                .build();
+    }
+
+    private static void validateSize(int minSizeInclusive, int maxSizeExclusive) {
+        Validate.isTrue(maxSizeExclusive > minSizeInclusive, "Start value must be smaller than end value.");
+        Validate.isTrue(minSizeInclusive >= 0, "Both range values must be non-negative.");
+    }
+
+    private static void validateSize(int size) {
+        Validate.isTrue(size >= 0, "Size must be non-negative.");
+    }
+}

src/main/java/io/javarig/config/JavaRIGConfig.java

@@ -35,7 +35,7 @@ private Object generatePrimitiveArray(Class<?> primitiveType) {
 
     private Object[] generateArray(Class<?> arrayParameterType) {
         List<Object> objectList = getRandomInstanceGenerator()
-                .generate(List.class, getConfig().getMinSizeInclusive(), getConfig().getMaxSizeExclusive(), arrayParameterType);
+                .generate(List.class, arrayParameterType);
         Object[] arrayInstance = (Object[]) Array.newInstance(arrayParameterType, 0);
         arrayInstance = objectList.toArray(arrayInstance);
         return arrayInstance;

src/main/java/io/javarig/generator/ArrayGenerator.java

@@ -1,7 +1,7 @@
 package io.javarig.generator;
 
 import io.javarig.RandomInstanceGenerator;
-import io.javarig.config.JavaRIGConfig;
+import io.javarig.config.Configuration;
 import io.javarig.exception.InstanceGenerationException;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
@@ -21,7 +21,7 @@ public abstract class TypeGenerator {
     private final Type type;
     private final RandomInstanceGenerator randomInstanceGenerator;
 
-    protected JavaRIGConfig getConfig(){
+    protected Configuration getConfig(){
         if(getRandomInstanceGenerator().getOneTimeConfig() != null) {
             return getRandomInstanceGenerator().getOneTimeConfig();
         }

src/main/java/io/javarig/generator/TypeGenerator.java

@@ -1,6 +1,7 @@
 package io.javarig.generation.javapredefinedtypes;
 
 import io.javarig.RandomInstanceGenerator;
+import io.javarig.config.Configuration;
 import io.javarig.testclasses.TestClass;
 import lombok.extern.slf4j.Slf4j;
 import org.junit.jupiter.api.BeforeEach;
@@ -33,7 +34,7 @@ public void shouldReturnIntegerArray(Class<?> testClass) {
     @Test
     public void shouldReturnWrapperArrayWithExactSize() {
         int size = 20;
-        Object generated = randomInstanceGenerator.generate(Double[].class, size);
+        Object generated = randomInstanceGenerator.generate(Double[].class, Configuration.withSize(size));
         log.info("shouldReturnArrayWithExactSize : {}", generated);
         assertThat(generated).isNotNull();
         assertThat(generated).isInstanceOf(Double[].class);
@@ -43,7 +44,7 @@ public void shouldReturnWrapperArrayWithExactSize() {
     @Test
     public void shouldReturnPrimitiveArrayWithExactSize() {
         int size = 20;
-        Object generated = randomInstanceGenerator.generate(double[].class, size);
+        Object generated = randomInstanceGenerator.generate(double[].class, Configuration.withSize(size));
         log.info("shouldReturnArrayWithExactSize : {}", generated);
         assertThat(generated).isNotNull();
         assertThat(generated).isInstanceOf(double[].class);
@@ -54,7 +55,7 @@ public void shouldReturnPrimitiveArrayWithExactSize() {
     public void shouldReturnArrayWithSizeBetween() {
         int minSize = 20;
         int maxSize = 40;
-        Object generated = randomInstanceGenerator.generate(String[].class, minSize, maxSize);
+        Object generated = randomInstanceGenerator.generate(String[].class, Configuration.withSize(minSize, maxSize));
         log.info("shouldReturnArrayWithSizeBetween : {}", generated);
         assertThat(generated).isNotNull();
         assertThat(generated).isInstanceOf(String[].class);
@@ -72,7 +73,7 @@ public void shouldReturn2DArray() {
     @Test
     public void shouldReturnTestClassArrayWithExactSize() {
         int size = 22;
-        Object generated = randomInstanceGenerator.generate(TestClass[].class, size);
+        Object generated = randomInstanceGenerator.generate(TestClass[].class, Configuration.withSize(size));
         log.info("shouldReturnTestClassArrayWithExactSize {} : {}", size, generated);
         assertThat(generated).isNotNull();
         assertThat(generated).isInstanceOf(TestClass[].class);

src/test/java/io/javarig/generation/javapredefinedtypes/ArrayGenerationTest.java

@@ -1,6 +1,7 @@
 package io.javarig.generation.javapredefinedtypes;
 
 import io.javarig.RandomInstanceGenerator;
+import io.javarig.config.Configuration;
 import lombok.extern.slf4j.Slf4j;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -29,7 +30,7 @@ public void shouldGenerateString() {
     @Test
     public void shouldGenerateStringWithExactSize() {
         int size = 20;
-        Object generated = randomInstanceGenerator.generate(String.class, size);
+        Object generated = randomInstanceGenerator.generate(String.class, Configuration.withSize(size));
         log.info("shouldGenerateString : {}", generated);
         assertThat(generated).isNotNull();
         assertThat(generated).isInstanceOf(String.class);
@@ -40,7 +41,7 @@ public void shouldGenerateStringWithExactSize() {
     public void shouldGenerateStringWithSizeBetween() {
         int minSize = 20;
         int maxSize = 40;
-        Object generated = randomInstanceGenerator.generate(String.class, minSize, maxSize);
+        Object generated = randomInstanceGenerator.generate(String.class, Configuration.withSize(minSize, maxSize));
         log.info("shouldGenerateString : {}", generated);
         assertThat(generated).isNotNull();
         assertThat(generated).isInstanceOf(String.class);
@@ -51,7 +52,7 @@ public void shouldThrowIllegalArgumentExceptionGivenStringHavingMinSizeGreaterTh
         int minSize = 40;
         int maxSize = 20;
         assertThatThrownBy(() -> {//when
-            randomInstanceGenerator.generate(String.class, minSize, maxSize);
+            randomInstanceGenerator.generate(String.class, Configuration.withSize(minSize, maxSize));
         }).isInstanceOf(IllegalArgumentException.class)
                 .hasMessage("Start value must be smaller than end value.");
     }
@@ -60,15 +61,15 @@ public void shouldThrowIllegalArgumentExceptionGivenStringHavingMinSizeGreaterTh
     public void shouldThrowIllegalArgumentExceptionGivenStringHavingMinSizeSameASMaxSize() {
         int size = 30;
         assertThatThrownBy(() -> {//when
-            randomInstanceGenerator.generate(String.class, size, size);
+            randomInstanceGenerator.generate(String.class, Configuration.withSize(size, size));
         }).isInstanceOf(IllegalArgumentException.class)
                 .hasMessage("Start value must be smaller than end value.");
     }
     @Test
     public void shouldThrowIllegalArgumentExceptionWhenGivenNegativeSize() {
         int size = -20;
         assertThatThrownBy(() -> {//when
-            randomInstanceGenerator.generate(String.class, size);
+            randomInstanceGenerator.generate(String.class, Configuration.withSize(size));
         }).isInstanceOf(IllegalArgumentException.class)
                 .hasMessage("Size must be non-negative.");
     }