From 62b3ff8a769450d245573cd03878e6c45c9c9f46 Mon Sep 17 00:00:00 2001 From: Milad Naseri Date: Sun, 12 Jun 2016 18:32:26 -0700 Subject: [PATCH 01/12] chore(travis): revert back to container infrastructure --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 3f81f435..907ad5d9 100644 --- a/.travis.yml +++ b/.travis.yml @@ -11,7 +11,7 @@ after_success: - '[[ $TRAVIS_BRANCH == "master" && ( "x${TRAVIS_PULL_REQUEST}" == "xfalse" || "x${TRAVIS_PULL_REQUEST}" == "x" ) && ( "x$(echo $JAVA_HOME | grep -o 8)" == "x8" ) ]] && sudo apt-get install gnupg2' - '[[ $TRAVIS_BRANCH == "master" && ( "x${TRAVIS_PULL_REQUEST}" == "xfalse" || "x${TRAVIS_PULL_REQUEST}" == "x" ) && ( "x$(echo $JAVA_HOME | grep -o 8)" == "x8" ) ]] && bash ../deployment/deploy.sh eb1a6f34f056 ../deployment/key.asc.enc ../deployment/settings.xml' # SUDO should be set to `false` except when deploying to OSSRH to trigger container infrastructure -sudo: true +sudo: false env: global: - secure: DPkao3yJ4hhEsUOfs2VQJ8WCV3VdR3ToFiGB1l461PUstjaytTeXYK3bW2PmZqYJs6Hxxwyl8UHFvgBvWLb/yQV/dqyyJAV8XRb9UC37e4ddLoi8HE7NSGQIiXq0tySiMaOTyd2NtRTepfNAMEMDP746Nrox1giPEq1FPv+K98o= From c97bb914d78a5d19169cb8cd8a1398067a8a4e88 Mon Sep 17 00:00:00 2001 From: Paul Verest Date: Mon, 13 Jun 2016 16:56:41 +0800 Subject: [PATCH 02/12] ignore Eclipse IDE stuff ref #82 4d7cca273cc32e9c5750db5beeb9d4dad59ec1d3 --- .gitignore | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index b43dc7e2..76ed29c9 100644 --- a/.gitignore +++ b/.gitignore @@ -24,8 +24,13 @@ com_crashlytics_export_strings.xml crashlytics.properties crashlytics-build.properties +# Eclipse IDE stuff +.settings/ +.classpath +.project + # Maven Target target # Mac OS X junk -.DS_Store \ No newline at end of file +.DS_Store From cc28fbb4eaf1a8fa382cf9ec5e31098d80ee3bd9 Mon Sep 17 00:00:00 2001 From: Milad Naseri Date: Mon, 13 Jun 2016 13:18:47 -0700 Subject: [PATCH 03/12] feat(com.mmnaseri.utils.spring.data.dsl.factory): add `.configure()` method to the DSL to expose the configuration created thus far Closes #97 --- .../com/mmnaseri/utils/spring/data/dsl/factory/End.java | 7 +++++++ .../spring/data/dsl/factory/RepositoryFactoryBuilder.java | 7 ++++++- 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/factory/End.java b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/factory/End.java index 47476421..ae69e308 100644 --- a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/factory/End.java +++ b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/factory/End.java @@ -2,6 +2,7 @@ import com.mmnaseri.utils.spring.data.dsl.mock.KeyGeneration; import com.mmnaseri.utils.spring.data.proxy.RepositoryFactory; +import com.mmnaseri.utils.spring.data.proxy.RepositoryFactoryConfiguration; /** * Finalizes the DSL by providing a way to either choose to {@link #build() build} the factory or to @@ -20,4 +21,10 @@ public interface End extends KeyGeneration { */ RepositoryFactory build(); + /** + * @return the {@link RepositoryFactoryConfiguration repository factory configuration} instance that has + * been created as a result of method calls via this DSL + */ + RepositoryFactoryConfiguration configure(); + } diff --git a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/factory/RepositoryFactoryBuilder.java b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/factory/RepositoryFactoryBuilder.java index 0345f828..0cf0fd8f 100644 --- a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/factory/RepositoryFactoryBuilder.java +++ b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/factory/RepositoryFactoryBuilder.java @@ -245,7 +245,12 @@ public ResultAdaptersAnd and(ResultAdapter adapter) { @Override public RepositoryFactory build() { - return new DefaultRepositoryFactory(new ImmutableRepositoryFactoryConfiguration(metadataResolver, queryDescriptionExtractor, functionRegistry, dataStoreRegistry, resultAdapterContext, typeMappingContext, eventListenerContext, operationInvocationHandler)); + return new DefaultRepositoryFactory(configure()); + } + + @Override + public RepositoryFactoryConfiguration configure() { + return new ImmutableRepositoryFactoryConfiguration(metadataResolver, queryDescriptionExtractor, functionRegistry, dataStoreRegistry, resultAdapterContext, typeMappingContext, eventListenerContext, operationInvocationHandler); } @Override From df78de0b2d867e4c3222b620d89a358a1a2f2b9f Mon Sep 17 00:00:00 2001 From: Milad Naseri Date: Mon, 13 Jun 2016 13:42:37 -0700 Subject: [PATCH 04/12] chore(pom): upgrade `maven-javadoc-plugin` from `2.10.3` to `2.10.4` Closes #95 --- spring-data-mock/pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/spring-data-mock/pom.xml b/spring-data-mock/pom.xml index 85092a57..b80143e6 100644 --- a/spring-data-mock/pom.xml +++ b/spring-data-mock/pom.xml @@ -311,7 +311,7 @@ 1.3 1.6 - 2.10.3 + 2.10.4 3.0.0 2.8.2 1.6.7 From 4b9e515fad0a27afa718df441b9e848940b926eb Mon Sep 17 00:00:00 2001 From: Milad Naseri Date: Mon, 13 Jun 2016 13:51:01 -0700 Subject: [PATCH 05/12] chore(all): optimize imports Closes #96 --- .../spring/data/domain/impl/id/EntityIdPropertyResolverTest.java | 1 - 1 file changed, 1 deletion(-) diff --git a/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/domain/impl/id/EntityIdPropertyResolverTest.java b/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/domain/impl/id/EntityIdPropertyResolverTest.java index 79c580e1..3fdec271 100644 --- a/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/domain/impl/id/EntityIdPropertyResolverTest.java +++ b/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/domain/impl/id/EntityIdPropertyResolverTest.java @@ -1,6 +1,5 @@ package com.mmnaseri.utils.spring.data.domain.impl.id; -import com.mmnaseri.utils.spring.data.domain.IdPropertyResolver; import com.mmnaseri.utils.spring.data.error.NoIdPropertyException; import com.mmnaseri.utils.spring.data.error.PrimitiveIdTypeException; import com.mmnaseri.utils.spring.data.sample.models.*; From 74c88dd106d57e01528418e1941b9efff3a25d4b Mon Sep 17 00:00:00 2001 From: Milad Naseri Date: Mon, 13 Jun 2016 14:05:59 -0700 Subject: [PATCH 06/12] chore(pom): reorganize all POM files to follow conventions closes #92 --- spring-data-mock-build/pom.xml | 27 ++++--- spring-data-mock-sample-jpa/pom.xml | 96 +++++++++++++--------- spring-data-mock/pom.xml | 120 +++++++++++++++------------- 3 files changed, 135 insertions(+), 108 deletions(-) diff --git a/spring-data-mock-build/pom.xml b/spring-data-mock-build/pom.xml index 281fdff3..851e4e8b 100644 --- a/spring-data-mock-build/pom.xml +++ b/spring-data-mock-build/pom.xml @@ -27,11 +27,12 @@ com.mmnaseri.utils spring-data-mock-build 1.1.0 + pom + Spring Data Mock: Build Aggregator This is the build module that will aggregate all reactors for the spring-data-mock project https://mmnaseri.github.io/spring-data-mock - pom - + 2015 MIT @@ -51,12 +52,23 @@ + + ../spring-data-mock/ + ../spring-data-mock-sample-jpa + + scm:git:git@github.com:mmnaseri/spring-data-mock.git scm:git:git@github.com:mmnaseri/spring-data-mock.git git@github.com:mmnaseri/spring-data-mock.git + + UTF-8 + 3.5.1 + 1.7 + + @@ -71,15 +83,4 @@ - - ../spring-data-mock/ - ../spring-data-mock-sample-jpa - - - - UTF-8 - 3.5.1 - 1.7 - - diff --git a/spring-data-mock-sample-jpa/pom.xml b/spring-data-mock-sample-jpa/pom.xml index c8273cd3..b461d14b 100644 --- a/spring-data-mock-sample-jpa/pom.xml +++ b/spring-data-mock-sample-jpa/pom.xml @@ -7,36 +7,42 @@ com.mmnaseri.utils.sample spring-data-mock-sample-jpa 1.0 + Spring Data Mock: Samples (JPA) This module tries to demonstrate how Spring Data Mock could be used to test an application that is using Spring Data JPA. + 2016 + + + MIT + http://mit-license.org + + - - - - org.apache.maven.plugins - maven-compiler-plugin - ${maven-compiler-plugin.version} - - ${target-jdk.version} - ${target-jdk.version} - - - - org.codehaus.mojo - cobertura-maven-plugin - ${cobertura-maven-plugin.version} - - xml - 256m - - true - - target/reports - - - - + + + Milad Naseri + mmnaseri@programmer.net + http://www.mmnaseri.com + + designer + developer + + + + + + 1.12.1.RELEASE + 1.10.1.RELEASE + 1.0.2 + 1.1.2 + 6.9.6 + 1.3 + UTF-8 + 3.5.1 + 1.7 + 2.7 + @@ -74,17 +80,31 @@ - - 1.12.1.RELEASE - 1.10.1.RELEASE - 1.0.2 - 1.1.2 - 6.9.6 - 1.3 - UTF-8 - 3.5.1 - 1.7 - 2.7 - + + + + org.apache.maven.plugins + maven-compiler-plugin + ${maven-compiler-plugin.version} + + ${target-jdk.version} + ${target-jdk.version} + + + + org.codehaus.mojo + cobertura-maven-plugin + ${cobertura-maven-plugin.version} + + xml + 256m + + true + + target/reports + + + + \ No newline at end of file diff --git a/spring-data-mock/pom.xml b/spring-data-mock/pom.xml index b80143e6..0e9266b1 100644 --- a/spring-data-mock/pom.xml +++ b/spring-data-mock/pom.xml @@ -22,15 +22,17 @@ + 4.0.0 com.mmnaseri.utils spring-data-mock 1.1.2 + Spring Data Mock A framework for mocking Spring Data repositories https://mmnaseri.github.io/spring-data-mock - + 2014 MIT @@ -38,21 +40,6 @@ - - - - gemfire-repository - Gemfire Repository - http://dist.gemstone.com/maven/release - - - - gradle-repository - Gradle Repository - http://gradle.artifactoryonline.com/gradle/libs/ - - - Milad Naseri @@ -70,20 +57,38 @@ scm:git:git@github.com:mmnaseri/spring-data-mock.git git@github.com:mmnaseri/spring-data-mock.git + + Github + https://github.com/mmnaseri/spring-data-mock/issues + - - - - org.apache.maven.plugins - maven-compiler-plugin - ${maven-compiler-plugin.version} - - ${target-jdk.version} - ${target-jdk.version} - - - - + + + UTF-8 + 3.5.1 + 1.7 + + 1.2 + 2.9.4 + + 6.9.11 + 1.3 + + 1.6 + 2.10.4 + 3.0.0 + 2.8.2 + 1.6.7 + 2.7 + 4.2.0 + + 1.12.1.RELEASE + 1.8.1.RELEASE + 1.10.1.RELEASE + 4.1.2 + 3.2.2 + 1.0.2 + @@ -164,6 +169,35 @@ + + + + gemfire-repository + Gemfire Repository + http://dist.gemstone.com/maven/release + + + + gradle-repository + Gradle Repository + http://gradle.artifactoryonline.com/gradle/libs/ + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + ${maven-compiler-plugin.version} + + ${target-jdk.version} + ${target-jdk.version} + + + + + release @@ -298,32 +332,4 @@ - - - UTF-8 - 3.5.1 - 1.7 - - 1.2 - 2.9.4 - - 6.9.11 - 1.3 - - 1.6 - 2.10.4 - 3.0.0 - 2.8.2 - 1.6.7 - 2.7 - 4.2.0 - - 1.12.1.RELEASE - 1.8.1.RELEASE - 1.10.1.RELEASE - 4.1.2 - 3.2.2 - 1.0.2 - - \ No newline at end of file From a9d21c82eefcd1764ef00de7dd9efa01fab74df5 Mon Sep 17 00:00:00 2001 From: Milad Naseri Date: Tue, 14 Jun 2016 12:29:43 -0700 Subject: [PATCH 07/12] feat(com.mmnaseri.utils.spring.data.domain.imp.key): implement additional, more customizable key generators Closes #104 --- ...igurableSequentialIntegerKeyGenerator.java | 34 +++++++++++++++ ...onfigurableSequentialLongKeyGenerator.java | 35 ++++++++++++++++ .../data/dsl/mock/KeyGeneratorProvider.java | 2 + ...ableSequentialIntegerKeyGeneratorTest.java | 41 +++++++++++++++++++ ...gurableSequentialLongKeyGeneratorTest.java | 41 +++++++++++++++++++ 5 files changed, 153 insertions(+) create mode 100644 spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/domain/impl/key/ConfigurableSequentialIntegerKeyGenerator.java create mode 100644 spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/domain/impl/key/ConfigurableSequentialLongKeyGenerator.java create mode 100644 spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/domain/impl/key/ConfigurableSequentialIntegerKeyGeneratorTest.java create mode 100644 spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/domain/impl/key/ConfigurableSequentialLongKeyGeneratorTest.java diff --git a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/domain/impl/key/ConfigurableSequentialIntegerKeyGenerator.java b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/domain/impl/key/ConfigurableSequentialIntegerKeyGenerator.java new file mode 100644 index 00000000..55feab6d --- /dev/null +++ b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/domain/impl/key/ConfigurableSequentialIntegerKeyGenerator.java @@ -0,0 +1,34 @@ +package com.mmnaseri.utils.spring.data.domain.impl.key; + +import com.mmnaseri.utils.spring.data.domain.impl.AbstractRandomKeyGenerator; + +import java.util.concurrent.atomic.AtomicInteger; + +/** + * @author Milad Naseri (milad.naseri@cdk.com) + * @since 1.0 (6/14/16, 11:49 AM) + */ +public class ConfigurableSequentialIntegerKeyGenerator extends AbstractRandomKeyGenerator { + + private final AtomicInteger current; + private final int step; + + public ConfigurableSequentialIntegerKeyGenerator() { + this(1); + } + + public ConfigurableSequentialIntegerKeyGenerator(int initialValue) { + this(initialValue, 1); + } + + public ConfigurableSequentialIntegerKeyGenerator(int initialValue, int step) { + current = new AtomicInteger(initialValue); + this.step = step; + } + + @Override + protected Integer getNext() { + return current.getAndAdd(step); + } + +} diff --git a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/domain/impl/key/ConfigurableSequentialLongKeyGenerator.java b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/domain/impl/key/ConfigurableSequentialLongKeyGenerator.java new file mode 100644 index 00000000..cc4ffa1f --- /dev/null +++ b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/domain/impl/key/ConfigurableSequentialLongKeyGenerator.java @@ -0,0 +1,35 @@ +package com.mmnaseri.utils.spring.data.domain.impl.key; + +import com.mmnaseri.utils.spring.data.domain.impl.AbstractRandomKeyGenerator; + +import java.util.concurrent.atomic.AtomicLong; + +/** + * @author Milad Naseri (milad.naseri@cdk.com) + * @since 1.0 (6/14/16, 11:47 AM) + */ +public class ConfigurableSequentialLongKeyGenerator extends AbstractRandomKeyGenerator { + + private final AtomicLong current; + private final long step; + + public ConfigurableSequentialLongKeyGenerator() { + this(1L); + } + + + public ConfigurableSequentialLongKeyGenerator(long initialValue) { + this(initialValue, 1L); + } + + public ConfigurableSequentialLongKeyGenerator(long initialValue, long step) { + current = new AtomicLong(initialValue); + this.step = step; + } + + @Override + protected Long getNext() { + return current.getAndAdd(step); + } + +} diff --git a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/mock/KeyGeneratorProvider.java b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/mock/KeyGeneratorProvider.java index 1f1ff20f..9ea00e5a 100644 --- a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/mock/KeyGeneratorProvider.java +++ b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/mock/KeyGeneratorProvider.java @@ -44,6 +44,8 @@ private List> getKeyGeneratorTypes() { RandomLongKeyGenerator.class, SequentialIntegerKeyGenerator.class, SequentialLongKeyGenerator.class, + ConfigurableSequentialIntegerKeyGenerator.class, + ConfigurableSequentialLongKeyGenerator.class, UUIDKeyGenerator.class ); } diff --git a/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/domain/impl/key/ConfigurableSequentialIntegerKeyGeneratorTest.java b/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/domain/impl/key/ConfigurableSequentialIntegerKeyGeneratorTest.java new file mode 100644 index 00000000..2b269302 --- /dev/null +++ b/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/domain/impl/key/ConfigurableSequentialIntegerKeyGeneratorTest.java @@ -0,0 +1,41 @@ +package com.mmnaseri.utils.spring.data.domain.impl.key; + +import org.testng.annotations.Test; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.*; + +/** + * @author Milad Naseri (milad.naseri@cdk.com) + * @since 1.0 (6/14/16, 12:25 PM) + */ +public class ConfigurableSequentialIntegerKeyGeneratorTest { + + @Test + public void testKeyGenerationWithDefaultSettings() throws Exception { + final ConfigurableSequentialIntegerKeyGenerator generator = new ConfigurableSequentialIntegerKeyGenerator(); + assertThat(generator.getNext(), is(1)); + assertThat(generator.getNext(), is(2)); + assertThat(generator.getNext(), is(3)); + } + + @Test + public void testKeyGenerationWithDefaultStepAndCustomInitialValue() throws Exception { + final int initialValue = 100; + final ConfigurableSequentialIntegerKeyGenerator generator = new ConfigurableSequentialIntegerKeyGenerator(initialValue); + assertThat(generator.getNext(), is(initialValue)); + assertThat(generator.getNext(), is(initialValue + 1)); + assertThat(generator.getNext(), is(initialValue + 2)); + } + + @Test + public void testKeyGenerationWithCustomStepAndCustomInitialValue() throws Exception { + final int initialValue = 100; + final int step = 3; + final ConfigurableSequentialIntegerKeyGenerator generator = new ConfigurableSequentialIntegerKeyGenerator(initialValue, step); + assertThat(generator.getNext(), is(initialValue)); + assertThat(generator.getNext(), is(initialValue + step)); + assertThat(generator.getNext(), is(initialValue + step * 2)); + } + +} \ No newline at end of file diff --git a/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/domain/impl/key/ConfigurableSequentialLongKeyGeneratorTest.java b/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/domain/impl/key/ConfigurableSequentialLongKeyGeneratorTest.java new file mode 100644 index 00000000..c0eb47cc --- /dev/null +++ b/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/domain/impl/key/ConfigurableSequentialLongKeyGeneratorTest.java @@ -0,0 +1,41 @@ +package com.mmnaseri.utils.spring.data.domain.impl.key; + +import org.testng.annotations.Test; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.*; + +/** + * @author Milad Naseri (milad.naseri@cdk.com) + * @since 1.0 (6/14/16, 12:27 PM) + */ +public class ConfigurableSequentialLongKeyGeneratorTest { + + @Test + public void testKeyGenerationWithDefaultSettings() throws Exception { + final ConfigurableSequentialLongKeyGenerator generator = new ConfigurableSequentialLongKeyGenerator(); + assertThat(generator.getNext(), is(1L)); + assertThat(generator.getNext(), is(2L)); + assertThat(generator.getNext(), is(3L)); + } + + @Test + public void testKeyGenerationWithDefaultStepAndCustomInitialValue() throws Exception { + final long initialValue = 100L; + final ConfigurableSequentialLongKeyGenerator generator = new ConfigurableSequentialLongKeyGenerator(initialValue); + assertThat(generator.getNext(), is(initialValue)); + assertThat(generator.getNext(), is(initialValue + 1)); + assertThat(generator.getNext(), is(initialValue + 2)); + } + + @Test + public void testKeyGenerationWithCustomStepAndCustomInitialValue() throws Exception { + final long initialValue = 100L; + final long step = 3L; + final ConfigurableSequentialLongKeyGenerator generator = new ConfigurableSequentialLongKeyGenerator(initialValue, step); + assertThat(generator.getNext(), is(initialValue)); + assertThat(generator.getNext(), is(initialValue + step)); + assertThat(generator.getNext(), is(initialValue + step * 2)); + } + +} \ No newline at end of file From c847259bece8013f7671b302599cd5a0c90aaf02 Mon Sep 17 00:00:00 2001 From: Milad Naseri Date: Tue, 14 Jun 2016 12:40:44 -0700 Subject: [PATCH 08/12] feat(com.mmnaseri.utils.spring.data.domain.imp.key): implement additional, more customizable key generators Closes #104 --- ...ableSequentialIntegerKeyGeneratorTest.java | 27 ++++++++++--------- ...gurableSequentialLongKeyGeneratorTest.java | 27 ++++++++++--------- 2 files changed, 28 insertions(+), 26 deletions(-) diff --git a/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/domain/impl/key/ConfigurableSequentialIntegerKeyGeneratorTest.java b/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/domain/impl/key/ConfigurableSequentialIntegerKeyGeneratorTest.java index 2b269302..e0d29ba3 100644 --- a/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/domain/impl/key/ConfigurableSequentialIntegerKeyGeneratorTest.java +++ b/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/domain/impl/key/ConfigurableSequentialIntegerKeyGeneratorTest.java @@ -1,9 +1,10 @@ package com.mmnaseri.utils.spring.data.domain.impl.key; +import com.mmnaseri.utils.spring.data.domain.KeyGenerator; import org.testng.annotations.Test; import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.*; +import static org.hamcrest.Matchers.is; /** * @author Milad Naseri (milad.naseri@cdk.com) @@ -13,29 +14,29 @@ public class ConfigurableSequentialIntegerKeyGeneratorTest { @Test public void testKeyGenerationWithDefaultSettings() throws Exception { - final ConfigurableSequentialIntegerKeyGenerator generator = new ConfigurableSequentialIntegerKeyGenerator(); - assertThat(generator.getNext(), is(1)); - assertThat(generator.getNext(), is(2)); - assertThat(generator.getNext(), is(3)); + final KeyGenerator generator = new ConfigurableSequentialIntegerKeyGenerator(); + assertThat(generator.generate(), is(1)); + assertThat(generator.generate(), is(2)); + assertThat(generator.generate(), is(3)); } @Test public void testKeyGenerationWithDefaultStepAndCustomInitialValue() throws Exception { final int initialValue = 100; - final ConfigurableSequentialIntegerKeyGenerator generator = new ConfigurableSequentialIntegerKeyGenerator(initialValue); - assertThat(generator.getNext(), is(initialValue)); - assertThat(generator.getNext(), is(initialValue + 1)); - assertThat(generator.getNext(), is(initialValue + 2)); + final KeyGenerator generator = new ConfigurableSequentialIntegerKeyGenerator(initialValue); + assertThat(generator.generate(), is(initialValue)); + assertThat(generator.generate(), is(initialValue + 1)); + assertThat(generator.generate(), is(initialValue + 2)); } @Test public void testKeyGenerationWithCustomStepAndCustomInitialValue() throws Exception { final int initialValue = 100; final int step = 3; - final ConfigurableSequentialIntegerKeyGenerator generator = new ConfigurableSequentialIntegerKeyGenerator(initialValue, step); - assertThat(generator.getNext(), is(initialValue)); - assertThat(generator.getNext(), is(initialValue + step)); - assertThat(generator.getNext(), is(initialValue + step * 2)); + final KeyGenerator generator = new ConfigurableSequentialIntegerKeyGenerator(initialValue, step); + assertThat(generator.generate(), is(initialValue)); + assertThat(generator.generate(), is(initialValue + step)); + assertThat(generator.generate(), is(initialValue + step * 2)); } } \ No newline at end of file diff --git a/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/domain/impl/key/ConfigurableSequentialLongKeyGeneratorTest.java b/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/domain/impl/key/ConfigurableSequentialLongKeyGeneratorTest.java index c0eb47cc..367e9e45 100644 --- a/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/domain/impl/key/ConfigurableSequentialLongKeyGeneratorTest.java +++ b/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/domain/impl/key/ConfigurableSequentialLongKeyGeneratorTest.java @@ -1,9 +1,10 @@ package com.mmnaseri.utils.spring.data.domain.impl.key; +import com.mmnaseri.utils.spring.data.domain.KeyGenerator; import org.testng.annotations.Test; import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.*; +import static org.hamcrest.Matchers.is; /** * @author Milad Naseri (milad.naseri@cdk.com) @@ -13,29 +14,29 @@ public class ConfigurableSequentialLongKeyGeneratorTest { @Test public void testKeyGenerationWithDefaultSettings() throws Exception { - final ConfigurableSequentialLongKeyGenerator generator = new ConfigurableSequentialLongKeyGenerator(); - assertThat(generator.getNext(), is(1L)); - assertThat(generator.getNext(), is(2L)); - assertThat(generator.getNext(), is(3L)); + final KeyGenerator generator = new ConfigurableSequentialLongKeyGenerator(); + assertThat(generator.generate(), is(1L)); + assertThat(generator.generate(), is(2L)); + assertThat(generator.generate(), is(3L)); } @Test public void testKeyGenerationWithDefaultStepAndCustomInitialValue() throws Exception { final long initialValue = 100L; - final ConfigurableSequentialLongKeyGenerator generator = new ConfigurableSequentialLongKeyGenerator(initialValue); - assertThat(generator.getNext(), is(initialValue)); - assertThat(generator.getNext(), is(initialValue + 1)); - assertThat(generator.getNext(), is(initialValue + 2)); + final KeyGenerator generator = new ConfigurableSequentialLongKeyGenerator(initialValue); + assertThat(generator.generate(), is(initialValue)); + assertThat(generator.generate(), is(initialValue + 1)); + assertThat(generator.generate(), is(initialValue + 2)); } @Test public void testKeyGenerationWithCustomStepAndCustomInitialValue() throws Exception { final long initialValue = 100L; final long step = 3L; - final ConfigurableSequentialLongKeyGenerator generator = new ConfigurableSequentialLongKeyGenerator(initialValue, step); - assertThat(generator.getNext(), is(initialValue)); - assertThat(generator.getNext(), is(initialValue + step)); - assertThat(generator.getNext(), is(initialValue + step * 2)); + final KeyGenerator generator = new ConfigurableSequentialLongKeyGenerator(initialValue, step); + assertThat(generator.generate(), is(initialValue)); + assertThat(generator.generate(), is(initialValue + step)); + assertThat(generator.generate(), is(initialValue + step * 2)); } } \ No newline at end of file From 14767ccc2d665446dc4c4155f7623a62722ba951 Mon Sep 17 00:00:00 2001 From: Milad Naseri Date: Tue, 14 Jun 2016 23:03:33 -0700 Subject: [PATCH 09/12] feat(com.mmnaseri.utils.spring.data.*): add support for specifying a fallback key generator at the configuration level Closes #93 --- .../domain/impl/key/NoOpKeyGenerator.java | 20 ++++++++ .../dsl/factory/FallbackKeyGenerator.java | 21 +++++++++ .../data/dsl/factory/OperationHandlers.java | 4 +- .../dsl/factory/RepositoryFactoryBuilder.java | 39 +++++++++------- .../data/dsl/mock/RepositoryMockBuilder.java | 40 ++++++---------- .../spring/data/proxy/RepositoryFactory.java | 4 +- .../proxy/RepositoryFactoryConfiguration.java | 6 +++ .../proxy/impl/DefaultRepositoryFactory.java | 10 ++++ ...DefaultRepositoryFactoryConfiguration.java | 32 +++++++++++++ ...mutableRepositoryFactoryConfiguration.java | 12 ++++- .../factory/RepositoryFactoryBuilderTest.java | 22 ++++++--- .../dsl/mock/RepositoryMockBuilderTest.java | 18 +++++++- .../impl/DefaultRepositoryFactoryTest.java | 46 +++++++++++++++++-- .../RepositoryClearerMapping.java | 4 +- 14 files changed, 216 insertions(+), 62 deletions(-) create mode 100644 spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/domain/impl/key/NoOpKeyGenerator.java create mode 100644 spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/factory/FallbackKeyGenerator.java diff --git a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/domain/impl/key/NoOpKeyGenerator.java b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/domain/impl/key/NoOpKeyGenerator.java new file mode 100644 index 00000000..0a8e5dc9 --- /dev/null +++ b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/domain/impl/key/NoOpKeyGenerator.java @@ -0,0 +1,20 @@ +package com.mmnaseri.utils.spring.data.domain.impl.key; + +import com.mmnaseri.utils.spring.data.domain.KeyGenerator; + +import java.io.Serializable; + +/** + * This is a key generator that should be used to indicate that we do not want automatic key generation. + * + * @author Milad Naseri (milad.naseri@cdk.com) + * @since 1.0 (6/14/16, 12:51 PM) + */ +public class NoOpKeyGenerator implements KeyGenerator { + + @Override + public S generate() { + return null; + } + +} diff --git a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/factory/FallbackKeyGenerator.java b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/factory/FallbackKeyGenerator.java new file mode 100644 index 00000000..dff78e04 --- /dev/null +++ b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/factory/FallbackKeyGenerator.java @@ -0,0 +1,21 @@ +package com.mmnaseri.utils.spring.data.dsl.factory; + +import com.mmnaseri.utils.spring.data.domain.KeyGenerator; + +import java.io.Serializable; + +/** + * @author Milad Naseri (milad.naseri@cdk.com) + * @since 1.0 (6/14/16, 10:25 PM) + */ +public interface FallbackKeyGenerator extends EventListener { + + /** + * Sets up a default key generator that would be used as a fallback if no key generation scheme is specified for the + * repository + * @param keyGenerator the key generator to be used + * @return the rest of the configuration + */ + EventListener withDefaultKeyGenerator(KeyGenerator keyGenerator); + +} diff --git a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/factory/OperationHandlers.java b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/factory/OperationHandlers.java index aeb69371..fba32608 100644 --- a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/factory/OperationHandlers.java +++ b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/factory/OperationHandlers.java @@ -10,14 +10,14 @@ * @since 1.0 (4/8/16) */ @SuppressWarnings("WeakerAccess") -public interface OperationHandlers extends EventListener { +public interface OperationHandlers extends FallbackKeyGenerator { /** * Sets the invocation handler used for handling non-data-related operations * @param invocationHandler the invocation handler * @return the rest of the configuration */ - EventListener withOperationHandlers(NonDataOperationInvocationHandler invocationHandler); + FallbackKeyGenerator withOperationHandlers(NonDataOperationInvocationHandler invocationHandler); /** * Registers an operation handler diff --git a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/factory/RepositoryFactoryBuilder.java b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/factory/RepositoryFactoryBuilder.java index 0cf0fd8f..fa7e8d9e 100644 --- a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/factory/RepositoryFactoryBuilder.java +++ b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/factory/RepositoryFactoryBuilder.java @@ -33,7 +33,6 @@ public class RepositoryFactoryBuilder implements Start, DataFunctionsAnd, DataStoresAnd, EventListenerAnd, MappingContextAnd, OperatorsAnd, ResultAdaptersAnd, OperationHandlersAnd { private static RepositoryFactory DEFAULT_FACTORY; - private static RepositoryFactoryConfiguration DEFAULT_FACTORY_CONFIGURATION; public static final String DEFAULT_USER = "User"; private RepositoryMetadataResolver metadataResolver; private MethodQueryDescriptionExtractor queryDescriptionExtractor; @@ -43,6 +42,7 @@ public class RepositoryFactoryBuilder implements Start, DataFunctionsAnd, DataSt private TypeMappingContext typeMappingContext; private DataStoreEventListenerContext eventListenerContext; private NonDataOperationInvocationHandler operationInvocationHandler; + private KeyGenerator defaultKeyGenerator; /** * Starting point for writing code in the builder's DSL @@ -57,20 +57,17 @@ public static Start builder() { * @return the default configuration (always the same instance) */ public static RepositoryFactoryConfiguration defaultConfiguration() { - if (DEFAULT_FACTORY_CONFIGURATION == null) { - final RepositoryFactoryBuilder builder = (RepositoryFactoryBuilder) builder(); - DEFAULT_FACTORY_CONFIGURATION = new ImmutableRepositoryFactoryConfiguration( - builder.metadataResolver, - builder.queryDescriptionExtractor, - builder.functionRegistry, - builder.dataStoreRegistry, - builder.resultAdapterContext, - builder.typeMappingContext, - builder.eventListenerContext, - builder.operationInvocationHandler - ); - } - return DEFAULT_FACTORY_CONFIGURATION; + final RepositoryFactoryBuilder builder = (RepositoryFactoryBuilder) builder(); + return new ImmutableRepositoryFactoryConfiguration( + builder.metadataResolver, + builder.queryDescriptionExtractor, + builder.functionRegistry, + builder.dataStoreRegistry, + builder.resultAdapterContext, + builder.typeMappingContext, + builder.eventListenerContext, + builder.operationInvocationHandler, + builder.defaultKeyGenerator); } /** @@ -92,6 +89,8 @@ private RepositoryFactoryBuilder() { typeMappingContext = new DefaultTypeMappingContext(); eventListenerContext = new DefaultDataStoreEventListenerContext(); operationInvocationHandler = new NonDataOperationInvocationHandler(); + //by default, we do not want any key generator, unless one is specified + defaultKeyGenerator = null; } @Override @@ -168,7 +167,7 @@ public MappingContextAnd honoringImplementation(Class superType, Class imp @Override - public EventListener withOperationHandlers(NonDataOperationInvocationHandler invocationHandler) { + public FallbackKeyGenerator withOperationHandlers(NonDataOperationInvocationHandler invocationHandler) { operationInvocationHandler = invocationHandler; return this; } @@ -219,6 +218,12 @@ public OperationHandlersAnd and(NonDataOperationHandler handler) { return this; } + @Override + public EventListener withDefaultKeyGenerator(KeyGenerator keyGenerator) { + defaultKeyGenerator = keyGenerator; + return this; + } + @Override public EventListenerAnd and(DataStoreEventListener listener) { eventListenerContext.register(listener); @@ -250,7 +255,7 @@ public RepositoryFactory build() { @Override public RepositoryFactoryConfiguration configure() { - return new ImmutableRepositoryFactoryConfiguration(metadataResolver, queryDescriptionExtractor, functionRegistry, dataStoreRegistry, resultAdapterContext, typeMappingContext, eventListenerContext, operationInvocationHandler); + return new ImmutableRepositoryFactoryConfiguration(metadataResolver, queryDescriptionExtractor, functionRegistry, dataStoreRegistry, resultAdapterContext, typeMappingContext, eventListenerContext, operationInvocationHandler, defaultKeyGenerator); } @Override diff --git a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/mock/RepositoryMockBuilder.java b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/mock/RepositoryMockBuilder.java index ed2957a3..49db0f83 100644 --- a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/mock/RepositoryMockBuilder.java +++ b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/mock/RepositoryMockBuilder.java @@ -2,6 +2,7 @@ import com.mmnaseri.utils.spring.data.domain.KeyGenerator; import com.mmnaseri.utils.spring.data.domain.RepositoryMetadata; +import com.mmnaseri.utils.spring.data.domain.impl.key.NoOpKeyGenerator; import com.mmnaseri.utils.spring.data.dsl.factory.RepositoryFactoryBuilder; import com.mmnaseri.utils.spring.data.error.MockBuilderException; import com.mmnaseri.utils.spring.data.proxy.RepositoryFactory; @@ -20,7 +21,6 @@ */ public class RepositoryMockBuilder implements Start, ImplementationAnd, KeyGeneration { - private static final KeyGenerator NOOP = new NoOpKeyGenerator<>(); private final RepositoryFactory factory; private final List> implementations; private final KeyGenerator keyGenerator; @@ -71,7 +71,7 @@ public > Implementation genera @Override public Implementation withoutGeneratingKeys() { - return new RepositoryMockBuilder(factory, implementations, NOOP); + return new RepositoryMockBuilder(factory, implementations, new NoOpKeyGenerator<>()); } private KeyGenerator createKeyGenerator(Class generatorType) { @@ -93,31 +93,21 @@ public E mock(Class repositoryInterface) { repositoryFactory = this.factory; } if (keyGenerator == null) { - final KeyGeneratorProvider generatorProvider = new KeyGeneratorProvider(); - final RepositoryMetadata metadata = repositoryFactory.getConfiguration().getRepositoryMetadataResolver().resolve(repositoryInterface); - final Class identifierType = metadata.getIdentifierType(); - final Class> keyGeneratorType = generatorProvider.getKeyGenerator(identifierType); - final KeyGenerator keyGenerator = createKeyGenerator(keyGeneratorType); - return generateKeysUsing(keyGenerator).mock(repositoryInterface); + final RepositoryFactoryConfiguration configuration = repositoryFactory.getConfiguration(); + final KeyGenerator evaluatedKeyGenerator; + if (configuration.getDefaultKeyGenerator() != null) { + evaluatedKeyGenerator = configuration.getDefaultKeyGenerator(); + } else { + final KeyGeneratorProvider generatorProvider = new KeyGeneratorProvider(); + final RepositoryMetadata metadata = configuration.getRepositoryMetadataResolver().resolve(repositoryInterface); + final Class identifierType = metadata.getIdentifierType(); + final Class> keyGeneratorType = generatorProvider.getKeyGenerator(identifierType); + evaluatedKeyGenerator = createKeyGenerator(keyGeneratorType); + } + return generateKeysUsing(evaluatedKeyGenerator).mock(repositoryInterface); } else { - return repositoryFactory.getInstance(NOOP.equals(keyGenerator) ? null : keyGenerator, repositoryInterface, implementations.toArray(new Class[implementations.size()])); + return repositoryFactory.getInstance(keyGenerator, repositoryInterface, implementations.toArray(new Class[implementations.size()])); } } - /** - * This class is used to indicate that we don't want key generation. Whenever the singleton instance - * {@link #NOOP} is used for key generation, the builder will set the underlying key generator to - * {@literal null}, thus signifying to the various implementing classes that no key generator has been - * provided - * @param the type of the keys this class generates - */ - public static class NoOpKeyGenerator implements KeyGenerator { - - @Override - public S generate() { - return null; - } - - } - } diff --git a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/proxy/RepositoryFactory.java b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/proxy/RepositoryFactory.java index 1971a068..f84a43bd 100644 --- a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/proxy/RepositoryFactory.java +++ b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/proxy/RepositoryFactory.java @@ -20,8 +20,8 @@ public interface RepositoryFactory { * Creates an instance of the repository as per the provided configuration. * * @param keyGenerator the key generator to use when inserting items (if auto generation is required). - * You can specify a {@literal null} key generator to signify that while inserting - * items, we don't need key generation. + * You can specify a {@literal null} key generator to signify that {@link RepositoryFactoryConfiguration#getDefaultKeyGenerator() + * the fallback key generator} should be used when generating keys. * @param repositoryInterface the repository interface which we want to mock * @param implementations all the concrete classes that can be used to figure out method mappings * @param the type of the interface diff --git a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/proxy/RepositoryFactoryConfiguration.java b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/proxy/RepositoryFactoryConfiguration.java index 0b54309d..835e5c91 100644 --- a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/proxy/RepositoryFactoryConfiguration.java +++ b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/proxy/RepositoryFactoryConfiguration.java @@ -1,5 +1,6 @@ package com.mmnaseri.utils.spring.data.proxy; +import com.mmnaseri.utils.spring.data.domain.KeyGenerator; import com.mmnaseri.utils.spring.data.domain.RepositoryMetadataResolver; import com.mmnaseri.utils.spring.data.domain.impl.MethodQueryDescriptionExtractor; import com.mmnaseri.utils.spring.data.proxy.impl.NonDataOperationInvocationHandler; @@ -55,4 +56,9 @@ public interface RepositoryFactoryConfiguration { */ NonDataOperationInvocationHandler getOperationInvocationHandler(); + /** + * @return the default key generator that should be used as a fallback when no key generator is specified + */ + KeyGenerator getDefaultKeyGenerator(); + } diff --git a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/proxy/impl/DefaultRepositoryFactory.java b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/proxy/impl/DefaultRepositoryFactory.java index 3d36bf30..9f9edbf4 100644 --- a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/proxy/impl/DefaultRepositoryFactory.java +++ b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/proxy/impl/DefaultRepositoryFactory.java @@ -2,6 +2,7 @@ import com.mmnaseri.utils.spring.data.domain.*; import com.mmnaseri.utils.spring.data.domain.impl.MethodQueryDescriptionExtractor; +import com.mmnaseri.utils.spring.data.domain.impl.key.NoOpKeyGenerator; import com.mmnaseri.utils.spring.data.proxy.*; import com.mmnaseri.utils.spring.data.proxy.impl.resolvers.DefaultDataOperationResolver; import com.mmnaseri.utils.spring.data.query.DataFunctionRegistry; @@ -57,6 +58,15 @@ public DefaultRepositoryFactory(RepositoryFactoryConfiguration configuration) { @Override public E getInstance(KeyGenerator keyGenerator, Class repositoryInterface, Class... implementations) { + if (keyGenerator == null) { + if (configuration.getDefaultKeyGenerator() != null) { + //if no key generator is passed and there is a default key generator specified, we fall back to that + keyGenerator = configuration.getDefaultKeyGenerator(); + } else { + //otherwise, let's assume that not key generation is required + keyGenerator = new NoOpKeyGenerator<>(); + } + } log.info("We are going to create a proxy instance of type " + repositoryInterface + " using key generator " + keyGenerator + " and binding the implementations to " + Arrays.toString(implementations)); //figure out the repository metadata log.info("Resolving repository metadata for " + repositoryInterface); diff --git a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/proxy/impl/DefaultRepositoryFactoryConfiguration.java b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/proxy/impl/DefaultRepositoryFactoryConfiguration.java index d75c6321..933f9f13 100644 --- a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/proxy/impl/DefaultRepositoryFactoryConfiguration.java +++ b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/proxy/impl/DefaultRepositoryFactoryConfiguration.java @@ -1,5 +1,6 @@ package com.mmnaseri.utils.spring.data.proxy.impl; +import com.mmnaseri.utils.spring.data.domain.KeyGenerator; import com.mmnaseri.utils.spring.data.domain.RepositoryMetadataResolver; import com.mmnaseri.utils.spring.data.domain.impl.MethodQueryDescriptionExtractor; import com.mmnaseri.utils.spring.data.proxy.RepositoryFactoryConfiguration; @@ -25,6 +26,28 @@ public class DefaultRepositoryFactoryConfiguration implements RepositoryFactoryC private TypeMappingContext typeMappingContext; private DataStoreEventListenerContext eventListenerContext; private NonDataOperationInvocationHandler operationInvocationHandler; + private KeyGenerator defaultKeyGenerator; + + public DefaultRepositoryFactoryConfiguration() { + } + + public DefaultRepositoryFactoryConfiguration(RepositoryFactoryConfiguration configuration) { + this(configuration.getRepositoryMetadataResolver(), configuration.getDescriptionExtractor(), configuration.getFunctionRegistry(), configuration.getDataStoreRegistry(), + configuration.getResultAdapterContext(), configuration.getTypeMappingContext(), configuration.getEventListenerContext(), + configuration.getOperationInvocationHandler(), configuration.getDefaultKeyGenerator()); + } + + public DefaultRepositoryFactoryConfiguration(RepositoryMetadataResolver repositoryMetadataResolver, MethodQueryDescriptionExtractor descriptionExtractor, DataFunctionRegistry functionRegistry, DataStoreRegistry dataStoreRegistry, ResultAdapterContext resultAdapterContext, TypeMappingContext typeMappingContext, DataStoreEventListenerContext eventListenerContext, NonDataOperationInvocationHandler operationInvocationHandler, KeyGenerator defaultKeyGenerator) { + this.repositoryMetadataResolver = repositoryMetadataResolver; + this.descriptionExtractor = descriptionExtractor; + this.functionRegistry = functionRegistry; + this.dataStoreRegistry = dataStoreRegistry; + this.resultAdapterContext = resultAdapterContext; + this.typeMappingContext = typeMappingContext; + this.eventListenerContext = eventListenerContext; + this.operationInvocationHandler = operationInvocationHandler; + this.defaultKeyGenerator = defaultKeyGenerator; + } @Override public RepositoryMetadataResolver getRepositoryMetadataResolver() { @@ -98,4 +121,13 @@ public void setOperationInvocationHandler(NonDataOperationInvocationHandler oper this.operationInvocationHandler = operationInvocationHandler; } + @Override + public KeyGenerator getDefaultKeyGenerator() { + return defaultKeyGenerator; + } + + public void setDefaultKeyGenerator(KeyGenerator defaultKeyGenerator) { + this.defaultKeyGenerator = defaultKeyGenerator; + } + } diff --git a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/proxy/impl/ImmutableRepositoryFactoryConfiguration.java b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/proxy/impl/ImmutableRepositoryFactoryConfiguration.java index 2d723b2b..72fe0929 100644 --- a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/proxy/impl/ImmutableRepositoryFactoryConfiguration.java +++ b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/proxy/impl/ImmutableRepositoryFactoryConfiguration.java @@ -1,5 +1,6 @@ package com.mmnaseri.utils.spring.data.proxy.impl; +import com.mmnaseri.utils.spring.data.domain.KeyGenerator; import com.mmnaseri.utils.spring.data.domain.RepositoryMetadataResolver; import com.mmnaseri.utils.spring.data.domain.impl.MethodQueryDescriptionExtractor; import com.mmnaseri.utils.spring.data.proxy.RepositoryFactoryConfiguration; @@ -27,14 +28,15 @@ public class ImmutableRepositoryFactoryConfiguration implements RepositoryFactor private final TypeMappingContext typeMappingContext; private final DataStoreEventListenerContext eventListenerContext; private final NonDataOperationInvocationHandler operationInvocationHandler; + private final KeyGenerator keyGenerator; public ImmutableRepositoryFactoryConfiguration(RepositoryFactoryConfiguration configuration) { this(configuration.getRepositoryMetadataResolver(), configuration.getDescriptionExtractor(), configuration.getFunctionRegistry(), configuration.getDataStoreRegistry(), configuration.getResultAdapterContext(), configuration.getTypeMappingContext(), - configuration.getEventListenerContext(), configuration.getOperationInvocationHandler()); + configuration.getEventListenerContext(), configuration.getOperationInvocationHandler(), configuration.getDefaultKeyGenerator()); } - public ImmutableRepositoryFactoryConfiguration(RepositoryMetadataResolver metadataResolver, MethodQueryDescriptionExtractor queryDescriptionExtractor, DataFunctionRegistry functionRegistry, DataStoreRegistry dataStoreRegistry, ResultAdapterContext resultAdapterContext, TypeMappingContext typeMappingContext, DataStoreEventListenerContext eventListenerContext, NonDataOperationInvocationHandler operationInvocationHandler) { + public ImmutableRepositoryFactoryConfiguration(RepositoryMetadataResolver metadataResolver, MethodQueryDescriptionExtractor queryDescriptionExtractor, DataFunctionRegistry functionRegistry, DataStoreRegistry dataStoreRegistry, ResultAdapterContext resultAdapterContext, TypeMappingContext typeMappingContext, DataStoreEventListenerContext eventListenerContext, NonDataOperationInvocationHandler operationInvocationHandler, KeyGenerator keyGenerator) { this.metadataResolver = metadataResolver; this.queryDescriptionExtractor = queryDescriptionExtractor; this.functionRegistry = functionRegistry; @@ -43,6 +45,7 @@ public ImmutableRepositoryFactoryConfiguration(RepositoryMetadataResolver metada this.typeMappingContext = typeMappingContext; this.eventListenerContext = eventListenerContext; this.operationInvocationHandler = operationInvocationHandler; + this.keyGenerator = keyGenerator; } @Override @@ -85,4 +88,9 @@ public NonDataOperationInvocationHandler getOperationInvocationHandler() { return operationInvocationHandler; } + @Override + public KeyGenerator getDefaultKeyGenerator() { + return keyGenerator; + } + } diff --git a/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/dsl/factory/RepositoryFactoryBuilderTest.java b/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/dsl/factory/RepositoryFactoryBuilderTest.java index 536eb31c..2672f055 100644 --- a/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/dsl/factory/RepositoryFactoryBuilderTest.java +++ b/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/dsl/factory/RepositoryFactoryBuilderTest.java @@ -8,7 +8,8 @@ import com.mmnaseri.utils.spring.data.domain.impl.DefaultRepositoryMetadataResolver; import com.mmnaseri.utils.spring.data.domain.impl.ImmutableOperator; import com.mmnaseri.utils.spring.data.domain.impl.MethodQueryDescriptionExtractor; -import com.mmnaseri.utils.spring.data.dsl.mock.RepositoryMockBuilder; +import com.mmnaseri.utils.spring.data.domain.impl.key.NoOpKeyGenerator; +import com.mmnaseri.utils.spring.data.domain.impl.key.UUIDKeyGenerator; import com.mmnaseri.utils.spring.data.proxy.RepositoryFactory; import com.mmnaseri.utils.spring.data.proxy.RepositoryFactoryConfiguration; import com.mmnaseri.utils.spring.data.proxy.ResultAdapterContext; @@ -57,14 +58,12 @@ public void testDefaultConfiguration() throws Exception { assertThat(configuration.getFunctionRegistry(), is(notNullValue())); assertThat(configuration.getEventListenerContext(), is(notNullValue())); assertThat(configuration.getDescriptionExtractor(), is(notNullValue())); - assertThat(RepositoryFactoryBuilder.defaultConfiguration(), is(RepositoryFactoryBuilder.defaultConfiguration())); } @Test public void testDefaultFactory() throws Exception { final RepositoryFactory factory = RepositoryFactoryBuilder.defaultFactory(); assertThat(factory, is(notNullValue())); - assertThat(factory.getConfiguration(), is(RepositoryFactoryBuilder.defaultConfiguration())); assertThat(factory, is(RepositoryFactoryBuilder.defaultFactory())); } @@ -88,6 +87,14 @@ public void testUsingCustomQueryDescriptor() throws Exception { assertThat(factory.getConfiguration().getDescriptionExtractor(), is(queryDescriptionExtractor)); } + @Test + public void testSpecifyingDefaultKeyGenerator() throws Exception { + final UUIDKeyGenerator generator = new UUIDKeyGenerator(); + final RepositoryFactoryConfiguration configuration = RepositoryFactoryBuilder.builder().withDefaultKeyGenerator(generator).configure(); + assertThat(configuration.getDefaultKeyGenerator(), is(notNullValue())); + assertThat(configuration.getDefaultKeyGenerator(), is((Object) generator)); + } + @Test public void testUsingCustomOperatorContext() throws Exception { final DefaultOperatorContext operatorContext = new DefaultOperatorContext(); @@ -302,12 +309,13 @@ public void testMockingUsingCustomImplementation() throws Exception { public void testMockingWithoutGeneratingKeys() throws Exception { final ConfiguredSimplePersonRepository repository = RepositoryFactoryBuilder.builder().withoutGeneratingKeys().usingImplementation(ConfiguredMapping.class).mock(ConfiguredSimplePersonRepository.class); assertThat(repository.getRepositoryConfiguration(), is(notNullValue())); - assertThat(repository.getRepositoryConfiguration().getKeyGenerator(), is(nullValue())); + assertThat(repository.getRepositoryConfiguration().getKeyGenerator(), is(notNullValue())); + assertThat(repository.getRepositoryConfiguration().getKeyGenerator(), is(instanceOf(NoOpKeyGenerator.class))); } @Test public void testMockingWithCustomKeyGeneration() throws Exception { - final RepositoryMockBuilder.NoOpKeyGenerator keyGenerator = new RepositoryMockBuilder.NoOpKeyGenerator<>(); + final NoOpKeyGenerator keyGenerator = new NoOpKeyGenerator<>(); final ConfiguredSimplePersonRepository repository = RepositoryFactoryBuilder.builder().generateKeysUsing(keyGenerator).usingImplementation(ConfiguredMapping.class).mock(ConfiguredSimplePersonRepository.class); assertThat(repository.getRepositoryConfiguration(), is(notNullValue())); assertThat(repository.getRepositoryConfiguration().getKeyGenerator(), is(notNullValue())); @@ -317,10 +325,10 @@ public void testMockingWithCustomKeyGeneration() throws Exception { @Test public void testMockingWithCustomKeyGenerationByType() throws Exception { //noinspection unchecked - final ConfiguredSimplePersonRepository repository = RepositoryFactoryBuilder.builder().generateKeysUsing(RepositoryMockBuilder.NoOpKeyGenerator.class).usingImplementation(ConfiguredMapping.class).mock(ConfiguredSimplePersonRepository.class); + final ConfiguredSimplePersonRepository repository = RepositoryFactoryBuilder.builder().generateKeysUsing(NoOpKeyGenerator.class).usingImplementation(ConfiguredMapping.class).mock(ConfiguredSimplePersonRepository.class); assertThat(repository.getRepositoryConfiguration(), is(notNullValue())); assertThat(repository.getRepositoryConfiguration().getKeyGenerator(), is(notNullValue())); - assertThat(repository.getRepositoryConfiguration().getKeyGenerator(), is(instanceOf(RepositoryMockBuilder.NoOpKeyGenerator.class))); + assertThat(repository.getRepositoryConfiguration().getKeyGenerator(), is(instanceOf(NoOpKeyGenerator.class))); } } \ No newline at end of file diff --git a/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/dsl/mock/RepositoryMockBuilderTest.java b/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/dsl/mock/RepositoryMockBuilderTest.java index 79b8a427..f32a6063 100644 --- a/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/dsl/mock/RepositoryMockBuilderTest.java +++ b/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/dsl/mock/RepositoryMockBuilderTest.java @@ -5,6 +5,9 @@ import com.mmnaseri.utils.spring.data.domain.impl.DefaultOperatorContext; import com.mmnaseri.utils.spring.data.domain.impl.DefaultRepositoryMetadataResolver; import com.mmnaseri.utils.spring.data.domain.impl.MethodQueryDescriptionExtractor; +import com.mmnaseri.utils.spring.data.domain.impl.key.NoOpKeyGenerator; +import com.mmnaseri.utils.spring.data.domain.impl.key.UUIDKeyGenerator; +import com.mmnaseri.utils.spring.data.dsl.factory.RepositoryFactoryBuilder; import com.mmnaseri.utils.spring.data.error.CorruptDataException; import com.mmnaseri.utils.spring.data.error.DataOperationExecutionException; import com.mmnaseri.utils.spring.data.error.MockBuilderException; @@ -38,7 +41,7 @@ public class RepositoryMockBuilderTest { @Test public void testOutOfTheBoxMocking() throws Exception { - final SimpleCrudPersonRepository repository = new RepositoryMockBuilder().mock(SimpleCrudPersonRepository.class); + final SimpleCrudPersonRepository repository = new RepositoryMockBuilder().useConfiguration(RepositoryFactoryBuilder.defaultConfiguration()).mock(SimpleCrudPersonRepository.class); assertThat(repository, is(notNullValue())); final Person person = repository.save(new Person()); assertThat(repository.findAll(), is(notNullValue())); @@ -70,6 +73,17 @@ public void testMockingWithoutKeyGeneration() throws Exception { assertThat(repository.findAll(), is(empty())); } + @Test + public void testMockingWithFallbackKeyGenerator() throws Exception { + final DefaultRepositoryFactoryConfiguration configuration = new DefaultRepositoryFactoryConfiguration(RepositoryFactoryBuilder.defaultConfiguration()); + configuration.setDefaultKeyGenerator(new UUIDKeyGenerator()); + final SimpleCrudPersonRepository repository = new RepositoryMockBuilder().useConfiguration(configuration).mock(SimpleCrudPersonRepository.class); + assertThat(repository, is(notNullValue())); + final Person saved = repository.save(new Person()); + assertThat(saved, is(notNullValue())); + assertThat(saved.getId(), is(notNullValue())); + } + @Test public void testCustomKeyGeneration() throws Exception { final SimpleCrudPersonRepository repository = new RepositoryMockBuilder().generateKeysUsing(CustomStringKeyGenerator.class).mock(SimpleCrudPersonRepository.class); @@ -157,7 +171,7 @@ public void testUsingCustomConfiguration() throws Exception { @Test public void testNoOpKeyGeneration() throws Exception { - final RepositoryMockBuilder.NoOpKeyGenerator generator = new RepositoryMockBuilder.NoOpKeyGenerator<>(); + final NoOpKeyGenerator generator = new NoOpKeyGenerator<>(); assertThat(generator.generate(), is(nullValue())); } diff --git a/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/proxy/impl/DefaultRepositoryFactoryTest.java b/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/proxy/impl/DefaultRepositoryFactoryTest.java index 70f40a31..c0fd55dc 100644 --- a/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/proxy/impl/DefaultRepositoryFactoryTest.java +++ b/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/proxy/impl/DefaultRepositoryFactoryTest.java @@ -3,7 +3,7 @@ import com.mmnaseri.utils.spring.data.domain.impl.DefaultOperatorContext; import com.mmnaseri.utils.spring.data.domain.impl.DefaultRepositoryMetadataResolver; import com.mmnaseri.utils.spring.data.domain.impl.MethodQueryDescriptionExtractor; -import com.mmnaseri.utils.spring.data.domain.impl.key.UUIDKeyGenerator; +import com.mmnaseri.utils.spring.data.domain.impl.key.NoOpKeyGenerator; import com.mmnaseri.utils.spring.data.proxy.RepositoryFactoryConfiguration; import com.mmnaseri.utils.spring.data.query.impl.DefaultDataFunctionRegistry; import com.mmnaseri.utils.spring.data.sample.models.Person; @@ -39,12 +39,52 @@ public void testRepositoryInstance() throws Exception { configuration.setRepositoryMetadataResolver(new DefaultRepositoryMetadataResolver()); configuration.setResultAdapterContext(new DefaultResultAdapterContext()); configuration.setTypeMappingContext(new DefaultTypeMappingContext()); + configuration.setDefaultKeyGenerator(null); final DefaultRepositoryFactory factory = new DefaultRepositoryFactory(configuration); assertThat(factory.getConfiguration(), Matchers.is(configuration)); assertThat(dataStoreRegistry.has(Person.class), is(false)); - factory.getInstance(new UUIDKeyGenerator(), ClearableSimpleCrudPersonRepository.class, RepositoryClearerMapping.class); + factory.getInstance(null, ClearableSimpleCrudPersonRepository.class, RepositoryClearerMapping.class); assertThat(dataStoreRegistry.has(Person.class), is(true)); - final ClearableSimpleCrudPersonRepository repository = factory.getInstance(new UUIDKeyGenerator(), ClearableSimpleCrudPersonRepository.class, RepositoryClearerMapping.class); + final ClearableSimpleCrudPersonRepository repository = factory.getInstance(null, ClearableSimpleCrudPersonRepository.class, RepositoryClearerMapping.class); + final DataStore dataStore = dataStoreRegistry.getDataStore(Person.class); + dataStore.save("k1", new Person().setId("k1").setLastName("Sadeghi")); + dataStore.save("k2", new Person().setId("k2").setLastName("Naseri")); + dataStore.save("k3", new Person().setId("k3").setLastName("Sadeghi")); + dataStore.save("k4", new Person().setId("k4").setLastName("Naseri")); + assertThat(repository.findAll(), containsInAnyOrder(dataStore.retrieveAll().toArray())); + assertThat(repository.findByLastName("Naseri"), containsInAnyOrder(dataStore.retrieve("k2"), dataStore.retrieve("k4"))); + assertThat(repository.findByLastName("Sadeghi"), containsInAnyOrder(dataStore.retrieve("k1"), dataStore.retrieve("k3"))); + assertThat(repository.findByLastName("Ghomboli"), is(empty())); + final Collection all = dataStore.retrieveAll(); + assertThat(repository.deleteAll(), containsInAnyOrder(all.toArray())); + dataStore.save("k1", new Person().setId("k1").setLastName("Sadeghi")); + dataStore.save("k2", new Person().setId("k2").setLastName("Naseri")); + dataStore.save("k3", new Person().setId("k3").setLastName("Sadeghi")); + dataStore.save("k4", new Person().setId("k4").setLastName("Naseri")); + assertThat(dataStore.retrieveAll(), hasSize(4)); + repository.clearRepo(); + assertThat(dataStore.retrieveAll(), is(empty())); + } + + @Test + public void testRepositoryInstanceWithKeyGenerationFallback() throws Exception { + final DefaultRepositoryFactoryConfiguration configuration = new DefaultRepositoryFactoryConfiguration(); + final DefaultDataStoreRegistry dataStoreRegistry = new DefaultDataStoreRegistry(); + configuration.setDataStoreRegistry(dataStoreRegistry); + configuration.setDescriptionExtractor(new MethodQueryDescriptionExtractor(new DefaultOperatorContext())); + configuration.setEventListenerContext(new DefaultDataStoreEventListenerContext()); + configuration.setFunctionRegistry(new DefaultDataFunctionRegistry()); + configuration.setOperationInvocationHandler(new NonDataOperationInvocationHandler()); + configuration.setRepositoryMetadataResolver(new DefaultRepositoryMetadataResolver()); + configuration.setResultAdapterContext(new DefaultResultAdapterContext()); + configuration.setTypeMappingContext(new DefaultTypeMappingContext()); + configuration.setDefaultKeyGenerator(new NoOpKeyGenerator<>()); + final DefaultRepositoryFactory factory = new DefaultRepositoryFactory(configuration); + assertThat(factory.getConfiguration(), Matchers.is(configuration)); + assertThat(dataStoreRegistry.has(Person.class), is(false)); + factory.getInstance(null, ClearableSimpleCrudPersonRepository.class, RepositoryClearerMapping.class); + assertThat(dataStoreRegistry.has(Person.class), is(true)); + final ClearableSimpleCrudPersonRepository repository = factory.getInstance(null, ClearableSimpleCrudPersonRepository.class, RepositoryClearerMapping.class); final DataStore dataStore = dataStoreRegistry.getDataStore(Person.class); dataStore.save("k1", new Person().setId("k1").setLastName("Sadeghi")); dataStore.save("k2", new Person().setId("k2").setLastName("Naseri")); diff --git a/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/sample/repositories/RepositoryClearerMapping.java b/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/sample/repositories/RepositoryClearerMapping.java index dc59599a..59422aee 100644 --- a/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/sample/repositories/RepositoryClearerMapping.java +++ b/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/sample/repositories/RepositoryClearerMapping.java @@ -1,7 +1,7 @@ package com.mmnaseri.utils.spring.data.sample.repositories; import com.mmnaseri.utils.spring.data.domain.RepositoryAware; -import com.mmnaseri.utils.spring.data.domain.impl.key.UUIDKeyGenerator; +import com.mmnaseri.utils.spring.data.domain.impl.key.NoOpKeyGenerator; import com.mmnaseri.utils.spring.data.proxy.*; import com.mmnaseri.utils.spring.data.sample.models.Person; import org.hamcrest.Matchers; @@ -35,7 +35,7 @@ public void setRepositoryFactoryConfiguration(RepositoryFactoryConfiguration con public void setRepositoryConfiguration(RepositoryConfiguration repositoryConfiguration) { assertThat(repositoryConfiguration, is(notNullValue())); assertThat(repositoryConfiguration.getKeyGenerator(), is(notNullValue())); - assertThat(repositoryConfiguration.getKeyGenerator(), is(instanceOf(UUIDKeyGenerator.class))); + assertThat(repositoryConfiguration.getKeyGenerator(), is(instanceOf(NoOpKeyGenerator.class))); assertThat(repositoryConfiguration.getRepositoryMetadata(), is(notNullValue())); assertThat(repositoryConfiguration.getRepositoryMetadata().getEntityType(), is(Matchers.>equalTo(Person.class))); assertThat(repositoryConfiguration.getRepositoryMetadata().getIdentifierProperty(), is("id")); From ae6ecac9f05a800385a09e00c21c975236449240 Mon Sep 17 00:00:00 2001 From: Milad Naseri Date: Tue, 14 Jun 2016 23:22:17 -0700 Subject: [PATCH 10/12] feat(com.mmnaseri.utils.spring.data.dsl.factory): let users pick a configuration to start off of Closes #109 --- .../dsl/factory/RepositoryFactoryBuilder.java | 48 ++++++++++++------- .../factory/RepositoryFactoryBuilderTest.java | 17 ++++++- 2 files changed, 48 insertions(+), 17 deletions(-) diff --git a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/factory/RepositoryFactoryBuilder.java b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/factory/RepositoryFactoryBuilder.java index fa7e8d9e..5fe97cdf 100644 --- a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/factory/RepositoryFactoryBuilder.java +++ b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/dsl/factory/RepositoryFactoryBuilder.java @@ -32,7 +32,6 @@ @SuppressWarnings("WeakerAccess") public class RepositoryFactoryBuilder implements Start, DataFunctionsAnd, DataStoresAnd, EventListenerAnd, MappingContextAnd, OperatorsAnd, ResultAdaptersAnd, OperationHandlersAnd { - private static RepositoryFactory DEFAULT_FACTORY; public static final String DEFAULT_USER = "User"; private RepositoryMetadataResolver metadataResolver; private MethodQueryDescriptionExtractor queryDescriptionExtractor; @@ -45,16 +44,7 @@ public class RepositoryFactoryBuilder implements Start, DataFunctionsAnd, DataSt private KeyGenerator defaultKeyGenerator; /** - * Starting point for writing code in the builder's DSL - * - * @return an instance of the builder - */ - public static Start builder() { - return new RepositoryFactoryBuilder(); - } - - /** - * @return the default configuration (always the same instance) + * @return the default configuration */ public static RepositoryFactoryConfiguration defaultConfiguration() { final RepositoryFactoryBuilder builder = (RepositoryFactoryBuilder) builder(); @@ -71,13 +61,39 @@ public static RepositoryFactoryConfiguration defaultConfiguration() { } /** - * @return the default factory (always the same instance) + * Starting point for writing code in the builder's DSL + * + * @return an instance of the builder + */ + public static Start builder() { + return new RepositoryFactoryBuilder(); + } + + /** + * Start the configuration DSL by considering the provided configuration as + * the default fallback + * @param configuration the fallback configuration + * @return an instance of the builder + */ + public static Start given(RepositoryFactoryConfiguration configuration) { + final RepositoryFactoryBuilder builder = new RepositoryFactoryBuilder(); + builder.metadataResolver = configuration.getRepositoryMetadataResolver() != null ? configuration.getRepositoryMetadataResolver() : builder.metadataResolver; + builder.queryDescriptionExtractor = configuration.getDescriptionExtractor() != null ? configuration.getDescriptionExtractor() : builder.queryDescriptionExtractor; + builder.functionRegistry = configuration.getFunctionRegistry() != null ? configuration.getFunctionRegistry() : builder.functionRegistry; + builder.dataStoreRegistry = configuration.getDataStoreRegistry() != null ? configuration.getDataStoreRegistry() : builder.dataStoreRegistry; + builder.resultAdapterContext = configuration.getResultAdapterContext() != null ? configuration.getResultAdapterContext() : builder.resultAdapterContext; + builder.typeMappingContext = configuration.getTypeMappingContext() != null ? configuration.getTypeMappingContext() : builder.typeMappingContext; + builder.eventListenerContext = configuration.getEventListenerContext() != null ? configuration.getEventListenerContext() : builder.eventListenerContext; + builder.operationInvocationHandler = configuration.getOperationInvocationHandler() != null ? configuration.getOperationInvocationHandler() : builder.operationInvocationHandler; + builder.defaultKeyGenerator = configuration.getDefaultKeyGenerator() != null ? configuration.getDefaultKeyGenerator() : builder.defaultKeyGenerator; + return builder; + } + + /** + * @return the default factory */ public static RepositoryFactory defaultFactory() { - if (DEFAULT_FACTORY == null) { - DEFAULT_FACTORY = new DefaultRepositoryFactory(defaultConfiguration()); - } - return DEFAULT_FACTORY; + return new DefaultRepositoryFactory(defaultConfiguration()); } private RepositoryFactoryBuilder() { diff --git a/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/dsl/factory/RepositoryFactoryBuilderTest.java b/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/dsl/factory/RepositoryFactoryBuilderTest.java index 2672f055..2de21db3 100644 --- a/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/dsl/factory/RepositoryFactoryBuilderTest.java +++ b/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/dsl/factory/RepositoryFactoryBuilderTest.java @@ -14,6 +14,7 @@ import com.mmnaseri.utils.spring.data.proxy.RepositoryFactoryConfiguration; import com.mmnaseri.utils.spring.data.proxy.ResultAdapterContext; import com.mmnaseri.utils.spring.data.proxy.TypeMappingContext; +import com.mmnaseri.utils.spring.data.proxy.impl.DefaultRepositoryFactoryConfiguration; import com.mmnaseri.utils.spring.data.proxy.impl.DefaultResultAdapterContext; import com.mmnaseri.utils.spring.data.proxy.impl.DefaultTypeMappingContext; import com.mmnaseri.utils.spring.data.proxy.impl.NonDataOperationInvocationHandler; @@ -37,6 +38,7 @@ import java.io.Serializable; import java.util.List; +import static com.mmnaseri.utils.spring.data.dsl.factory.RepositoryFactoryBuilder.given; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.*; @@ -64,7 +66,20 @@ public void testDefaultConfiguration() throws Exception { public void testDefaultFactory() throws Exception { final RepositoryFactory factory = RepositoryFactoryBuilder.defaultFactory(); assertThat(factory, is(notNullValue())); - assertThat(factory, is(RepositoryFactoryBuilder.defaultFactory())); + } + + @Test + public void testConfiguringAProvidedConfiguration() throws Exception { + final DefaultRepositoryFactoryConfiguration configuration = new DefaultRepositoryFactoryConfiguration(); + final DefaultDataFunctionRegistry functionRegistry = new DefaultDataFunctionRegistry(); + configuration.setFunctionRegistry(functionRegistry); + configuration.setDefaultKeyGenerator(new NoOpKeyGenerator<>()); + final UUIDKeyGenerator keyGenerator = new UUIDKeyGenerator(); + final RepositoryFactoryConfiguration modifiedConfiguration = given(configuration).withDefaultKeyGenerator(keyGenerator).withListener(new AllCatchingEventListener()).configure(); + assertThat(modifiedConfiguration, is(notNullValue())); + assertThat(modifiedConfiguration.getDefaultKeyGenerator(), is((Object) keyGenerator)); + assertThat(modifiedConfiguration.getEventListenerContext(), is(notNullValue())); + assertThat(modifiedConfiguration.getEventListenerContext().getListeners(DataStoreEvent.class), hasSize(1)); } @Test From de1d7b68b9f2f8d7af9f5046f09fb155a7007dd6 Mon Sep 17 00:00:00 2001 From: Milad Naseri Date: Wed, 15 Jun 2016 00:19:45 -0700 Subject: [PATCH 11/12] feat(sample-jpa): add samples outlining how a configuration can be shared Closes #109 --- .../samples/spring/data/jpa/model/Plane.java | 42 +++++++++ .../data/jpa/model/SerialAwareEntity.java | 22 +++++ .../data/jpa/repository/PlaneRepository.java | 11 +++ .../SerialAwareEntityRepository.java | 13 +++ .../spring/data/jpa/service/PlaneService.java | 15 ++++ .../jpa/service/impl/DefaultPlaneService.java | 46 ++++++++++ .../SerialAwareEntityRepositorySupport.java | 39 +++++++++ .../service/impl/DefaultPlaneServiceTest.java | 85 +++++++++++++++++++ .../data/jpa/utils/RepositoryConfigUtils.java | 31 +++++++ .../utils/spring/data/store/DataStore.java | 5 ++ .../store/impl/EventPublishingDataStore.java | 5 ++ .../data/store/impl/MemoryDataStore.java | 5 ++ .../data/sample/mocks/SpyingDataStore.java | 7 ++ .../impl/EventPublishingDataStoreTest.java | 12 +++ .../data/store/impl/MemoryDataStoreTest.java | 10 +++ 15 files changed, 348 insertions(+) create mode 100644 spring-data-mock-sample-jpa/src/main/java/com/mmnaseri/utils/samples/spring/data/jpa/model/Plane.java create mode 100644 spring-data-mock-sample-jpa/src/main/java/com/mmnaseri/utils/samples/spring/data/jpa/model/SerialAwareEntity.java create mode 100644 spring-data-mock-sample-jpa/src/main/java/com/mmnaseri/utils/samples/spring/data/jpa/repository/PlaneRepository.java create mode 100644 spring-data-mock-sample-jpa/src/main/java/com/mmnaseri/utils/samples/spring/data/jpa/repository/SerialAwareEntityRepository.java create mode 100644 spring-data-mock-sample-jpa/src/main/java/com/mmnaseri/utils/samples/spring/data/jpa/service/PlaneService.java create mode 100644 spring-data-mock-sample-jpa/src/main/java/com/mmnaseri/utils/samples/spring/data/jpa/service/impl/DefaultPlaneService.java create mode 100644 spring-data-mock-sample-jpa/src/test/java/com/mmnaseri/utils/samples/spring/data/jpa/repository/SerialAwareEntityRepositorySupport.java create mode 100644 spring-data-mock-sample-jpa/src/test/java/com/mmnaseri/utils/samples/spring/data/jpa/service/impl/DefaultPlaneServiceTest.java create mode 100644 spring-data-mock-sample-jpa/src/test/java/com/mmnaseri/utils/samples/spring/data/jpa/utils/RepositoryConfigUtils.java diff --git a/spring-data-mock-sample-jpa/src/main/java/com/mmnaseri/utils/samples/spring/data/jpa/model/Plane.java b/spring-data-mock-sample-jpa/src/main/java/com/mmnaseri/utils/samples/spring/data/jpa/model/Plane.java new file mode 100644 index 00000000..1072444b --- /dev/null +++ b/spring-data-mock-sample-jpa/src/main/java/com/mmnaseri/utils/samples/spring/data/jpa/model/Plane.java @@ -0,0 +1,42 @@ +package com.mmnaseri.utils.samples.spring.data.jpa.model; + +import javax.persistence.Entity; +import javax.persistence.Id; + +/** + * @author Milad Naseri (milad.naseri@cdk.com) + * @since 1.0 (6/14/16, 11:34 PM) + */ +@Entity +public class Plane extends SerialAwareEntity { + + @Id + private Long id; + private String model; + private int capacity; + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public String getModel() { + return model; + } + + public void setModel(String model) { + this.model = model; + } + + public int getCapacity() { + return capacity; + } + + public void setCapacity(int capacity) { + this.capacity = capacity; + } + +} diff --git a/spring-data-mock-sample-jpa/src/main/java/com/mmnaseri/utils/samples/spring/data/jpa/model/SerialAwareEntity.java b/spring-data-mock-sample-jpa/src/main/java/com/mmnaseri/utils/samples/spring/data/jpa/model/SerialAwareEntity.java new file mode 100644 index 00000000..f24fb237 --- /dev/null +++ b/spring-data-mock-sample-jpa/src/main/java/com/mmnaseri/utils/samples/spring/data/jpa/model/SerialAwareEntity.java @@ -0,0 +1,22 @@ +package com.mmnaseri.utils.samples.spring.data.jpa.model; + +import javax.persistence.MappedSuperclass; + +/** + * @author Milad Naseri (milad.naseri@cdk.com) + * @since 1.0 (6/14/16, 11:36 PM) + */ +@MappedSuperclass +public class SerialAwareEntity { + + private String serial; + + public String getSerial() { + return serial; + } + + public void setSerial(String serial) { + this.serial = serial; + } + +} diff --git a/spring-data-mock-sample-jpa/src/main/java/com/mmnaseri/utils/samples/spring/data/jpa/repository/PlaneRepository.java b/spring-data-mock-sample-jpa/src/main/java/com/mmnaseri/utils/samples/spring/data/jpa/repository/PlaneRepository.java new file mode 100644 index 00000000..11a04e8c --- /dev/null +++ b/spring-data-mock-sample-jpa/src/main/java/com/mmnaseri/utils/samples/spring/data/jpa/repository/PlaneRepository.java @@ -0,0 +1,11 @@ +package com.mmnaseri.utils.samples.spring.data.jpa.repository; + +import com.mmnaseri.utils.samples.spring.data.jpa.model.Plane; +import org.springframework.data.jpa.repository.JpaRepository; + +/** + * @author Milad Naseri (milad.naseri@cdk.com) + * @since 1.0 (6/14/16, 11:34 PM) + */ +public interface PlaneRepository extends JpaRepository, SerialAwareEntityRepository { +} diff --git a/spring-data-mock-sample-jpa/src/main/java/com/mmnaseri/utils/samples/spring/data/jpa/repository/SerialAwareEntityRepository.java b/spring-data-mock-sample-jpa/src/main/java/com/mmnaseri/utils/samples/spring/data/jpa/repository/SerialAwareEntityRepository.java new file mode 100644 index 00000000..e415fced --- /dev/null +++ b/spring-data-mock-sample-jpa/src/main/java/com/mmnaseri/utils/samples/spring/data/jpa/repository/SerialAwareEntityRepository.java @@ -0,0 +1,13 @@ +package com.mmnaseri.utils.samples.spring.data.jpa.repository; + +import com.mmnaseri.utils.samples.spring.data.jpa.model.SerialAwareEntity; + +/** + * @author Milad Naseri (milad.naseri@cdk.com) + * @since 1.0 (6/14/16, 11:37 PM) + */ +public interface SerialAwareEntityRepository { + + E lookupBySerial(String serial); + +} diff --git a/spring-data-mock-sample-jpa/src/main/java/com/mmnaseri/utils/samples/spring/data/jpa/service/PlaneService.java b/spring-data-mock-sample-jpa/src/main/java/com/mmnaseri/utils/samples/spring/data/jpa/service/PlaneService.java new file mode 100644 index 00000000..4f2f8006 --- /dev/null +++ b/spring-data-mock-sample-jpa/src/main/java/com/mmnaseri/utils/samples/spring/data/jpa/service/PlaneService.java @@ -0,0 +1,15 @@ +package com.mmnaseri.utils.samples.spring.data.jpa.service; + +/** + * @author Milad Naseri (milad.naseri@cdk.com) + * @since 1.0 (6/14/16, 11:39 PM) + */ +public interface PlaneService { + + Long create(String model, String serial); + + String lookup(Long id); + + String lookup(String serial); + +} diff --git a/spring-data-mock-sample-jpa/src/main/java/com/mmnaseri/utils/samples/spring/data/jpa/service/impl/DefaultPlaneService.java b/spring-data-mock-sample-jpa/src/main/java/com/mmnaseri/utils/samples/spring/data/jpa/service/impl/DefaultPlaneService.java new file mode 100644 index 00000000..3c87aab9 --- /dev/null +++ b/spring-data-mock-sample-jpa/src/main/java/com/mmnaseri/utils/samples/spring/data/jpa/service/impl/DefaultPlaneService.java @@ -0,0 +1,46 @@ +package com.mmnaseri.utils.samples.spring.data.jpa.service.impl; + +import com.mmnaseri.utils.samples.spring.data.jpa.model.Plane; +import com.mmnaseri.utils.samples.spring.data.jpa.repository.PlaneRepository; +import com.mmnaseri.utils.samples.spring.data.jpa.service.PlaneService; + +/** + * @author Milad Naseri (milad.naseri@cdk.com) + * @since 1.0 (6/14/16, 11:39 PM) + */ +public class DefaultPlaneService implements PlaneService { + + private final PlaneRepository repository; + + public DefaultPlaneService(PlaneRepository repository) { + this.repository = repository; + } + + @Override + public Long create(String model, String serial) { + final Plane plane = new Plane(); + plane.setModel(model); + plane.setCapacity(100); + plane.setSerial(serial); + return repository.save(plane).getId(); + } + + @Override + public String lookup(Long id) { + final Plane plane = repository.findOne(id); + if (plane == null) { + return null; + } + return plane.getModel(); + } + + @Override + public String lookup(String serial) { + final Plane plane = repository.lookupBySerial(serial); + if (plane == null) { + return null; + } + return plane.getModel(); + } + +} diff --git a/spring-data-mock-sample-jpa/src/test/java/com/mmnaseri/utils/samples/spring/data/jpa/repository/SerialAwareEntityRepositorySupport.java b/spring-data-mock-sample-jpa/src/test/java/com/mmnaseri/utils/samples/spring/data/jpa/repository/SerialAwareEntityRepositorySupport.java new file mode 100644 index 00000000..8946bfa1 --- /dev/null +++ b/spring-data-mock-sample-jpa/src/test/java/com/mmnaseri/utils/samples/spring/data/jpa/repository/SerialAwareEntityRepositorySupport.java @@ -0,0 +1,39 @@ +package com.mmnaseri.utils.samples.spring.data.jpa.repository; + +import com.mmnaseri.utils.samples.spring.data.jpa.model.SerialAwareEntity; +import com.mmnaseri.utils.spring.data.domain.RepositoryAware; +import com.mmnaseri.utils.spring.data.error.DataOperationExecutionException; +import org.springframework.data.domain.Example; +import org.springframework.data.jpa.repository.JpaRepository; + +import java.util.List; + +/** + * @author Milad Naseri (milad.naseri@cdk.com) + * @since 1.0 (6/14/16, 11:45 PM) + */ +public class SerialAwareEntityRepositorySupport implements SerialAwareEntityRepository, RepositoryAware { + + private JpaRepository repository; + + @Override + public SerialAwareEntity lookupBySerial(String serial) { + final SerialAwareEntity probe = new SerialAwareEntity(); + probe.setSerial(serial); + final Example example = Example.of(probe); + final List found = repository.findAll(example); + if (found.isEmpty()) { + return null; + } + if (found.size() > 1) { + throw new DataOperationExecutionException("Expected only one instance to be found", null); + } + return (SerialAwareEntity) found.get(0); + } + + @Override + public void setRepository(JpaRepository repository) { + this.repository = repository; + } + +} diff --git a/spring-data-mock-sample-jpa/src/test/java/com/mmnaseri/utils/samples/spring/data/jpa/service/impl/DefaultPlaneServiceTest.java b/spring-data-mock-sample-jpa/src/test/java/com/mmnaseri/utils/samples/spring/data/jpa/service/impl/DefaultPlaneServiceTest.java new file mode 100644 index 00000000..65273b65 --- /dev/null +++ b/spring-data-mock-sample-jpa/src/test/java/com/mmnaseri/utils/samples/spring/data/jpa/service/impl/DefaultPlaneServiceTest.java @@ -0,0 +1,85 @@ +package com.mmnaseri.utils.samples.spring.data.jpa.service.impl; + +import com.mmnaseri.utils.samples.spring.data.jpa.model.Plane; +import com.mmnaseri.utils.samples.spring.data.jpa.repository.PlaneRepository; +import com.mmnaseri.utils.samples.spring.data.jpa.utils.RepositoryConfigUtils; +import com.mmnaseri.utils.spring.data.dsl.mock.RepositoryMockBuilder; +import com.mmnaseri.utils.spring.data.proxy.RepositoryFactoryConfiguration; +import com.mmnaseri.utils.spring.data.store.DataStore; +import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + +import java.io.Serializable; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.is; +import static org.hamcrest.Matchers.notNullValue; + +/** + * @author Milad Naseri (milad.naseri@cdk.com) + * @since 1.0 (6/14/16, 11:41 PM) + */ +public class DefaultPlaneServiceTest { + + private PlaneRepository repository; + private DefaultPlaneService service; + + @BeforeMethod + public void setUp() throws Exception { + final RepositoryFactoryConfiguration configuration = RepositoryConfigUtils.getConfiguration(); + repository = new RepositoryMockBuilder() + .useConfiguration(configuration) + .mock(PlaneRepository.class); + service = new DefaultPlaneService(repository); + } + + @AfterMethod + public void tearDown() throws Exception { + final RepositoryFactoryConfiguration configuration = RepositoryConfigUtils.getConfiguration(); + //because the configuration is now shared, it means that the data store registry is shared across all + //the tests, too. + //This is the same as using a shared database for doing all the tests. So, at the end of the tests we need + //to clear the database after us like using a regular data store + final DataStore dataStore = configuration.getDataStoreRegistry().getDataStore(Plane.class); + dataStore.truncate(); + } + + @Test + public void testCreate() throws Exception { + assertThat(repository.count(), is(0L)); + final String model = "F-22"; + final String serial = "123456"; + final Long id = service.create(model, serial); + assertThat(id, is(notNullValue())); + final Plane loaded = repository.findOne(id); + assertThat(loaded, is(notNullValue())); + assertThat(loaded.getModel(), is(model)); + assertThat(loaded.getSerial(), is(serial)); + } + + @Test + public void testLookupById() throws Exception { + final Plane entity = new Plane(); + entity.setModel("Boeing 747"); + entity.setSerial("123456"); + entity.setCapacity(1000); + final Plane saved = repository.save(entity); + final String model = service.lookup(saved.getId()); + assertThat(model, is(notNullValue())); + assertThat(model, is(entity.getModel())); + } + + @Test + public void testLookupBySerial() throws Exception { + final Plane entity = new Plane(); + entity.setModel("Boeing 747"); + entity.setSerial("123456"); + entity.setCapacity(1000); + repository.save(entity); + final String model = service.lookup(entity.getSerial()); + assertThat(model, is(notNullValue())); + assertThat(model, is(entity.getModel())); + } + +} \ No newline at end of file diff --git a/spring-data-mock-sample-jpa/src/test/java/com/mmnaseri/utils/samples/spring/data/jpa/utils/RepositoryConfigUtils.java b/spring-data-mock-sample-jpa/src/test/java/com/mmnaseri/utils/samples/spring/data/jpa/utils/RepositoryConfigUtils.java new file mode 100644 index 00000000..40bc527a --- /dev/null +++ b/spring-data-mock-sample-jpa/src/test/java/com/mmnaseri/utils/samples/spring/data/jpa/utils/RepositoryConfigUtils.java @@ -0,0 +1,31 @@ +package com.mmnaseri.utils.samples.spring.data.jpa.utils; + +import com.mmnaseri.utils.samples.spring.data.jpa.repository.SerialAwareEntityRepository; +import com.mmnaseri.utils.samples.spring.data.jpa.repository.SerialAwareEntityRepositorySupport; +import com.mmnaseri.utils.spring.data.domain.impl.key.ConfigurableSequentialLongKeyGenerator; +import com.mmnaseri.utils.spring.data.proxy.RepositoryFactoryConfiguration; + +import static com.mmnaseri.utils.spring.data.dsl.factory.RepositoryFactoryBuilder.builder; + +/** + * We are setting defaults on the configuration level, which we will be reusing later. + * + * @author Milad Naseri (milad.naseri@cdk.com) + * @since 1.0 (6/14/16, 11:42 PM) + */ +public final class RepositoryConfigUtils { + + private static final RepositoryFactoryConfiguration CONFIGURATION = builder() + .honoringImplementation(SerialAwareEntityRepository.class, SerialAwareEntityRepositorySupport.class) + .withDefaultKeyGenerator(new ConfigurableSequentialLongKeyGenerator()) + .configure(); + + private RepositoryConfigUtils() { + throw new UnsupportedOperationException(); + } + + public static RepositoryFactoryConfiguration getConfiguration() { + return CONFIGURATION; + } + +} diff --git a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/store/DataStore.java b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/store/DataStore.java index 2e89b0e3..bc8a7d5b 100644 --- a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/store/DataStore.java +++ b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/store/DataStore.java @@ -62,4 +62,9 @@ public interface DataStore { */ Class getEntityType(); + /** + * Does a hard remove of all the entities in the data store + */ + void truncate(); + } diff --git a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/store/impl/EventPublishingDataStore.java b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/store/impl/EventPublishingDataStore.java index 859428fb..cf10fa06 100644 --- a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/store/impl/EventPublishingDataStore.java +++ b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/store/impl/EventPublishingDataStore.java @@ -102,6 +102,11 @@ public Class getEntityType() { return delegate.getEntityType(); } + @Override + public void truncate() { + delegate.truncate(); + } + @Override public void publishEvent(DataStoreEvent event) { listenerContext.trigger(event); diff --git a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/store/impl/MemoryDataStore.java b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/store/impl/MemoryDataStore.java index dd18c8bf..1ad2d3cc 100644 --- a/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/store/impl/MemoryDataStore.java +++ b/spring-data-mock/src/main/java/com/mmnaseri/utils/spring/data/store/impl/MemoryDataStore.java @@ -96,4 +96,9 @@ public Class getEntityType() { return entityType; } + @Override + public void truncate() { + store.clear(); + } + } diff --git a/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/sample/mocks/SpyingDataStore.java b/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/sample/mocks/SpyingDataStore.java index 9259bb56..cdbc3d70 100644 --- a/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/sample/mocks/SpyingDataStore.java +++ b/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/sample/mocks/SpyingDataStore.java @@ -80,6 +80,13 @@ public Class getEntityType() { return delegate.getEntityType(); } + @Override + public void truncate() { + if (delegate != null) { + delegate.truncate(); + } + } + public List getRequests() { return Collections.unmodifiableList(requests); } diff --git a/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/store/impl/EventPublishingDataStoreTest.java b/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/store/impl/EventPublishingDataStoreTest.java index e5017a04..666466e8 100644 --- a/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/store/impl/EventPublishingDataStoreTest.java +++ b/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/store/impl/EventPublishingDataStoreTest.java @@ -183,4 +183,16 @@ public void testDelete() throws Exception { assertThat(after.getEvent().getDataStore(), Matchers.>is(dataStore)); } + @Test + public void testTruncating() throws Exception { + final String k1 = "k1"; + final String k2 = "k2"; + assertThat(dataStore.retrieveAll(), is(delegate.retrieveAll())); + delegate.save(k1, new Person()); + delegate.save(k2, new Person()); + assertThat(dataStore.retrieveAll(), is(delegate.retrieveAll())); + dataStore.truncate(); + assertThat(delegate.retrieveAll(), is(Matchers.empty())); + } + } \ No newline at end of file diff --git a/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/store/impl/MemoryDataStoreTest.java b/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/store/impl/MemoryDataStoreTest.java index ea99ae16..9f52ba42 100644 --- a/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/store/impl/MemoryDataStoreTest.java +++ b/spring-data-mock/src/test/java/com/mmnaseri/utils/spring/data/store/impl/MemoryDataStoreTest.java @@ -113,4 +113,14 @@ public void testRetrievingWithNullKey() throws Exception { dataStore.retrieve(null); } + @Test + public void testTruncating() throws Exception { + dataStore.save("1", new Person()); + dataStore.save("2", new Person()); + dataStore.save("3", new Person()); + assertThat(dataStore.retrieveAll(), hasSize(3)); + dataStore.truncate(); + assertThat(dataStore.retrieveAll(), is(Matchers.empty())); + } + } \ No newline at end of file From 273012f3aacc151800df7b6e543ba8f41195c07b Mon Sep 17 00:00:00 2001 From: Milad Naseri Date: Wed, 15 Jun 2016 00:27:18 -0700 Subject: [PATCH 12/12] chore(all): prepare for release 1.1.3 closes #112 --- .travis.yml | 2 +- spring-data-mock-sample-jpa/pom.xml | 2 +- spring-data-mock/pom.xml | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.travis.yml b/.travis.yml index 907ad5d9..3f81f435 100644 --- a/.travis.yml +++ b/.travis.yml @@ -11,7 +11,7 @@ after_success: - '[[ $TRAVIS_BRANCH == "master" && ( "x${TRAVIS_PULL_REQUEST}" == "xfalse" || "x${TRAVIS_PULL_REQUEST}" == "x" ) && ( "x$(echo $JAVA_HOME | grep -o 8)" == "x8" ) ]] && sudo apt-get install gnupg2' - '[[ $TRAVIS_BRANCH == "master" && ( "x${TRAVIS_PULL_REQUEST}" == "xfalse" || "x${TRAVIS_PULL_REQUEST}" == "x" ) && ( "x$(echo $JAVA_HOME | grep -o 8)" == "x8" ) ]] && bash ../deployment/deploy.sh eb1a6f34f056 ../deployment/key.asc.enc ../deployment/settings.xml' # SUDO should be set to `false` except when deploying to OSSRH to trigger container infrastructure -sudo: false +sudo: true env: global: - secure: DPkao3yJ4hhEsUOfs2VQJ8WCV3VdR3ToFiGB1l461PUstjaytTeXYK3bW2PmZqYJs6Hxxwyl8UHFvgBvWLb/yQV/dqyyJAV8XRb9UC37e4ddLoi8HE7NSGQIiXq0tySiMaOTyd2NtRTepfNAMEMDP746Nrox1giPEq1FPv+K98o= diff --git a/spring-data-mock-sample-jpa/pom.xml b/spring-data-mock-sample-jpa/pom.xml index b461d14b..1d32911c 100644 --- a/spring-data-mock-sample-jpa/pom.xml +++ b/spring-data-mock-sample-jpa/pom.xml @@ -35,7 +35,7 @@ 1.12.1.RELEASE 1.10.1.RELEASE 1.0.2 - 1.1.2 + 1.1.3 6.9.6 1.3 UTF-8 diff --git a/spring-data-mock/pom.xml b/spring-data-mock/pom.xml index 0e9266b1..cf9c348f 100644 --- a/spring-data-mock/pom.xml +++ b/spring-data-mock/pom.xml @@ -27,7 +27,7 @@ com.mmnaseri.utils spring-data-mock - 1.1.2 + 1.1.3 Spring Data Mock A framework for mocking Spring Data repositories