Merge pull request #178 from zonkyio/bean-definition-instance-supplier

tomix26 · web-flow · commit 1e7c0ec23787 · 2021-08-29T15:35:58.000+02:00
#11 Use instance supplier to define data source bean instead of the previous bean factory
diff --git a/embedded-database-spring-test/src/main/java/io/zonky/test/db/EmbeddedDatabaseContextCustomizerFactory.java b/embedded-database-spring-test/src/main/java/io/zonky/test/db/EmbeddedDatabaseContextCustomizerFactory.java
@@ -21,6 +21,7 @@
 import io.zonky.test.db.config.EmbeddedDatabaseAutoConfiguration;
 import io.zonky.test.db.config.EmbeddedDatabaseCondition;
 import io.zonky.test.db.context.DatabaseContext;
+import io.zonky.test.db.context.DatabaseTargetSource;
 import io.zonky.test.db.context.DefaultDatabaseContext;
 import io.zonky.test.db.context.EmbeddedDatabaseFactoryBean;
 import io.zonky.test.db.provider.DatabaseProvider;
@@ -32,10 +33,12 @@
 import io.zonky.test.db.util.PropertyUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.aop.framework.ProxyFactory;
 import org.springframework.beans.factory.ObjectFactory;
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.config.BeanDefinitionHolder;
 import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
+import org.springframework.beans.factory.support.AbstractBeanDefinition;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
 import org.springframework.beans.factory.support.RootBeanDefinition;
@@ -68,6 +71,7 @@
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Set;
+import java.util.function.Supplier;
 
 import static java.util.stream.Collectors.toCollection;
 
@@ -302,11 +306,20 @@ public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
                         });
 
                 RootBeanDefinition dataSourceDefinition = new RootBeanDefinition();
-                dataSourceDefinition.setBeanClass(EmbeddedDatabaseFactoryBean.class);
-                dataSourceDefinition.setPrimary(dataSourceInfo.getBeanDefinition().isPrimary());
-                dataSourceDefinition.getConstructorArgumentValues()
-                        .addIndexedArgumentValue(0, (ObjectFactory<DatabaseContext>) () ->
-                                beanFactory.getBean(contextBeanName, DatabaseContext.class));
+                if (ClassUtils.hasMethod(AbstractBeanDefinition.class, "setInstanceSupplier", Supplier.class)) {
+                    dataSourceDefinition.setBeanClass(DataSource.class);
+                    dataSourceDefinition.setPrimary(dataSourceInfo.getBeanDefinition().isPrimary());
+                    dataSourceDefinition.setInstanceSupplier(() -> {
+                        DatabaseContext databaseContext = beanFactory.getBean(contextBeanName, DatabaseContext.class);
+                        return ProxyFactory.getProxy(DataSource.class, new DatabaseTargetSource(databaseContext));
+                    });
+                } else {
+                    dataSourceDefinition.setBeanClass(EmbeddedDatabaseFactoryBean.class);
+                    dataSourceDefinition.setPrimary(dataSourceInfo.getBeanDefinition().isPrimary());
+                    dataSourceDefinition.getConstructorArgumentValues()
+                            .addIndexedArgumentValue(0, (ObjectFactory<DatabaseContext>) () ->
+                                    beanFactory.getBean(contextBeanName, DatabaseContext.class));
+                }
 
                 logger.info("Replacing '{}' DataSource bean with embedded version", dataSourceBeanName);
 
diff --git a/embedded-database-spring-test/src/main/java/io/zonky/test/db/context/EmbeddedDatabaseFactoryBean.java b/embedded-database-spring-test/src/main/java/io/zonky/test/db/context/EmbeddedDatabaseFactoryBean.java
@@ -27,7 +27,6 @@
  * Implementation of the {@link org.springframework.beans.factory.FactoryBean} interface
  * that provides fully cacheable instances of the embedded postgres database.
  */
-// TODO: replace by using factory method (java configuration)
 public class EmbeddedDatabaseFactoryBean implements FactoryBean<DataSource>, Ordered {
 
     private final ObjectFactory<DatabaseContext> databaseContextProvider;
diff --git a/embedded-database-spring-test/src/test/java/io/zonky/test/db/FlywayTransactionalIntegrationTest.java b/embedded-database-spring-test/src/test/java/io/zonky/test/db/FlywayTransactionalIntegrationTest.java
@@ -20,6 +20,7 @@
 import io.zonky.test.category.FlywayTestSuite;
 import io.zonky.test.db.context.DatabaseContext;
 import io.zonky.test.db.flyway.FlywayWrapper;
+import io.zonky.test.db.flyway.OptimizedFlywayTestExecutionListener;
 import io.zonky.test.db.flyway.preparer.MigrateFlywayDatabasePreparer;
 import io.zonky.test.support.ConditionalTestRule;
 import io.zonky.test.support.SpyPostProcessor;
@@ -38,10 +39,13 @@
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.test.context.TestExecutionListeners;
 import org.springframework.test.context.TestPropertySource;
 import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.test.context.support.DependencyInjectionTestExecutionListener;
 import org.springframework.test.context.transaction.AfterTransaction;
 import org.springframework.test.context.transaction.BeforeTransaction;
+import org.springframework.test.context.transaction.TransactionalTestExecutionListener;
 
 import javax.sql.DataSource;
 
@@ -61,6 +65,11 @@
         "spring.liquibase.enabled=false"
 })
 @JdbcTest
