From 74cede5cdcc56afae84e78f9fe10a1c71ad5595f Mon Sep 17 00:00:00 2001 From: Phillip Webb Date: Mon, 12 Feb 2018 16:20:52 -0800 Subject: [PATCH] Migrate integration tests to context runner Migrate `IntegrationAutoConfigurationTests` to use the `ApplicationContextRunner`. --- .../IntegrationAutoConfigurationTests.java | 225 ++++++++---------- 1 file changed, 103 insertions(+), 122 deletions(-) diff --git a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/integration/IntegrationAutoConfigurationTests.java b/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/integration/IntegrationAutoConfigurationTests.java index ce41c7b37c0..b6b634caed7 100644 --- a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/integration/IntegrationAutoConfigurationTests.java +++ b/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/integration/IntegrationAutoConfigurationTests.java @@ -16,26 +16,20 @@ package org.springframework.boot.autoconfigure.integration; -import java.util.Arrays; -import java.util.List; - import javax.management.MBeanServer; -import org.junit.After; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; +import org.springframework.boot.autoconfigure.AutoConfigurations; import org.springframework.boot.autoconfigure.integration.IntegrationAutoConfiguration.IntegrationComponentScanAutoConfiguration; import org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration; import org.springframework.boot.autoconfigure.jdbc.EmbeddedDataSourceConfiguration; import org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration; import org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration; -import org.springframework.boot.context.properties.source.ConfigurationPropertySources; import org.springframework.boot.jdbc.DataSourceInitializationMode; -import org.springframework.boot.test.util.TestPropertyValues; -import org.springframework.context.ConfigurableApplicationContext; -import org.springframework.context.annotation.AnnotationConfigApplicationContext; +import org.springframework.boot.test.context.runner.ApplicationContextRunner; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Primary; @@ -47,7 +41,6 @@ import org.springframework.integration.support.management.IntegrationManagementC import org.springframework.jdbc.BadSqlGrammarException; import org.springframework.jdbc.core.JdbcOperations; import org.springframework.jmx.export.MBeanExporter; -import org.springframework.test.context.support.TestPropertySourceUtils; import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.mock; @@ -64,158 +57,146 @@ public class IntegrationAutoConfigurationTests { @Rule public ExpectedException thrown = ExpectedException.none(); - private AnnotationConfigApplicationContext context; - - @After - public void close() { - if (this.context != null) { - this.context.close(); - if (this.context.getParent() != null) { - ((ConfigurableApplicationContext) this.context.getParent()).close(); - } - } - } + private ApplicationContextRunner contextRunner = new ApplicationContextRunner() + .withConfiguration(AutoConfigurations.of(JmxAutoConfiguration.class, + IntegrationAutoConfiguration.class)); @Test public void integrationIsAvailable() { - load(); - assertThat(this.context.getBean(TestGateway.class)).isNotNull(); - assertThat(this.context.getBean(IntegrationComponentScanAutoConfiguration.class)) - .isNotNull(); + this.contextRunner.run((context) -> { + assertThat(context).hasSingleBean(TestGateway.class); + assertThat(context) + .hasSingleBean(IntegrationComponentScanAutoConfiguration.class); + }); } @Test public void explicitIntegrationComponentScan() { - this.context = new AnnotationConfigApplicationContext(); - this.context.register(IntegrationComponentScanConfiguration.class, - JmxAutoConfiguration.class, IntegrationAutoConfiguration.class); - this.context.refresh(); - assertThat(this.context.getBean(TestGateway.class)).isNotNull(); - assertThat(this.context - .getBeansOfType(IntegrationComponentScanAutoConfiguration.class)) - .isEmpty(); + this.contextRunner + .withUserConfiguration(IntegrationComponentScanConfiguration.class) + .run((context) -> { + assertThat(context).hasSingleBean(TestGateway.class); + assertThat(context).doesNotHaveBean( + IntegrationComponentScanAutoConfiguration.class); + }); } @Test public void parentContext() { - load(); - AnnotationConfigApplicationContext parent = this.context; - this.context = new AnnotationConfigApplicationContext(); - ConfigurationPropertySources.attach(this.context.getEnvironment()); - this.context.setParent(parent); - this.context.register(JmxAutoConfiguration.class, - IntegrationAutoConfiguration.class); - TestPropertySourceUtils.addInlinedPropertiesToEnvironment(this.context, - "spring.jmx.default_domain=org.foo"); - this.context.refresh(); - assertThat(this.context.getBean(HeaderChannelRegistry.class)).isNotNull(); + this.contextRunner.run((context) -> { + this.contextRunner.withParent(context) + .withPropertyValues("spring.jmx.default_domain=org.foo") + .run((child) -> { + assertThat(child).hasSingleBean(HeaderChannelRegistry.class); + }); + }); } @Test public void jmxIntegrationEnabledByDefault() { - load(); - MBeanServer mBeanServer = this.context.getBean(MBeanServer.class); - assertDomains(mBeanServer, true, "org.springframework.integration", - "org.springframework.integration.monitor"); - Object bean = this.context - .getBean(IntegrationManagementConfigurer.MANAGEMENT_CONFIGURER_NAME); - assertThat(bean).isNotNull(); + this.contextRunner.run((context) -> { + MBeanServer mBeanServer = context.getBean(MBeanServer.class); + assertThat(mBeanServer.getDomains()).contains( + "org.springframework.integration", + "org.springframework.integration.monitor"); + assertThat(context) + .hasBean(IntegrationManagementConfigurer.MANAGEMENT_CONFIGURER_NAME); + }); } @Test public void disableJmxIntegration() { - load("spring.jmx.enabled=false"); - assertThat(this.context.getBeansOfType(MBeanServer.class)).hasSize(0); - assertThat(this.context.getBeansOfType(IntegrationManagementConfigurer.class)) - .isNotEmpty(); // As of Boot 2.0 we always configure + this.contextRunner.withPropertyValues("spring.jmx.enabled=false") + .run((context) -> { + assertThat(context).doesNotHaveBean(MBeanServer.class); + assertThat(context) + .hasSingleBean(IntegrationManagementConfigurer.class); + }); } @Test public void customizeJmxDomain() { - load("spring.jmx.default_domain=org.foo"); - MBeanServer mBeanServer = this.context.getBean(MBeanServer.class); - assertDomains(mBeanServer, true, "org.foo"); - assertDomains(mBeanServer, false, "org.springframework.integration", - "org.springframework.integration.monitor"); + this.contextRunner.withPropertyValues("spring.jmx.default_domain=org.foo") + .run((context) -> { + MBeanServer mBeanServer = context.getBean(MBeanServer.class); + assertThat(mBeanServer.getDomains()).contains("org.foo") + .doesNotContain("org.springframework.integration", + "org.springframework.integration.monitor"); + }); } @Test public void primaryExporterIsAllowed() { - load(new Class[] { CustomMBeanExporter.class }); - assertThat(this.context.getBeansOfType(MBeanExporter.class)).hasSize(2); - assertThat(this.context.getBean(MBeanExporter.class)) - .isSameAs(this.context.getBean("myMBeanExporter")); + this.contextRunner.withUserConfiguration(CustomMBeanExporter.class) + .run((context) -> { + assertThat(context).getBeans(MBeanExporter.class).hasSize(2); + assertThat(context.getBean(MBeanExporter.class)) + .isSameAs(context.getBean("myMBeanExporter")); + }); } @Test public void integrationJdbcDataSourceInitializerEnabled() { - load(new Class[] { EmbeddedDataSourceConfiguration.class, - DataSourceTransactionManagerAutoConfiguration.class, - JdbcTemplateAutoConfiguration.class, IntegrationAutoConfiguration.class }, - "spring.datasource.generate-unique-name=true", - "spring.integration.jdbc.initialize-schema=always"); - assertThat(this.context.getBean(IntegrationProperties.class).getJdbc() - .getInitializeSchema()).isEqualTo(DataSourceInitializationMode.ALWAYS); - JdbcOperations jdbcOperations = this.context.getBean(JdbcOperations.class); - assertThat(jdbcOperations.queryForList("select * from INT_MESSAGE")).isEmpty(); - assertThat(jdbcOperations.queryForList("select * from INT_GROUP_TO_MESSAGE")) - .isEmpty(); - assertThat(jdbcOperations.queryForList("select * from INT_MESSAGE_GROUP")) - .isEmpty(); - assertThat(jdbcOperations.queryForList("select * from INT_LOCK")).isEmpty(); - assertThat(jdbcOperations.queryForList("select * from INT_CHANNEL_MESSAGE")) - .isEmpty(); + this.contextRunner.withUserConfiguration(EmbeddedDataSourceConfiguration.class) + .withConfiguration(AutoConfigurations.of( + DataSourceTransactionManagerAutoConfiguration.class, + JdbcTemplateAutoConfiguration.class, + IntegrationAutoConfiguration.class)) + .withPropertyValues("spring.datasource.generate-unique-name=true", + "spring.integration.jdbc.initialize-schema=always") + .run((context) -> { + IntegrationProperties properties = context + .getBean(IntegrationProperties.class); + assertThat(properties.getJdbc().getInitializeSchema()) + .isEqualTo(DataSourceInitializationMode.ALWAYS); + JdbcOperations jdbc = context.getBean(JdbcOperations.class); + assertThat(jdbc.queryForList("select * from INT_MESSAGE")).isEmpty(); + assertThat(jdbc.queryForList("select * from INT_GROUP_TO_MESSAGE")) + .isEmpty(); + assertThat(jdbc.queryForList("select * from INT_MESSAGE_GROUP")) + .isEmpty(); + assertThat(jdbc.queryForList("select * from INT_LOCK")).isEmpty(); + assertThat(jdbc.queryForList("select * from INT_CHANNEL_MESSAGE")) + .isEmpty(); + }); } @Test public void integrationJdbcDataSourceInitializerDisabled() { - load(new Class[] { EmbeddedDataSourceConfiguration.class, - DataSourceTransactionManagerAutoConfiguration.class, - JdbcTemplateAutoConfiguration.class, IntegrationAutoConfiguration.class }, - "spring.datasource.generate-unique-name=true", - "spring.integration.jdbc.initialize-schema=never"); - assertThat(this.context.getBean(IntegrationProperties.class).getJdbc() - .getInitializeSchema()).isEqualTo(DataSourceInitializationMode.NEVER); - JdbcOperations jdbcOperations = this.context.getBean(JdbcOperations.class); - this.thrown.expect(BadSqlGrammarException.class); - jdbcOperations.queryForList("select * from INT_MESSAGE"); + this.contextRunner.withUserConfiguration(EmbeddedDataSourceConfiguration.class) + .withConfiguration(AutoConfigurations.of( + DataSourceTransactionManagerAutoConfiguration.class, + JdbcTemplateAutoConfiguration.class, + IntegrationAutoConfiguration.class)) + .withPropertyValues("spring.datasource.generate-unique-name=true", + "spring.integration.jdbc.initialize-schema=never") + .run((context) -> { + IntegrationProperties properties = context + .getBean(IntegrationProperties.class); + assertThat(properties.getJdbc().getInitializeSchema()) + .isEqualTo(DataSourceInitializationMode.NEVER); + JdbcOperations jdbc = context.getBean(JdbcOperations.class); + this.thrown.expect(BadSqlGrammarException.class); + jdbc.queryForList("select * from INT_MESSAGE"); + }); } @Test public void integrationJdbcDataSourceInitializerEnabledByDefaultWithEmbeddedDb() { - load(new Class[] { EmbeddedDataSourceConfiguration.class, - DataSourceTransactionManagerAutoConfiguration.class, - JdbcTemplateAutoConfiguration.class, IntegrationAutoConfiguration.class }, - "spring.datasource.generate-unique-name=true"); - assertThat(this.context.getBean(IntegrationProperties.class).getJdbc() - .getInitializeSchema()).isEqualTo(DataSourceInitializationMode.EMBEDDED); - JdbcOperations jdbcOperations = this.context.getBean(JdbcOperations.class); - jdbcOperations.queryForList("select * from INT_MESSAGE").isEmpty(); - } - - private static void assertDomains(MBeanServer mBeanServer, boolean expected, - String... domains) { - List actual = Arrays.asList(mBeanServer.getDomains()); - for (String domain : domains) { - assertThat(actual.contains(domain)).isEqualTo(expected); - } - } - - public void load(String... environment) { - load(null, environment); - } - - private void load(Class[] configs, String... environment) { - AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(); - TestPropertyValues.of(environment).applyTo(ctx); - if (configs != null) { - ctx.register(configs); - } - TestPropertySourceUtils.addInlinedPropertiesToEnvironment(ctx, environment); - ConfigurationPropertySources.attach(ctx.getEnvironment()); - ctx.register(JmxAutoConfiguration.class, IntegrationAutoConfiguration.class); - ctx.refresh(); - this.context = ctx; + this.contextRunner.withUserConfiguration(EmbeddedDataSourceConfiguration.class) + .withConfiguration(AutoConfigurations.of( + DataSourceTransactionManagerAutoConfiguration.class, + JdbcTemplateAutoConfiguration.class, + IntegrationAutoConfiguration.class)) + .withPropertyValues("spring.datasource.generate-unique-name=true") + .run((context) -> { + IntegrationProperties properties = context + .getBean(IntegrationProperties.class); + assertThat(properties.getJdbc().getInitializeSchema()) + .isEqualTo(DataSourceInitializationMode.EMBEDDED); + JdbcOperations jdbc = context.getBean(JdbcOperations.class); + jdbc.queryForList("select * from INT_MESSAGE").isEmpty(); + }); } @Configuration