Refactor to give a nice shape to be extended for future requirements (#…

…24)

[#19] DefaultLookUp support multiple types of source to resolve the value and removed the randomLookup.
[#20] Refactor to remove dependency on Fyodor and replaced by Supplier.
[#21] Changes in the DSL to have separate methods for override based on the type.

updating README

README.md

@@ -5,6 +5,8 @@
 
 Library to build your POJO entities using a very intuitive DSL.
 
+**NOTE**: from version 0.2.x the DSL has changed a little bit to provide more support and new features. you will have to update your test in order to use the new version but hopefully the DSL should change.
+
 ## Motivation
 Most of the time when I am writing my tests I have the need to write clean and readable tests. One way to achieve is by having Test Builder, but normally it takes time and are difficult to mantain in time. So after looking around I came up with this library to help you to create your pojo in a different and easy way.
 
@@ -69,8 +71,8 @@ and below is the code to generate your pojo.
 ```java
 Pojo pojo = Builder.build()
                 .entity(PojoBuilder.creator)
-                .override(PojoBuilder.name, "nameoverrideed")
-                .override(PojoBuilder.value, "valueoverrided")
+                .overrideValue(PojoBuilder.name, "nameoverrideed")
+                .overrideValue(PojoBuilder.value, "valueoverrided")
                 .get();
 ```
 
@@ -79,7 +81,7 @@ You can nullify a field by just using nullify Method from DSL.
 ```java
 Pojo pojo = Builder.build()
                 .entity(PojoBuilder.creator)
-                .override(PojoBuilder.name, "nameoverrideed")
+                .overrideValue(PojoBuilder.name, "nameoverrideed")
                 .nullify(PojoBuilder.value)
                 .get();
 ```
@@ -99,11 +101,11 @@ If you already have creators and you want to reuse them on other creator, you ca
 
     Pojo pojo = Builder.build()
                     .entity(creator)
-                    .override(name, "test2")
+                    .overrideValue(name, "test2")
                     .get();
 ```
 
-- The other way is by overriding a field using a creator as value:
+- The other way is by overriding a field using a creator or Supplier as value:
 
 ```java
 
@@ -112,9 +114,9 @@ public static Creator<String> secondCreator = lookUp -> lookUp.get(secondName, "
 
 Pojo pojo = Builder.build()
                 .entity(PojoBuilder.creator)
-                .override(PojoBuilder.name, "nameoverrideed")
-                .override(PojoBuilder.secondName, "secondName")
-                .override(PojoBuilder.value, secondCreator)
+                .overrideValue(PojoBuilder.name, "nameoverrideed")
+                .overrideSupplier(PojoBuilder.secondName, () -> "secondName")
+                .overrideCreator(PojoBuilder.value, secondCreator)
                 .get();
 ```
 
@@ -130,10 +132,10 @@ In the example below we are creating a list of two elements overriding the fiend
 List<Pojo> testSiumple = Builder.build()
     .list(creator).elements()
         .element()
-            .override(name, "testSiumple")
+            .overrideValue(name, "testSiumple")
             .end()
         .element()
-            .override(name, "testSiumple2")
+            .overrideValue(name, "testSiumple2")
             .end()
     .get();
 ```
@@ -144,8 +146,8 @@ Also if you want to generate a certain amount of elements using the defaults val
 List<Pojo> testSimple = Builder.build()
                 .list(creator)
                 .size(5)
-                .override(name, RDG.string())
-                .override(value, RDG.string())
+                .overrideSupplier(name, () -> RDG.string())
+                .overrideSupplier(value, () -> RDG.string())
                 .get();
 ```
 This code will generate a List of five elements and each element will contain a random value and field.

build.gradle

@@ -24,13 +24,11 @@ repositories {
 
 dependencies {
     implementation "ch.qos.logback:logback-classic:1.2.1"
-    implementation "uk.org.fyodor:fyodor-core:1.0.0"
     implementation "com.google.guava:guava:27.0-jre"
     testImplementation "org.junit.jupiter:junit-jupiter-api:5.2.0"
     testImplementation "org.junit.jupiter:junit-jupiter-params:5.2.0"
     testImplementation "org.assertj:assertj-core:3.10.0"
-
-    testImplementation "org.assertj:assertj-core:3.10.0"
+    testImplementation "uk.org.fyodor:fyodor-core:1.0.0"
 
     testImplementation "org.mockito:mockito-junit-jupiter:2.25.0"
 

src/main/java/uk/co/caeldev/builder4test/DefaultLookUp.java

@@ -1,41 +1,38 @@
 package uk.co.caeldev.builder4test;
 
+import uk.co.caeldev.builder4test.resolvers.Resolver;
+
 import java.util.HashMap;
 import java.util.Map;
-import java.util.Optional;
 
 import static java.util.Objects.isNull;
 
 public class DefaultLookUp extends LookUp {
 
-    private Map<Field, Optional> values;
+    private Map<Field, Resolver> values;
 
     protected DefaultLookUp() {
         this.values = new HashMap<>();
     }
 
-    protected DefaultLookUp(Map<Field, Optional> values) {
+    protected DefaultLookUp(Map<Field, Resolver> values) {
         this.values = values;
     }
 
     @Override
-    protected <V> void put(Field<V> field, V value) {
-        values.put(field, Optional.ofNullable(value));
+    protected <V, U> void put(Field<V> field, Resolver<V, U> value) {
+        values.put(field, value);
     }
 
     @Override
     public <V> V get(Field<V> field, V defaultValue) {
-        Optional optValue = values.get(field);
+        Resolver<V, ?> resolver = values.get(field);
 
-        if (isNull(optValue)) {
+        if (isNull(resolver)) {
             return defaultValue;
         }
 
-        if (optValue.isPresent()) {
-            return (V) optValue.get();
-        }
-
-        return null;
+        return resolver.resolve();
     }
 
     @Override

src/main/java/uk/co/caeldev/builder4test/ElementBuilder.java

@@ -1,13 +1,17 @@
 package uk.co.caeldev.builder4test;
 
+import uk.co.caeldev.builder4test.resolvers.Resolver;
+import uk.co.caeldev.builder4test.resolvers.SupplierResolver;
+import uk.co.caeldev.builder4test.resolvers.ValueResolver;
+
 import java.util.HashMap;
 import java.util.Map;
-import java.util.Optional;
+import java.util.function.Supplier;
 
 public class ElementBuilder<K> implements OverrideField<ElementBuilder<K>> {
 
     private final ElementListBuilder<K> elementListBuilder;
-    private final Map<Field, Optional> fields;
+    private final Map<Field, Resolver> fields;
 
     private ElementBuilder(ElementListBuilder<K> elementListBuilder) {
         this.elementListBuilder = elementListBuilder;
@@ -18,23 +22,29 @@ public static <U> ElementBuilder<U> elementBuilder(ElementListBuilder<U> element
         return new ElementBuilder<>(elementListBuilder);
     }
 
-    protected Map<Field, Optional> getFields() {
+    protected Map<Field, Resolver> getFields() {
         return this.fields;
     }
 
     @Override
-    public <U> ElementBuilder<K> override(Field<U> field, U value) {
-        this.fields.put(field, Optional.ofNullable(value));
+    public <U> ElementBuilder<K> override(Field<U> field, Supplier<U> value) {
+        this.fields.put(field, new SupplierResolver(value));
+        return this;
+    }
+
+    @Override
+    public <U> ElementBuilder<K> overrideValue(Field<U> field, U value) {
+        this.fields.put(field, new ValueResolver<>(value));
         return this;
     }
 
     @Override
     public <U> ElementBuilder<K> override(Field<U> field, Creator<U> creator) {
-        return override(field, creator.build(new DefaultLookUp(fields)));
+        return override(field, () -> creator.build(new DefaultLookUp(fields)));
     }
 
     public <U> ElementBuilder<K> nullify(Field<U> field) {
-        this.fields.put(field, Optional.empty());
+        this.fields.put(field, new SupplierResolver(() -> null));
         return this;
     }
 

src/main/java/uk/co/caeldev/builder4test/ElementListBuilder.java

@@ -1,17 +1,17 @@
 package uk.co.caeldev.builder4test;
 
 import com.google.common.collect.Lists;
+import uk.co.caeldev.builder4test.resolvers.Resolver;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import java.util.stream.Collectors;
 
 public class ElementListBuilder<K> {
 
     private final Creator<K> creator;
-    private final List<Map<Field, Optional>> elements;
+    private final List<Map<Field, Resolver>> elements;
 
     private ElementListBuilder(Creator<K> creator) {
         this.creator = creator;

src/main/java/uk/co/caeldev/builder4test/EntityBuilder.java

@@ -1,7 +1,11 @@
 package uk.co.caeldev.builder4test;
 
+import uk.co.caeldev.builder4test.resolvers.Resolver;
+import uk.co.caeldev.builder4test.resolvers.SupplierResolver;
+import uk.co.caeldev.builder4test.resolvers.ValueResolver;
+
 import java.util.Map;
-import java.util.Optional;
+import java.util.function.Supplier;
 
 public class EntityBuilder<K> implements OverrideField<EntityBuilder<K>> {
 
@@ -13,7 +17,7 @@ private EntityBuilder(Creator<K> creator) {
         this.lookUp = new DefaultLookUp();
     }
 
-    private EntityBuilder(Creator<K> creator, Map<Field, Optional> fields) {
+    private EntityBuilder(Creator<K> creator, Map<Field, Resolver> fields) {
         this.creator = creator;
         this.lookUp = new DefaultLookUp(fields);
     }
@@ -23,31 +27,37 @@ private EntityBuilder(Creator<K> creator, LookUp lookUp) {
         this.lookUp = lookUp;
     }
 
-    protected static <T> EntityBuilder<T> entityBuilder(Creator<T> Creator, Map<Field, Optional> fields) {
-        return new EntityBuilder<>(Creator, fields);
+    protected static <T> EntityBuilder<T> entityBuilder(Creator<T> creator, Map<Field, Resolver> fields) {
+        return new EntityBuilder<>(creator, fields);
+    }
+
+    protected static <T> EntityBuilder<T> entityBuilder(Creator<T> creator) {
+        return new EntityBuilder<>(creator);
     }
 
-    protected static <T> EntityBuilder<T> entityBuilder(Creator<T> Creator) {
-        return new EntityBuilder<>(Creator);
+    protected static <T> EntityBuilder<T> entityBuilder(Creator<T> creator, LookUp lookUp) {
+        return new EntityBuilder<>(creator, lookUp);
     }
 
-    protected static <T> EntityBuilder<T> entityBuilder(Creator<T> Creator, LookUp lookUp) {
-        return new EntityBuilder<>(Creator, lookUp);
+    @Override
+    public <V> EntityBuilder<K> override(Field<V> field, Supplier<V> value) {
+        lookUp.put(field, new SupplierResolver<>(value));
+        return this;
     }
 
     @Override
-    public <V> EntityBuilder<K> override(Field<V> field, V value) {
-        lookUp.put(field, value);
+    public <U> EntityBuilder<K> overrideValue(Field<U> field, U value) {
+        lookUp.put(field, new ValueResolver<>(value));
         return this;
     }
 
     @Override
     public <V> EntityBuilder<K> override(Field<V> field, Creator<V> creator) {
-        return override(field, creator.build(lookUp));
+        return override(field, () -> creator.build(lookUp));
     }
 
     public <V> EntityBuilder<K> nullify(Field<V> field) {
-        lookUp.put(field, null);
+        lookUp.put(field, new SupplierResolver<>(() -> null));
         return this;
     }
 

src/main/java/uk/co/caeldev/builder4test/FixedSizeListBuilder.java

@@ -1,52 +1,53 @@
 package uk.co.caeldev.builder4test;
 
-import uk.org.fyodor.generators.Generator;
+import uk.co.caeldev.builder4test.resolvers.Resolver;
+import uk.co.caeldev.builder4test.resolvers.SupplierResolver;
+import uk.co.caeldev.builder4test.resolvers.ValueResolver;
 
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Optional;
+import java.util.function.Supplier;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
 public class FixedSizeListBuilder<K> implements OverrideField<FixedSizeListBuilder<K>>{
 
     private final int size;
     private final Creator<K> creator;
-    private final Map<Field, Generator> generators;
-    private final Map<Field, Optional> values;
+    private final Map<Field, Resolver> values;
 
     private FixedSizeListBuilder(int size, Creator<K> creator) {
         this.size = size;
         this.creator = creator;
         values = new HashMap<>();
-        generators = new HashMap<>();
 
     }
 
     protected static <U> FixedSizeListBuilder<U> fixedSizeListBuilder(int size, Creator<U> creator) {
         return new FixedSizeListBuilder<>(size, creator);
     }
 
-    public <U> FixedSizeListBuilder<K> override(Field<U> field, Generator<U> generator) {
-        generators.put(field, generator);
+    @Override
+    public <U> FixedSizeListBuilder<K> override(Field<U> field, Supplier<U> supplier) {
+        values.put(field, new SupplierResolver(supplier));
         return this;
     }
 
     @Override
-    public <U> FixedSizeListBuilder<K> override(Field<U> field, U value) {
-        values.put(field, Optional.of(value));
+    public <U> FixedSizeListBuilder<K> overrideValue(Field<U> field, U value) {
+        values.put(field, new ValueResolver<>(value));
         return this;
     }
 
     @Override
     public <U> FixedSizeListBuilder<K> override(Field<U> field, Creator<U> creator) {
-        override(field, creator.build(new DefaultLookUp(values)));
+        override(field, () -> creator.build(new DefaultLookUp(values)));
         return this;
     }
 
     public List<K> get() {
-        LookUp lookUp = new RandomLookUp(values, generators);
+        LookUp lookUp = new DefaultLookUp(values);
         return IntStream.rangeClosed(1, size)
                 .mapToObj(it -> EntityBuilder.entityBuilder(creator, lookUp).get())
                 .collect(Collectors.toList());

src/main/java/uk/co/caeldev/builder4test/LookUp.java

@@ -1,8 +1,10 @@
 package uk.co.caeldev.builder4test;
 
+import uk.co.caeldev.builder4test.resolvers.Resolver;
+
 public abstract class LookUp {
 
-    protected abstract <V> void put(Field<V> field, V value);
+    protected abstract <V, U> void put(Field<V> field, Resolver<V, U> value);
 
     public abstract <V> V get(Field<V> field);
 

src/main/java/uk/co/caeldev/builder4test/OverrideField.java

@@ -1,8 +1,11 @@
 package uk.co.caeldev.builder4test;
 
+import java.util.function.Supplier;
+
 public interface OverrideField<L> {
 
     <U> L override(Field<U> field, Creator<U> creator);
-    <U> L override(Field<U> field, U value);
+    <U> L override(Field<U> field, Supplier<U> supplier);
+    <U> L overrideValue(Field<U> field, U value);
 
 }