create a seperate config class

HamzaBenyazid · HamzaBenyazid · commit ab453cf19805 · 2023-10-24T14:57:30.000+01:00
diff --git a/src/main/java/io/javarig/RandomInstanceGenerator.java b/src/main/java/io/javarig/RandomInstanceGenerator.java
@@ -1,34 +1,31 @@
 package io.javarig;
 
+import io.javarig.config.JavaRIGConfig;
 import io.javarig.exception.InstanceGenerationException;
 import io.javarig.exception.NestedObjectRecursionException;
 import io.javarig.generator.TypeGenerator;
 import lombok.AllArgsConstructor;
-import lombok.Builder;
 import lombok.Getter;
-import lombok.NoArgsConstructor;
 import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+
 import org.apache.commons.lang3.Validate;
 
 import java.lang.reflect.Type;
 import java.util.Stack;
 
+@RequiredArgsConstructor
 @Getter
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
 public class RandomInstanceGenerator {
-    
+
     private final Stack<Type> objectStack = new Stack<>();
     private final TypeGeneratorFactory typeGeneratorFactory = new TypeGeneratorFactory();
+    private final JavaRIGConfig generalConfig;
+    private JavaRIGConfig oneTimeConfig = null;
 
-    // default values
-    public final static int DEFAULT_MAX_SIZE_EXCLUSIVE = 15;
-    public final static int DEFAULT_MIN_SIZE_INCLUSIVE = 5;
-
-    // configurations 
-    @Builder.Default private int maxSizeExclusive = DEFAULT_MAX_SIZE_EXCLUSIVE;
-    @Builder.Default private int minSizeInclusive = DEFAULT_MIN_SIZE_INCLUSIVE;
+    public RandomInstanceGenerator() {
+        this.generalConfig = JavaRIGConfig.builder().build();
+    }
 
     /**
      * generate a random instance of the given type
@@ -60,8 +57,11 @@ public <T> T generate(
             int collectionSize
     ) throws InstanceGenerationException {
         validateSize(collectionSize);
-        setSize(collectionSize);
-        return generate(type);
+        JavaRIGConfig oneTimeConfig = JavaRIGConfig.builder()
+            .maxSizeExclusive(collectionSize + 1)
+            .minSizeInclusive(collectionSize)
+            .build();
+        return generateWithOneTimeConfig(type, oneTimeConfig);
     }
 
     /**
@@ -73,13 +73,15 @@ public <T> T generate(
      * 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
+            int minSizeInclusive,
+            int maxSizeExclusive
     ) throws InstanceGenerationException {
         validateSize(minSizeInclusive, maxSizeExclusive);
-        this.maxSizeExclusive = maxSizeExclusive;
-        this.minSizeInclusive = minSizeInclusive;
-        return generate(objectType);
+        JavaRIGConfig oneTimeConfig = JavaRIGConfig.builder()
+                .maxSizeExclusive(maxSizeExclusive)
+                .minSizeInclusive(minSizeInclusive)
+                .build();
+        return generateWithOneTimeConfig(objectType, oneTimeConfig);
     }
 
     /**
@@ -98,7 +100,6 @@ public <T> T generate(
         return generate(parameterizedType);
     }
 
-
     /**
      * generate a random instance of a generic collection with a fixed size
      *
@@ -134,6 +135,13 @@ public <T> T generate(
         return generate(parameterizedType, minSizeInclusive, maxSizeExclusive);
     }
 
+    private <T> T generateWithOneTimeConfig(@NonNull Type type, JavaRIGConfig oneTimeConfig) {
+        this.oneTimeConfig = oneTimeConfig;
+        T generatedObject = generate(type);
+        this.oneTimeConfig = null;
+        return generatedObject;
+    }
+
     /**
      * check if type exists in objectStack, if so then object can't be generated because there is recursion
      * in this object's fields (there is a field that it's instantiation depends on owner object)
@@ -156,9 +164,4 @@ private void validateSize(int size) {
         Validate.isTrue(size >= 0, "Size must be non-negative.");
     }
 
-    private void setSize(int size){
-        this.maxSizeExclusive = size + 1;
-        this.minSizeInclusive = size;
-    }
-
 }
diff --git a/src/main/java/io/javarig/config/DefaultConfigValues.java b/src/main/java/io/javarig/config/DefaultConfigValues.java
@@ -0,0 +1,6 @@
+package io.javarig.config;
+
+public class DefaultConfigValues {
+    public final static int DEFAULT_MAX_SIZE_EXCLUSIVE = 15;
+    public final static int DEFAULT_MIN_SIZE_INCLUSIVE = 5;
+}
diff --git a/src/main/java/io/javarig/config/JavaRIGConfig.java b/src/main/java/io/javarig/config/JavaRIGConfig.java
@@ -0,0 +1,11 @@
+package io.javarig.config;
+
+import lombok.Builder;
+import lombok.Getter;
+
+@Getter
+@Builder
+public class JavaRIGConfig {
+    @Builder.Default private int maxSizeExclusive = DefaultConfigValues.DEFAULT_MAX_SIZE_EXCLUSIVE;
+    @Builder.Default private int minSizeInclusive = DefaultConfigValues.DEFAULT_MIN_SIZE_INCLUSIVE;
+}
diff --git a/src/main/java/io/javarig/generator/ArrayGenerator.java b/src/main/java/io/javarig/generator/ArrayGenerator.java
@@ -35,7 +35,7 @@ private Object generatePrimitiveArray(Class<?> primitiveType) {
 
     private Object[] generateArray(Class<?> arrayParameterType) {
         List<Object> objectList = getRandomInstanceGenerator()
-                .generate(List.class, getRandomInstanceGenerator().getMinSizeInclusive(), getRandomInstanceGenerator().getMaxSizeExclusive(), arrayParameterType);
+                .generate(List.class, getConfig().getMinSizeInclusive(), getConfig().getMaxSizeExclusive(), arrayParameterType);
         Object[] arrayInstance = (Object[]) Array.newInstance(arrayParameterType, 0);
         arrayInstance = objectList.toArray(arrayInstance);
         return arrayInstance;
diff --git a/src/main/java/io/javarig/generator/StringGenerator.java b/src/main/java/io/javarig/generator/StringGenerator.java
@@ -16,6 +16,6 @@ public StringGenerator(Type type, RandomInstanceGenerator randomInstanceGenerato
 
     @Override
     public String generate() {
-        return RandomStringUtils.randomAlphanumeric(getRandomInstanceGenerator().getMinSizeInclusive(), getRandomInstanceGenerator().getMaxSizeExclusive());
+        return RandomStringUtils.randomAlphanumeric(getConfig().getMinSizeInclusive(), getConfig().getMaxSizeExclusive());
     }
 }
diff --git a/src/main/java/io/javarig/generator/TypeGenerator.java b/src/main/java/io/javarig/generator/TypeGenerator.java
@@ -1,6 +1,7 @@
 package io.javarig.generator;
 
 import io.javarig.RandomInstanceGenerator;
+import io.javarig.config.JavaRIGConfig;
 import io.javarig.exception.InstanceGenerationException;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
@@ -19,6 +20,14 @@ public abstract class TypeGenerator {
     private final Random random = new Random();
     private final Type type;
     private final RandomInstanceGenerator randomInstanceGenerator;
+
+    protected JavaRIGConfig getConfig(){
+        if(getRandomInstanceGenerator().getOneTimeConfig() != null) {
+            return getRandomInstanceGenerator().getOneTimeConfig();
+        }
+        return getRandomInstanceGenerator().getGeneralConfig();
+    }
+
     /**
      * generates a random object, its type is known from the extending class
      */
diff --git a/src/main/java/io/javarig/generator/collection/SingleGenericTypeCollectionGenerator.java b/src/main/java/io/javarig/generator/collection/SingleGenericTypeCollectionGenerator.java
@@ -28,7 +28,7 @@ public int getNumberOfGenericParams() {
 
     @Override
     public T generate() throws InstanceGenerationException {
-        int randomSize = getRandom().nextInt(getRandomInstanceGenerator().getMinSizeInclusive(), getRandomInstanceGenerator().getMaxSizeExclusive());
+        int randomSize = getRandom().nextInt(getConfig().getMinSizeInclusive(), getConfig().getMaxSizeExclusive());
         checkIfValidNumberOfGenericArguments(getType());
         ParameterizedType parameterizedType = (ParameterizedType) getType();
         Type listParameterType = parameterizedType.getActualTypeArguments()[0];
diff --git a/src/main/java/io/javarig/generator/collection/map/MapGenerator.java b/src/main/java/io/javarig/generator/collection/map/MapGenerator.java
@@ -33,7 +33,7 @@ public int getNumberOfGenericParams() {
     @Override
     public Map<Object, Object> generate() throws InstanceGenerationException {
         checkIfValidNumberOfGenericArguments(getType());
-        int size = getRandom().nextInt(getRandomInstanceGenerator().getMinSizeInclusive(), getRandomInstanceGenerator().getMaxSizeExclusive());
+        int size = getRandom().nextInt(getConfig().getMinSizeInclusive(), getConfig().getMaxSizeExclusive());
         ParameterizedType parameterizedType = (ParameterizedType) getType();
         return generate(parameterizedType, size);
     }
diff --git a/src/test/java/io/javarig/generation/ObjectGenerationTest.java b/src/test/java/io/javarig/generation/ObjectGenerationTest.java
@@ -1,6 +1,7 @@
 package io.javarig.generation;
 
 import io.javarig.RandomInstanceGenerator;
+import io.javarig.config.DefaultConfigValues;
 import io.javarig.exception.*;
 import io.javarig.testclasses.*;
 import lombok.extern.slf4j.Slf4j;
@@ -164,7 +165,7 @@ public void shouldGenerateObjectWithFieldsContainingSetterPrefix() {
                 .extracting(ClassWithFieldContainingSetterPrefix::getSettersList)
                 .asList()
                 .isNotNull()
-                .hasSizeBetween(RandomInstanceGenerator.DEFAULT_MIN_SIZE_INCLUSIVE, RandomInstanceGenerator.DEFAULT_MAX_SIZE_EXCLUSIVE)// could be better if we had access to collectionGenerator defaultMin defaultMax size as public static fields
+                .hasSizeBetween(DefaultConfigValues.DEFAULT_MIN_SIZE_INCLUSIVE, DefaultConfigValues.DEFAULT_MAX_SIZE_EXCLUSIVE)// could be better if we had access to collectionGenerator defaultMin defaultMax size as public static fields
                 .element(0)
                 .isNotNull()
                 .asString()
@@ -204,7 +205,7 @@ public void shouldGenerateAGenericClass(Type genericType) {
                 .extracting(GenericTestClass::getList)
                 .asList()
                 .isNotNull()
-                .hasSizeBetween(RandomInstanceGenerator.DEFAULT_MIN_SIZE_INCLUSIVE, RandomInstanceGenerator.DEFAULT_MAX_SIZE_EXCLUSIVE)// could be better if we had access to collectionGenerator defaultMin defaultMax size as public static fields
+                .hasSizeBetween(DefaultConfigValues.DEFAULT_MIN_SIZE_INCLUSIVE, DefaultConfigValues.DEFAULT_MAX_SIZE_EXCLUSIVE)// could be better if we had access to collectionGenerator defaultMin defaultMax size as public static fields
                 .element(0)
                 .isInstanceOf((Class<?>) genericType);
     }

Original file line number	Diff line number	Diff line change
`@@ -16,6 +16,6 @@ public StringGenerator(Type type, RandomInstanceGenerator randomInstanceGenerato`
`16`	`16`
`17`	`17`	`@Override`
`18`	`18`	`public String generate() {`
`19`		`- return RandomStringUtils.randomAlphanumeric(getRandomInstanceGenerator().getMinSizeInclusive(), getRandomInstanceGenerator().getMaxSizeExclusive());`
	`19`	`+ return RandomStringUtils.randomAlphanumeric(getConfig().getMinSizeInclusive(), getConfig().getMaxSizeExclusive());`
`20`	`20`	`}`
`21`	`21`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ public int getNumberOfGenericParams() {`
`33`	`33`	`@Override`
`34`	`34`	`public Map<Object, Object> generate() throws InstanceGenerationException {`
`35`	`35`	`checkIfValidNumberOfGenericArguments(getType());`
`36`		`- int size = getRandom().nextInt(getRandomInstanceGenerator().getMinSizeInclusive(), getRandomInstanceGenerator().getMaxSizeExclusive());`
	`36`	`+ int size = getRandom().nextInt(getConfig().getMinSizeInclusive(), getConfig().getMaxSizeExclusive());`
`37`	`37`	`ParameterizedType parameterizedType = (ParameterizedType) getType();`
`38`	`38`	`return generate(parameterizedType, size);`
`39`	`39`	`}`