BAEL-20856 Move Spring Boot Autorconfiguration module

spring-boot-modules/spring-boot-autoconfiguration/src/test/java/com/baeldung/autoconfiguration/AutoconfigurationLiveTest.java

@@ -0,0 +1,27 @@
+package com.baeldung.autoconfiguration;
+
+import com.baeldung.autoconfiguration.example.AutoconfigurationApplication;
+import com.baeldung.autoconfiguration.example.MyUser;
+import com.baeldung.autoconfiguration.example.MyUserRepository;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@SpringBootTest(classes = AutoconfigurationApplication.class)
+@EnableJpaRepositories(basePackages = { "com.baeldung.autoconfiguration.example" })
+public class AutoconfigurationLiveTest {
+
+    @Autowired
+    private MyUserRepository userRepository;
+
+    @Test
+    public void whenSaveUser_thenOk() {
+        MyUser user = new MyUser("user@email.com");
+        userRepository.save(user);
+    }
+
+}

spring-boot-modules/spring-boot-autoconfiguration/src/test/java/com/baeldung/autoconfiguration/ConditionalOnBeanIntegrationTest.java

@@ -0,0 +1,77 @@
+package com.baeldung.autoconfiguration;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+public class ConditionalOnBeanIntegrationTest {
+
+    private final ApplicationContextRunner contextRunner = new ApplicationContextRunner();
+
+    @Test
+    public void whenDependentBeanIsPresent_thenConditionalBeanCreated() {
+        this.contextRunner.withUserConfiguration(BasicConfiguration.class, ConditionalOnBeanConfiguration.class)
+            .run((context) -> {
+                assertThat(context).hasBean("created");
+                assertThat(context).getBean("created")
+                    .isEqualTo("This is always created");
+                assertThat(context).hasBean("createOnBean");
+                assertThat(context).getBean("createOnBean")
+                    .isEqualTo("This is created when bean (name=created) is present");
+            });
+    }
+
+    @Test
+    public void whenDependentBeanIsPresent_thenConditionalMissingBeanIgnored() {
+        this.contextRunner.withUserConfiguration(BasicConfiguration.class, ConditionalOnMissingBeanConfiguration.class)
+            .run((context) -> {
+                assertThat(context).hasBean("created");
+                assertThat(context).getBean("created")
+                    .isEqualTo("This is always created");
+                assertThat(context).doesNotHaveBean("createOnMissingBean");
+            });
+    }
+
+    @Test
+    public void whenDependentBeanIsNotPresent_thenConditionalMissingBeanCreated() {
+        this.contextRunner.withUserConfiguration(ConditionalOnMissingBeanConfiguration.class)
+            .run((context) -> {
+                assertThat(context).hasBean("createOnMissingBean");
+                assertThat(context).getBean("createOnMissingBean")
+                    .isEqualTo("This is created when bean (name=created) is missing");
+                assertThat(context).doesNotHaveBean("created");
+            });
+    }
+
+    @Configuration
+    protected static class BasicConfiguration {
+        @Bean
+        public String created() {
+            return "This is always created";
+        }
+    }
+
+    @Configuration
+    @ConditionalOnBean(name = "created")
+    protected static class ConditionalOnBeanConfiguration {
+        @Bean
+        public String createOnBean() {
+            return "This is created when bean (name=created) is present";
+        }
+    }
+
+    @Configuration
+    @ConditionalOnMissingBean(name = "created")
+    protected static class ConditionalOnMissingBeanConfiguration {
+        @Bean
+        public String createOnMissingBean() {
+            return "This is created when bean (name=created) is missing";
+        }
+    }
+
+}

spring-boot-modules/spring-boot-autoconfiguration/src/test/java/com/baeldung/autoconfiguration/ConditionalOnClassIntegrationTest.java

@@ -0,0 +1,76 @@
+package com.baeldung.autoconfiguration;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
+import org.springframework.boot.test.context.FilteredClassLoader;
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+public class ConditionalOnClassIntegrationTest {
+
+    private final ApplicationContextRunner contextRunner = new ApplicationContextRunner();
+
+    @Test
+    public void whenDependentClassIsPresent_thenBeanCreated() {
+        this.contextRunner.withUserConfiguration(ConditionalOnClassConfiguration.class)
+            .run(context -> {
+                assertThat(context).hasBean("created");
+                assertThat(context.getBean("created")).isEqualTo("This is created when ConditionalOnClassIntegrationTest is present on the classpath");
+            });
+    }
+
+    @Test
+    public void whenDependentClassIsPresent_thenBeanMissing() {
+        this.contextRunner.withUserConfiguration(ConditionalOnMissingClassConfiguration.class)
+            .run(context -> {
+                assertThat(context).doesNotHaveBean("missed");
+            });
+    }
+
+    @Test
+    public void whenDependentClassIsNotPresent_thenBeanMissing() {
+        this.contextRunner.withUserConfiguration(ConditionalOnClassConfiguration.class)
+            .withClassLoader(new FilteredClassLoader(ConditionalOnClassIntegrationTest.class))
+            .run((context) -> {
+                assertThat(context).doesNotHaveBean("created");
+                assertThat(context).doesNotHaveBean(ConditionalOnClassIntegrationTest.class);
+
+            });
+    }
+
+    @Test
+    public void whenDependentClassIsNotPresent_thenBeanCreated() {
+        this.contextRunner.withUserConfiguration(ConditionalOnMissingClassConfiguration.class)
+            .withClassLoader(new FilteredClassLoader(ConditionalOnClassIntegrationTest.class))
+            .run((context) -> {
+                assertThat(context).hasBean("missed");
+                assertThat(context).getBean("missed")
+                    .isEqualTo("This is missed when ConditionalOnClassIntegrationTest is present on the classpath");
+                assertThat(context).doesNotHaveBean(ConditionalOnClassIntegrationTest.class);
+
+            });
+    }
+
+    @Configuration
+    @ConditionalOnClass(ConditionalOnClassIntegrationTest.class)
+    protected static class ConditionalOnClassConfiguration {
+        @Bean
+        public String created() {
+            return "This is created when ConditionalOnClassIntegrationTest is present on the classpath";
+        }
+    }
+
+    @Configuration
+    @ConditionalOnMissingClass("com.baeldung.autoconfiguration.ConditionalOnClassIntegrationTest")
+    protected static class ConditionalOnMissingClassConfiguration {
+        @Bean
+        public String missed() {
+            return "This is missed when ConditionalOnClassIntegrationTest is present on the classpath";
+        }
+    }
+
+}

