From ec5c63058923c0b9e67772bf0a42dba18e97f403 Mon Sep 17 00:00:00 2001
From: mhyeon-lee <mhyeon.lee@navercorp.com>
Date: Sat, 2 Oct 2021 18:56:02 +0900
Subject: [PATCH] Fix ArbitraryBuilder generated Arbitrary not affected
 Validator any with action

---
 .../arbitrary/ArbitraryValue.java             | 251 +++++++++++++-----
 .../fixturemonkey/test/FixtureMonkeyTest.java |  45 ++++
 2 files changed, 230 insertions(+), 66 deletions(-)

diff --git a/fixture-monkey/src/main/java/com/navercorp/fixturemonkey/arbitrary/ArbitraryValue.java b/fixture-monkey/src/main/java/com/navercorp/fixturemonkey/arbitrary/ArbitraryValue.java
index d8a95fc30..a7eac0997 100644
--- a/fixture-monkey/src/main/java/com/navercorp/fixturemonkey/arbitrary/ArbitraryValue.java
+++ b/fixture-monkey/src/main/java/com/navercorp/fixturemonkey/arbitrary/ArbitraryValue.java
@@ -74,13 +74,21 @@ public ArbitraryValue(
 	}
 
 	@Override
-	public RandomGenerator<T> generator(int genSize) {
-		return getArbitrary().generator(genSize);
+	public synchronized RandomGenerator<T> generator(int genSize) {
+		try {
+			return getArbitrary().generator(genSize);
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public Arbitrary<Object> asGeneric() {
-		return getArbitrary().asGeneric();
+	public synchronized Arbitrary<Object> asGeneric() {
+		try {
+			return getArbitrary().asGeneric();
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
@@ -89,107 +97,180 @@ public boolean isUnique() {
 	}
 
 	@Override
-	public Optional<ExhaustiveGenerator<T>> exhaustive() {
-		return getArbitrary().exhaustive();
+	public synchronized Optional<ExhaustiveGenerator<T>> exhaustive() {
+		try {
+			return getArbitrary().exhaustive();
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public Optional<ExhaustiveGenerator<T>> exhaustive(long maxNumberOfSamples) {
-		return getArbitrary().exhaustive(maxNumberOfSamples);
+	public synchronized Optional<ExhaustiveGenerator<T>> exhaustive(long maxNumberOfSamples) {
+		try {
+			return getArbitrary().exhaustive(maxNumberOfSamples);
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public EdgeCases<T> edgeCases() {
-		return getArbitrary().edgeCases();
+	public synchronized EdgeCases<T> edgeCases() {
+		try {
+			return getArbitrary().edgeCases();
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public Optional<Stream<T>> allValues() {
-		return getArbitrary().allValues();
+	public synchronized Optional<Stream<T>> allValues() {
+		try {
+			return getArbitrary().allValues();
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public void forEachValue(Consumer<? super T> action) {
-		getArbitrary().forEachValue(action);
+	public synchronized void forEachValue(Consumer<? super T> action) {
+		try {
+			getArbitrary().forEachValue(action);
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public Arbitrary<T> filter(Predicate<T> filterPredicate) {
-		return getArbitrary().filter(filterPredicate);
+	public synchronized Arbitrary<T> filter(Predicate<T> filterPredicate) {
+		try {
+			return getArbitrary().filter(filterPredicate);
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public <U> Arbitrary<U> map(Function<T, U> mapper) {
-		return getArbitrary().map(mapper);
+	public synchronized <U> Arbitrary<U> map(Function<T, U> mapper) {
+		try {
+			return getArbitrary().map(mapper);
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public <U> Arbitrary<U> flatMap(Function<T, Arbitrary<U>> mapper) {
-		return getArbitrary().flatMap(mapper);
+	public synchronized <U> Arbitrary<U> flatMap(Function<T, Arbitrary<U>> mapper) {
+		try {
+			return getArbitrary().flatMap(mapper);
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public Arbitrary<T> injectNull(double nullProbability) {
-		return getArbitrary().injectNull(nullProbability);
+	public synchronized Arbitrary<T> injectNull(double nullProbability) {
+		try {
+			return getArbitrary().injectNull(nullProbability);
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public Arbitrary<T> unique() {
-		return getArbitrary().unique();
+	public synchronized Arbitrary<T> unique() {
+		try {
+			return getArbitrary().unique();
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public Arbitrary<T> fixGenSize(int genSize) {
-		return getArbitrary().fixGenSize(genSize);
+	public synchronized Arbitrary<T> fixGenSize(int genSize) {
+		try {
+			return getArbitrary().fixGenSize(genSize);
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public ListArbitrary<T> list() {
-		return getArbitrary().list();
+	public synchronized ListArbitrary<T> list() {
+		try {
+			return getArbitrary().list();
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public SetArbitrary<T> set() {
-		return getArbitrary().set();
+	public synchronized SetArbitrary<T> set() {
+		try {
+			return getArbitrary().set();
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public StreamArbitrary<T> stream() {
-		return getArbitrary().stream();
+	public synchronized StreamArbitrary<T> stream() {
+		try {
+			return getArbitrary().stream();
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public IteratorArbitrary<T> iterator() {
-		return getArbitrary().iterator();
+	public synchronized IteratorArbitrary<T> iterator() {
+		try {
+			return getArbitrary().iterator();
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public <A> StreamableArbitrary<T, A> array(Class<A> arrayClass) {
-		return getArbitrary().array(arrayClass);
+	public synchronized <A> StreamableArbitrary<T, A> array(Class<A> arrayClass) {
+		try {
+			return getArbitrary().array(arrayClass);
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public Arbitrary<Optional<T>> optional() {
-		return getArbitrary().optional();
+	public synchronized Arbitrary<Optional<T>> optional() {
+		try {
+			return getArbitrary().optional();
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public Arbitrary<List<T>> collect(Predicate<List<T>> until) {
-		return getArbitrary().collect(until);
+	public synchronized Arbitrary<List<T>> collect(Predicate<List<T>> until) {
+		try {
+			return getArbitrary().collect(until);
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public Stream<T> sampleStream() {
-		return getArbitrary().sampleStream();
+	public synchronized Stream<T> sampleStream() {
+		try {
+			return getArbitrary().sampleStream();
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
-	@SuppressWarnings("unchecked")
 	@Override
-	public T sample() {
+	public synchronized T sample() {
 		try {
-			return getArbitrary()
-				.filter((Predicate<T>)this.validateFilter(validOnly))
-				.sample();
+			return getArbitrary().sample();
 		} catch (TooManyFilterMissesException ex) {
 			StringBuilder builder = new StringBuilder();
 			this.violations.values().forEach(violation -> builder
@@ -209,53 +290,91 @@ public T sample() {
 	}
 
 	@Override
-	public Arbitrary<T> injectDuplicates(double duplicateProbability) {
-		return getArbitrary().injectDuplicates(duplicateProbability);
+	public synchronized Arbitrary<T> injectDuplicates(double duplicateProbability) {
+		try {
+			return getArbitrary().injectDuplicates(duplicateProbability);
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public Arbitrary<Tuple1<T>> tuple1() {
-		return getArbitrary().tuple1();
+	public synchronized Arbitrary<Tuple1<T>> tuple1() {
+		try {
+			return getArbitrary().tuple1();
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public Arbitrary<Tuple2<T, T>> tuple2() {
-		return getArbitrary().tuple2();
+	public synchronized Arbitrary<Tuple2<T, T>> tuple2() {
+		try {
+			return getArbitrary().tuple2();
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public Arbitrary<Tuple3<T, T, T>> tuple3() {
-		return getArbitrary().tuple3();
+	public synchronized Arbitrary<Tuple3<T, T, T>> tuple3() {
+		try {
+			return getArbitrary().tuple3();
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public Arbitrary<Tuple4<T, T, T, T>> tuple4() {
-		return getArbitrary().tuple4();
+	public synchronized Arbitrary<Tuple4<T, T, T, T>> tuple4() {
+		try {
+			return getArbitrary().tuple4();
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public Arbitrary<Tuple5<T, T, T, T, T>> tuple5() {
-		return getArbitrary().tuple5();
+	public synchronized Arbitrary<Tuple5<T, T, T, T, T>> tuple5() {
+		try {
+			return getArbitrary().tuple5();
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public Arbitrary<T> ignoreException(Class<? extends Throwable> exceptionType) {
-		return getArbitrary().ignoreException(exceptionType);
+	public synchronized Arbitrary<T> ignoreException(Class<? extends Throwable> exceptionType) {
+		try {
+			return getArbitrary().ignoreException(exceptionType);
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public Arbitrary<T> dontShrink() {
-		return getArbitrary().dontShrink();
+	public synchronized Arbitrary<T> dontShrink() {
+		try {
+			return getArbitrary().dontShrink();
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
 	@Override
-	public Arbitrary<T> edgeCases(Consumer<Config<T>> configurator) {
-		return getArbitrary().edgeCases(configurator);
+	public synchronized Arbitrary<T> edgeCases(Consumer<Config<T>> configurator) {
+		try {
+			return getArbitrary().edgeCases(configurator);
+		} finally {
+			this.arbitrary = null; // in order to getting new value whenever sampling, set arbitrary as null
+		}
 	}
 
+	@SuppressWarnings("unchecked")
 	private synchronized Arbitrary<T> getArbitrary() {
 		if (this.arbitrary == null) {
-			this.arbitrary = generateArbitrary.get();
+			this.arbitrary = generateArbitrary.get()
+				.filter((Predicate<T>)this.validateFilter(validOnly));
 		}
 		return this.arbitrary;
 	}
diff --git a/fixture-monkey/src/test/java/com/navercorp/fixturemonkey/test/FixtureMonkeyTest.java b/fixture-monkey/src/test/java/com/navercorp/fixturemonkey/test/FixtureMonkeyTest.java
index 5704b5061..a4623bf79 100644
--- a/fixture-monkey/src/test/java/com/navercorp/fixturemonkey/test/FixtureMonkeyTest.java
+++ b/fixture-monkey/src/test/java/com/navercorp/fixturemonkey/test/FixtureMonkeyTest.java
@@ -18,6 +18,7 @@
 
 package com.navercorp.fixturemonkey.test;
 
+import static java.util.stream.Collectors.toList;
 import static org.assertj.core.api.BDDAssertions.then;
 import static org.assertj.core.api.BDDAssertions.thenThrownBy;
 
@@ -42,7 +43,9 @@
 import org.junit.platform.commons.util.StringUtils;
 
 import net.jqwik.api.Arbitrary;
+import net.jqwik.api.Example;
 import net.jqwik.api.Property;
+import net.jqwik.api.TooManyFilterMissesException;
 
 import lombok.AllArgsConstructor;
 import lombok.Builder;
@@ -284,6 +287,48 @@ void giveMeOptional() {
 		then(actual).isNotNull();
 	}
 
+	@Property
+	void giveMeArbitraryThenSample() {
+		// given
+		Arbitrary<StringWithNotBlankWrapperClass> sut = this.sut.giveMeArbitrary(StringWithNotBlankWrapperClass.class);
+
+		// when
+		StringWithNotBlankWrapperClass actual = sut.sample();
+
+		then(actual.getValue()).isNotBlank();
+	}
+
+	@Property
+	void giveMeArbitraryThenSampleStream() {
+		// given
+		Arbitrary<StringWithNotBlankWrapperClass> sut = this.sut.giveMeArbitrary(StringWithNotBlankWrapperClass.class);
+
+		// when
+		List<StringWithNotBlankWrapperClass> actual = sut.sampleStream().limit(5).collect(toList());
+
+		actual.forEach(it -> then(it.getValue()).isNotBlank());
+	}
+
+	@Example
+	void giveMeBuilderInvalidThenSampleTooManyFilterMissesException() {
+		Arbitrary<StringWithNotBlankWrapperClass> sut = this.sut.giveMeBuilder(StringWithNotBlankWrapperClass.class)
+			.set("value", "")
+			.build();
+
+		thenThrownBy(sut::sample)
+			.isExactlyInstanceOf(TooManyFilterMissesException.class);
+	}
+
+	@Example
+	void giveMeBuilderInvalidThenSampleStreamTooManyFilterMissesException() {
+		Arbitrary<StringWithNotBlankWrapperClass> sut = this.sut.giveMeBuilder(StringWithNotBlankWrapperClass.class)
+			.set("value", "")
+			.build();
+
+		thenThrownBy(() -> sut.sampleStream().limit(5).collect(toList()))
+			.isExactlyInstanceOf(TooManyFilterMissesException.class);
+	}
+
 	@Property
 	void setAfterBuildNotAffected() {
 		// given