From e4e56bbcc3e4242497a9ad9b89414e7e96230b13 Mon Sep 17 00:00:00 2001 From: Stephane Nicoll Date: Thu, 12 Apr 2018 15:23:36 +0200 Subject: [PATCH] Migrate to ApplicationContextRunner --- .../quartz/QuartzAutoConfigurationTests.java | 318 +++++++++--------- 1 file changed, 168 insertions(+), 150 deletions(-) diff --git a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/quartz/QuartzAutoConfigurationTests.java b/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/quartz/QuartzAutoConfigurationTests.java index 8fe619355c2..c1eaf917dc9 100644 --- a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/quartz/QuartzAutoConfigurationTests.java +++ b/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/quartz/QuartzAutoConfigurationTests.java @@ -21,8 +21,6 @@ import java.util.concurrent.Executors; import javax.sql.DataSource; -import com.zaxxer.hikari.HikariDataSource; -import org.junit.After; import org.junit.Rule; import org.junit.Test; import org.quartz.Calendar; @@ -31,7 +29,6 @@ import org.quartz.JobDetail; import org.quartz.JobExecutionContext; import org.quartz.JobKey; import org.quartz.Scheduler; -import org.quartz.SchedulerException; import org.quartz.SimpleScheduleBuilder; import org.quartz.Trigger; import org.quartz.TriggerBuilder; @@ -42,13 +39,14 @@ import org.quartz.simpl.RAMJobStore; import org.quartz.simpl.SimpleThreadPool; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.autoconfigure.AutoConfigurations; +import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration; +import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties; import org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration; -import org.springframework.boot.autoconfigure.jdbc.EmbeddedDataSourceConfiguration; -import org.springframework.boot.jdbc.DataSourceBuilder; +import org.springframework.boot.test.context.assertj.AssertableApplicationContext; +import org.springframework.boot.test.context.runner.ApplicationContextRunner; +import org.springframework.boot.test.context.runner.ContextConsumer; import org.springframework.boot.test.rule.OutputCapture; -import org.springframework.boot.test.util.TestPropertyValues; -import org.springframework.context.ConfigurableApplicationContext; -import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Import; @@ -59,7 +57,6 @@ import org.springframework.scheduling.quartz.LocalDataSourceJobStore; import org.springframework.scheduling.quartz.LocalTaskExecutorThreadPool; import org.springframework.scheduling.quartz.QuartzJobBean; import org.springframework.util.Assert; -import org.springframework.util.ObjectUtils; import static org.assertj.core.api.Assertions.assertThat; import static org.hamcrest.CoreMatchers.containsString; @@ -75,164 +72,179 @@ public class QuartzAutoConfigurationTests { @Rule public OutputCapture output = new OutputCapture(); - private ConfigurableApplicationContext context; + private final ApplicationContextRunner contextRunner = new ApplicationContextRunner() + .withPropertyValues("spring.datasource.generate-unique-name=true") + .withConfiguration(AutoConfigurations.of(QuartzAutoConfiguration.class)); - @After - public void closeContext() { - if (this.context != null) { - this.context.close(); - } + @Test + public void withNoDataSource() { + this.contextRunner.run((context) -> { + assertThat(context).hasSingleBean(Scheduler.class); + Scheduler scheduler = context.getBean(Scheduler.class); + assertThat(scheduler.getMetaData().getJobStoreClass()) + .isAssignableFrom(RAMJobStore.class); + }); } @Test - public void withNoDataSource() throws Exception { - load(); - assertThat(this.context.getBeansOfType(Scheduler.class)).hasSize(1); - Scheduler scheduler = this.context.getBean(Scheduler.class); - assertThat(scheduler.getMetaData().getJobStoreClass()) - .isAssignableFrom(RAMJobStore.class); + public void withDataSourceUseMemoryByDefault() { + this.contextRunner.withConfiguration(AutoConfigurations.of( + DataSourceAutoConfiguration.class, + DataSourceTransactionManagerAutoConfiguration.class)).run((context) -> { + assertThat(context).hasSingleBean(Scheduler.class); + Scheduler scheduler = context.getBean(Scheduler.class); + assertThat(scheduler.getMetaData().getJobStoreClass()) + .isAssignableFrom(RAMJobStore.class); + }); } @Test - public void withDataSourceUseMemoryByDefault() throws Exception { - load(new Class[] { EmbeddedDataSourceConfiguration.class, - DataSourceTransactionManagerAutoConfiguration.class }); - assertThat(this.context.getBeansOfType(Scheduler.class)).hasSize(1); - Scheduler scheduler = this.context.getBean(Scheduler.class); - assertThat(scheduler.getMetaData().getJobStoreClass()) - .isAssignableFrom(RAMJobStore.class); + public void withDataSource() { + this.contextRunner.withUserConfiguration(QuartzJobsConfiguration.class) + .withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class, + DataSourceTransactionManagerAutoConfiguration.class)) + .withPropertyValues("spring.quartz.job-store-type=jdbc") + .run(assertDataSourceJobStore("dataSource")); } @Test - public void withDataSource() throws Exception { - load(new Class[] { QuartzJobsConfiguration.class, - EmbeddedDataSourceConfiguration.class, - DataSourceTransactionManagerAutoConfiguration.class }, - "spring.quartz.job-store-type=jdbc"); - testWithDataSource(); - } - - @Test - public void withDataSourceNoTransactionManager() throws Exception { - load(new Class[] { QuartzJobsConfiguration.class, - EmbeddedDataSourceConfiguration.class }, - "spring.quartz.job-store-type=jdbc"); - testWithDataSource(); - } - - private void testWithDataSource() throws SchedulerException { - assertThat(this.context.getBeansOfType(Scheduler.class)).hasSize(1); - Scheduler scheduler = this.context.getBean(Scheduler.class); - assertThat(scheduler.getMetaData().getJobStoreClass()) - .isAssignableFrom(LocalDataSourceJobStore.class); - JdbcTemplate jdbcTemplate = new JdbcTemplate( - this.context.getBean(DataSource.class)); - assertThat(jdbcTemplate.queryForObject("SELECT COUNT(*) FROM QRTZ_JOB_DETAILS", - Integer.class)).isEqualTo(2); - assertThat(jdbcTemplate.queryForObject( - "SELECT COUNT(*) FROM QRTZ_SIMPLE_TRIGGERS", Integer.class)).isEqualTo(0); - } - - @Test - public void withTaskExecutor() throws Exception { - load(QuartzExecutorConfiguration.class); - assertThat(this.context.getBeansOfType(Scheduler.class)).hasSize(1); - Scheduler scheduler = this.context.getBean(Scheduler.class); - assertThat(scheduler.getMetaData().getThreadPoolClass()) - .isEqualTo(LocalTaskExecutorThreadPool.class); - } - - @Test - public void withMultipleTaskExecutors() throws Exception { - load(QuartzMultipleExecutorsConfiguration.class); - assertThat(this.context.getBeansOfType(Executor.class)).hasSize(2); - assertThat(this.context.getBeansOfType(Scheduler.class)).hasSize(1); - Scheduler scheduler = this.context.getBean(Scheduler.class); - assertThat(scheduler.getMetaData().getThreadPoolClass()) - .isEqualTo(SimpleThreadPool.class); - } - - @Test - public void withMultipleTaskExecutorsWithPrimary() throws Exception { - load(QuartzMultipleExecutorsWithPrimaryConfiguration.class); - assertThat(this.context.getBeansOfType(Executor.class)).hasSize(2); - assertThat(this.context.getBeansOfType(Scheduler.class)).hasSize(1); - Scheduler scheduler = this.context.getBean(Scheduler.class); - assertThat(scheduler.getMetaData().getThreadPoolClass()) - .isEqualTo(LocalTaskExecutorThreadPool.class); - } - - @Test - public void withMultipleTaskExecutorsWithCustomizer() throws Exception { - load(QuartzMultipleExecutorsWithCustomizerConfiguration.class); - assertThat(this.context.getBeansOfType(Executor.class)).hasSize(3); - assertThat(this.context.getBeansOfType(Scheduler.class)).hasSize(1); - Scheduler scheduler = this.context.getBean(Scheduler.class); - assertThat(scheduler.getMetaData().getThreadPoolClass()) - .isEqualTo(LocalTaskExecutorThreadPool.class); - } - - @Test - public void withConfiguredJobAndTrigger() throws Exception { - load(QuartzFullConfiguration.class, "test-name=withConfiguredJobAndTrigger"); - assertThat(this.context.getBeansOfType(Scheduler.class)).hasSize(1); - Scheduler scheduler = this.context.getBean(Scheduler.class); - assertThat(scheduler.getJobDetail(JobKey.jobKey("fooJob"))).isNotNull(); - assertThat(scheduler.getTrigger(TriggerKey.triggerKey("fooTrigger"))).isNotNull(); - Thread.sleep(1000L); - this.output.expect(containsString("withConfiguredJobAndTrigger")); - this.output.expect(containsString("jobDataValue")); - } - - @Test - public void withConfiguredCalendars() throws Exception { - load(QuartzCalendarsConfiguration.class); - assertThat(this.context.getBeansOfType(Scheduler.class)).hasSize(1); - Scheduler scheduler = this.context.getBean(Scheduler.class); - assertThat(scheduler.getCalendar("weekly")).isNotNull(); - assertThat(scheduler.getCalendar("monthly")).isNotNull(); - } - - @Test - public void withQuartzProperties() throws Exception { - load("spring.quartz.properties.org.quartz.scheduler.instanceId=FOO"); - assertThat(this.context.getBeansOfType(Scheduler.class)).hasSize(1); - Scheduler scheduler = this.context.getBean(Scheduler.class); - assertThat(scheduler.getSchedulerInstanceId()).isEqualTo("FOO"); - } - - @Test - public void withCustomizer() throws Exception { - load(QuartzCustomConfiguration.class); - assertThat(this.context.getBeansOfType(Scheduler.class)).hasSize(1); - Scheduler scheduler = this.context.getBean(Scheduler.class); - assertThat(scheduler.getSchedulerName()).isEqualTo("fooScheduler"); + public void withDataSourceNoTransactionManager() { + this.contextRunner.withUserConfiguration(QuartzJobsConfiguration.class) + .withConfiguration(AutoConfigurations.of( + DataSourceAutoConfiguration.class)) + .withPropertyValues("spring.quartz.job-store-type=jdbc") + .run(assertDataSourceJobStore("dataSource")); } @Test public void dataSourceWithQuartzDataSourceQualifierUsedWhenMultiplePresent() { - load(MultipleDataSourceConfiguration.class, "spring.quartz.job-store-type=jdbc"); + this.contextRunner + .withUserConfiguration(QuartzJobsConfiguration.class, + MultipleDataSourceConfiguration.class) + .withPropertyValues("spring.quartz.job-store-type=jdbc") + .run(assertDataSourceJobStore("quartzDataSource")); } - private void load(String... environment) { - load(new Class[0], environment); + private ContextConsumer assertDataSourceJobStore( + String datasourceName) { + return (context) -> { + assertThat(context).hasSingleBean(Scheduler.class); + Scheduler scheduler = context.getBean(Scheduler.class); + assertThat(scheduler.getMetaData().getJobStoreClass()) + .isAssignableFrom(LocalDataSourceJobStore.class); + JdbcTemplate jdbcTemplate = new JdbcTemplate(context.getBean( + datasourceName, DataSource.class)); + assertThat(jdbcTemplate.queryForObject( + "SELECT COUNT(*) FROM QRTZ_JOB_DETAILS", Integer.class)).isEqualTo(2); + assertThat(jdbcTemplate.queryForObject( + "SELECT COUNT(*) FROM QRTZ_SIMPLE_TRIGGERS", Integer.class)) + .isEqualTo(0); + }; } - private void load(Class config, String... environment) { - load(new Class[] { config }, environment); + @Test + public void withTaskExecutor() { + this.contextRunner.withUserConfiguration(QuartzExecutorConfiguration.class) + .run((context) -> { + assertThat(context).hasSingleBean(Scheduler.class); + Scheduler scheduler = context.getBean(Scheduler.class); + assertThat(scheduler.getMetaData().getThreadPoolClass()) + .isEqualTo(LocalTaskExecutorThreadPool.class); + }); } - private void load(Class[] configs, String... environment) { - AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(); - TestPropertyValues.of(environment).applyTo(ctx); - if (!ObjectUtils.isEmpty(configs)) { - ctx.register(configs); - } - ctx.register(QuartzAutoConfiguration.class); - ctx.refresh(); - this.context = ctx; + @Test + public void withMultipleTaskExecutors() { + this.contextRunner + .withUserConfiguration(QuartzMultipleExecutorsConfiguration.class) + .run((context) -> { + assertThat(context.getBeansOfType(Executor.class)).hasSize(2); + assertThat(context).hasSingleBean(Scheduler.class); + Scheduler scheduler = context.getBean(Scheduler.class); + assertThat(scheduler.getMetaData().getThreadPoolClass()) + .isEqualTo(SimpleThreadPool.class); + }); } + @Test + public void withMultipleTaskExecutorsWithPrimary() { + this.contextRunner + .withUserConfiguration( + QuartzMultipleExecutorsWithPrimaryConfiguration.class) + .run((context) -> { + assertThat(context.getBeansOfType(Executor.class)).hasSize(2); + assertThat(context).hasSingleBean(Scheduler.class); + Scheduler scheduler = context.getBean(Scheduler.class); + assertThat(scheduler.getMetaData().getThreadPoolClass()) + .isEqualTo(LocalTaskExecutorThreadPool.class); + }); + } + + @Test + public void withMultipleTaskExecutorsWithCustomizer() { + this.contextRunner + .withUserConfiguration( + QuartzMultipleExecutorsWithCustomizerConfiguration.class) + .run((context) -> { + assertThat(context.getBeansOfType(Executor.class)).hasSize(3); + assertThat(context).hasSingleBean(Scheduler.class); + Scheduler scheduler = context.getBean(Scheduler.class); + assertThat(scheduler.getMetaData().getThreadPoolClass()) + .isEqualTo(LocalTaskExecutorThreadPool.class); + }); + } + + @Test + public void withConfiguredJobAndTrigger() { + this.contextRunner.withUserConfiguration(QuartzFullConfiguration.class) + .withPropertyValues("test-name=withConfiguredJobAndTrigger") + .run((context) -> { + assertThat(context).hasSingleBean(Scheduler.class); + Scheduler scheduler = context.getBean(Scheduler.class); + assertThat(scheduler.getJobDetail(JobKey.jobKey("fooJob"))) + .isNotNull(); + assertThat(scheduler.getTrigger(TriggerKey.triggerKey("fooTrigger"))) + .isNotNull(); + Thread.sleep(1000L); + this.output.expect(containsString("withConfiguredJobAndTrigger")); + this.output.expect(containsString("jobDataValue")); + }); + } + + @Test + public void withConfiguredCalendars() { + this.contextRunner.withUserConfiguration(QuartzCalendarsConfiguration.class) + .run((context) -> { + assertThat(context).hasSingleBean(Scheduler.class); + Scheduler scheduler = context.getBean(Scheduler.class); + assertThat(scheduler.getCalendar("weekly")).isNotNull(); + assertThat(scheduler.getCalendar("monthly")).isNotNull(); + }); + } + + @Test + public void withQuartzProperties() { + this.contextRunner.withPropertyValues( + "spring.quartz.properties.org.quartz.scheduler.instanceId=FOO") + .run((context) -> { + assertThat(context).hasSingleBean(Scheduler.class); + Scheduler scheduler = context.getBean(Scheduler.class); + assertThat(scheduler.getSchedulerInstanceId()).isEqualTo("FOO"); + }); + } + + @Test + public void withCustomizer() { + this.contextRunner.withUserConfiguration(QuartzCustomConfiguration.class) + .run((context) -> { + assertThat(context).hasSingleBean(Scheduler.class); + Scheduler scheduler = context.getBean(Scheduler.class); + assertThat(scheduler.getSchedulerName()).isEqualTo("fooScheduler"); + }); + } + + + @Import(ComponentThatUsesScheduler.class) @Configuration protected static class BaseQuartzConfiguration { @@ -358,15 +370,21 @@ public class QuartzAutoConfigurationTests { @Bean @Primary - public DataSource applicationDataSource() { - return new HikariDataSource(); + public DataSource applicationDataSource() throws Exception { + return createTestDataSource(); } @QuartzDataSource @Bean - public DataSource quartzDataSource() { - return DataSourceBuilder.create().url("jdbc:hsqldb:mem:quartztest") - .username("sa").build(); + public DataSource quartzDataSource() throws Exception { + return createTestDataSource(); + } + + private DataSource createTestDataSource() throws Exception { + DataSourceProperties properties = new DataSourceProperties(); + properties.setGenerateUniqueName(true); + properties.afterPropertiesSet(); + return properties.initializeDataSourceBuilder().build(); } }