+@TestExecutionListeners(listeners = {
+        DependencyInjectionTestExecutionListener.class,
+        OptimizedFlywayTestExecutionListener.class,
+        TransactionalTestExecutionListener.class
+})
 public class FlywayTransactionalIntegrationTest {
 
     @ClassRule
diff --git a/embedded-database-spring-test/src/test/java/io/zonky/test/db/SpringProxiedBeanMethodsIntegrationTest.java b/embedded-database-spring-test/src/test/java/io/zonky/test/db/SpringProxiedBeanMethodsIntegrationTest.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.zonky.test.db;
+
+import io.zonky.test.category.SpringTestSuite;
+import io.zonky.test.support.ConditionalTestRule;
+import io.zonky.test.support.TestAssumptions;
+import org.junit.ClassRule;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import javax.sql.DataSource;
+
+import static io.zonky.test.db.AutoConfigureEmbeddedDatabase.DatabaseType.POSTGRES;
+import static io.zonky.test.support.MockitoAssertions.mock;
+import static org.assertj.core.api.Assertions.assertThat;
+
+@RunWith(SpringRunner.class)
+@Category(SpringTestSuite.class)
+@AutoConfigureEmbeddedDatabase(type = POSTGRES)
+public class SpringProxiedBeanMethodsIntegrationTest {
+
+    @ClassRule
+    public static ConditionalTestRule conditionalTestRule = new ConditionalTestRule(TestAssumptions::assumeSpringSupportsInstanceSupplier);
+
+    @Configuration
+    static class Config {
+
+        @Bean
+        public DataSource dataSource() {
+            return Mockito.mock(DataSource.class);
+        }
+
+        @Bean
+        public JdbcTemplate jdbcTemplate() {
+            return new JdbcTemplate(dataSource());
+        }
+    }
+
+    @Autowired
+    private DataSource dataSource;
+
+    @Autowired
+    private JdbcTemplate jdbcTemplate;
+
+    @Test
+    public void checkInitializedBeans() {
+        assertThat(dataSource).isNotNull().isNot(mock());
+        assertThat(jdbcTemplate).isNotNull();
+    }
+}
diff --git a/embedded-database-spring-test/src/test/java/io/zonky/test/support/MockitoAssertions.java b/embedded-database-spring-test/src/test/java/io/zonky/test/support/MockitoAssertions.java
@@ -28,8 +28,8 @@ public class MockitoAssertions {
 
     private MockitoAssertions() {}
 
-    public static <T> Condition<T> mockWithName(String name) {
-        Condition<T> isMock = new Condition<T>("target object should be a mock") {
+    public static <T> Condition<T> mock() {
+        return new Condition<T>("target object should be a mock") {
             @Override
             public boolean matches(T object) {
                 try {
@@ -39,6 +39,9 @@ public boolean matches(T object) {
                 }
             }
         };
+    }
+
+    public static <T> Condition<T> mockWithName(String name) {
         Condition<T> hasName = new Condition<T>("mock should have a specified name") {
             @Override
             public boolean matches(T object) {
@@ -50,6 +53,6 @@ public boolean matches(T object) {
             }
         };
 
-        return allOf(isMock, hasName);
+        return allOf(mock(), hasName);
     }
 }
diff --git a/embedded-database-spring-test/src/test/java/io/zonky/test/support/TestAssumptions.java b/embedded-database-spring-test/src/test/java/io/zonky/test/support/TestAssumptions.java
@@ -1,8 +1,11 @@
 package io.zonky.test.support;
 
 import io.zonky.test.db.flyway.FlywayClassUtils;
+import org.springframework.beans.factory.support.AbstractBeanDefinition;
 import org.springframework.util.ClassUtils;
 
+import java.util.function.Supplier;
+
 import static org.junit.Assume.assumeTrue;
 
 public class TestAssumptions {
@@ -25,6 +28,10 @@ private static void assumeFlywayVersion(int minVersion) {
         assumeTrue(FlywayClassUtils.getFlywayVersion() >= minVersion);
     }
 
+    public static void assumeSpringSupportsInstanceSupplier() {
+        assumeTrue(ClassUtils.hasMethod(AbstractBeanDefinition.class, "setInstanceSupplier", Supplier.class));
+    }
+
     public static void assumeSpringBootSupportsJdbcTestAnnotation() {
         assumeTrue(ClassUtils.isPresent("org.springframework.boot.test.autoconfigure.jdbc.JdbcTest", TestAssumptions.class.getClassLoader()));
     }

Original file line number	Diff line number	Diff line change
`@@ -28,8 +28,8 @@ public class MockitoAssertions {`
`28`	`28`
`29`	`29`	`private MockitoAssertions() {}`
`30`	`30`
`31`		`- public static <T> Condition<T> mockWithName(String name) {`
`32`		`- Condition<T> isMock = new Condition<T>("target object should be a mock") {`
	`31`	`+ public static <T> Condition<T> mock() {`
	`32`	`+ return new Condition<T>("target object should be a mock") {`
`33`	`33`	`@Override`
`34`	`34`	`public boolean matches(T object) {`
`35`	`35`	`try {`
`@@ -39,6 +39,9 @@ public boolean matches(T object) {`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`	`};`
	`42`	`+ }`
	`43`	`+`
	`44`	`+ public static <T> Condition<T> mockWithName(String name) {`
`42`	`45`	`Condition<T> hasName = new Condition<T>("mock should have a specified name") {`
`43`	`46`	`@Override`
`44`	`47`	`public boolean matches(T object) {`
`@@ -50,6 +53,6 @@ public boolean matches(T object) {`
`50`	`53`	`}`
`51`	`54`	`};`
`52`	`55`
`53`		`- return allOf(isMock, hasName);`
	`56`	`+ return allOf(mock(), hasName);`
`54`	`57`	`}`
`55`	`58`	`}`