spring-boot-modules/spring-boot-autoconfiguration/src/test/java/com/baeldung/autoconfiguration/ConditionalOnPropertyIntegrationTest.java

@@ -0,0 +1,64 @@
+package com.baeldung.autoconfiguration;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.test.context.TestPropertySource;
+
+import com.baeldung.autoconfiguration.service.CustomService;
+import com.baeldung.autoconfiguration.service.DefaultService;
+import com.baeldung.autoconfiguration.service.SimpleService;
+
+public class ConditionalOnPropertyIntegrationTest {
+
+    private final ApplicationContextRunner contextRunner = new ApplicationContextRunner();
+
+    @Test
+    public void whenGivenCustomPropertyValue_thenCustomServiceCreated() {
+        this.contextRunner.withPropertyValues("com.baeldung.service=custom")
+            .withUserConfiguration(SimpleServiceConfiguration.class)
+            .run(context -> {
+                assertThat(context).hasBean("customService");
+                SimpleService simpleService = context.getBean(CustomService.class);
+                assertThat(simpleService.serve()).isEqualTo("Custom Service");
+                assertThat(context).doesNotHaveBean("defaultService");
+            });
+    }
+
+    @Test
+    public void whenGivenDefaultPropertyValue_thenDefaultServiceCreated() {
+        this.contextRunner.withPropertyValues("com.baeldung.service=default")
+            .withUserConfiguration(SimpleServiceConfiguration.class)
+            .run(context -> {
+                assertThat(context).hasBean("defaultService");
+                SimpleService simpleService = context.getBean(DefaultService.class);
+                assertThat(simpleService.serve()).isEqualTo("Default Service");
+                assertThat(context).doesNotHaveBean("customService");
+            });
+    }
+
+    @Configuration
+    @TestPropertySource("classpath:ConditionalOnPropertyTest.properties")
+    protected static class SimpleServiceConfiguration {
+
+        @Bean
+        @ConditionalOnProperty(name = "com.baeldung.service", havingValue = "default")
+        @ConditionalOnMissingBean
+        public DefaultService defaultService() {
+            return new DefaultService();
+        }
+
+        @Bean
+        @ConditionalOnProperty(name = "com.baeldung.service", havingValue = "custom")
+        @ConditionalOnMissingBean
+        public CustomService customService() {
+            return new CustomService();
+        }
+    }
+
+}

spring-boot-modules/spring-boot-autoconfiguration/src/test/java/com/baeldung/autoconfiguration/SpringContextLiveTest.java

@@ -0,0 +1,19 @@
+package com.baeldung.autoconfiguration;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import com.baeldung.autoconfiguration.example.AutoconfigurationApplication;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = AutoconfigurationApplication.class)
+@EnableJpaRepositories(basePackages = { "com.baeldung.autoconfiguration.example" })
+public class SpringContextLiveTest {
+
+    @Test
+    public void whenSpringContextIsBootstrapped_thenNoExceptions() {
+    }
+}

spring-boot-modules/spring-boot-autoconfiguration/src/test/java/com/baeldung/autoconfiguration/annotationprocessor/DatabasePropertiesIntegrationTest.java

@@ -0,0 +1,31 @@
+package com.baeldung.autoconfiguration.annotationprocessor;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.TestPropertySource;
+import org.springframework.test.context.junit4.SpringRunner;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = AnnotationProcessorApplication.class)
+@TestPropertySource("classpath:databaseproperties-test.properties")
+public class DatabasePropertiesIntegrationTest {
+
+    @Autowired
+    private DatabaseProperties databaseProperties;
+
+    @Test
+    public void whenSimplePropertyQueriedThenReturnsPropertyValue() throws Exception {
+        Assert.assertEquals("Incorrectly bound Username property", "baeldung", databaseProperties.getUsername());
+        Assert.assertEquals("Incorrectly bound Password property", "password", databaseProperties.getPassword());
+    }
+    
+    @Test
+    public void whenNestedPropertyQueriedThenReturnsPropertyValue() throws Exception {
+    	Assert.assertEquals("Incorrectly bound Server IP nested property", "127.0.0.1", databaseProperties.getServer().getIp());
+        Assert.assertEquals("Incorrectly bound Server Port nested property", 3306, databaseProperties.getServer().getPort());
+    }   
+
+}