Update Task to BOOT 2.1.M1

Migrating to use ApplicationContextRunner or ImportAutoConfiguration with SpringApp.run, instead of SpringApplicationBuilder, because builder does not handle AutoConfiguration properly

SimpleTaskAutoConfiguration now has an annotation AutoConfigureBefore the BatchTaskAutoConfig so that it is processed prior.  THis is so that that BatchTaskAutoConfig can create the appropriate beans

SimpleTaskAutoConfiguration has new annotations so that it is AutoConfigured after BindingServiceConfiguration and after SimpleTaskAutoConfiguration.  This is so that it does not attempt to start emitting messages before stream is ready and it can create the appropriate beans after SimpleTaskAutoConfiguration has run.

Renamed SimpleTaskConfiguration to SimpleTaskAutoConfiguration.

Task version updated to  2.1.0

Added missing headers

Updated documentation.

Deprecated EnableTask

Added ability to disable Task autoconfiguration.

Removed @EnableTask from tests

Resolves #439
Resolves #440
Resolves #448
Resolves #466

spring-cloud-task-batch/src/test/java/org/springframework/cloud/task/batch/configuration/TaskBatchTest.java

@@ -0,0 +1,38 @@
+/*
+ *  Copyright 2018 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 org.springframework.cloud.task.batch.configuration;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.springframework.boot.autoconfigure.ImportAutoConfiguration;
+
+/**
+ * Contains the common configurations to run a unit test for the task batch features of
+ * SCT.
+ *
+ * @author Glenn Renfro
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@ImportAutoConfiguration
+public @interface TaskBatchTest {
+}

spring-cloud-task-batch/src/test/java/org/springframework/cloud/task/batch/configuration/TaskJobLauncherAutoConfigurationTests.java

@@ -42,13 +42,10 @@ public class TaskJobLauncherAutoConfigurationTests {
 
 	@Test
 	public void testAutoBuiltDataSourceWithTaskJobLauncherCLR() {
-		this.contextRunner.
-				withPropertyValues("spring.cloud.task.batch.fail-on-job-failure=true").
-				run(context -> {
+		this.contextRunner.withPropertyValues("spring.cloud.task.batch.fail-on-job-failure=true").run(context -> {
 			assertThat(context).hasSingleBean(TaskJobLauncherCommandLineRunner.class);
-			assertThat(context).doesNotHaveBean(JobLauncherCommandLineRunner.class);
-					assertThat(context.getBean(TaskJobLauncherCommandLineRunner.class)
-							.getOrder())
+			assertThat(context.getBean(TaskJobLauncherCommandLineRunner.class)
+					.getOrder())
 							.isEqualTo(0);
 		});
 	}

spring-cloud-task-batch/src/test/java/org/springframework/cloud/task/batch/handler/TaskJobLauncherCommandLineRunnerCoreTests.java

@@ -16,11 +16,16 @@
 
 package org.springframework.cloud.task.batch.handler;
 
+
+import org.assertj.core.api.AssertionsForClassTypes;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.jupiter.api.function.Executable;
 import org.junit.runner.RunWith;
 
 import org.springframework.batch.core.Job;
+import org.springframework.batch.core.JobExecution;
+import org.springframework.batch.core.JobInstance;
 import org.springframework.batch.core.JobParameters;
 import org.springframework.batch.core.JobParametersBuilder;
 import org.springframework.batch.core.Step;
@@ -34,10 +39,12 @@ import org.springframework.batch.core.launch.JobLauncher;
 import org.springframework.batch.core.launch.support.RunIdIncrementer;
 import org.springframework.batch.core.launch.support.SimpleJobLauncher;
 import org.springframework.batch.core.repository.JobRepository;
+import org.springframework.batch.core.repository.JobRestartException;
 import org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean;
 import org.springframework.batch.core.step.tasklet.Tasklet;
 import org.springframework.batch.support.transaction.ResourcelessTransactionManager;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.cloud.task.batch.configuration.TaskBatchProperties;
 import org.springframework.cloud.task.listener.TaskException;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.core.task.SyncTaskExecutor;
@@ -47,6 +54,7 @@ import org.springframework.test.context.junit4.SpringRunner;
 import org.springframework.transaction.PlatformTransactionManager;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 /**
  * @author Glenn Renfro
@@ -64,6 +72,9 @@ public class TaskJobLauncherCommandLineRunnerCoreTests {
 	@Autowired
 	private JobExplorer jobExplorer;
 
+	@Autowired
+	private BatchConfiguration batchConfigurer;
+
 	@Autowired
 	private PlatformTransactionManager transactionManager;
 
@@ -79,12 +90,14 @@ public class TaskJobLauncherCommandLineRunnerCoreTests {
 
 	@Before
 	public void init() {
+		batchConfigurer.clear();
 		this.jobs = new JobBuilderFactory(this.jobRepository);
 		this.steps = new StepBuilderFactory(this.jobRepository, this.transactionManager);
 		Tasklet tasklet = (contribution, chunkContext) -> null;
 		this.step = this.steps.get("step").tasklet(tasklet).build();
 		this.job = this.jobs.get("job").start(this.step).build();
-		this.runner = new TaskJobLauncherCommandLineRunner(this.jobLauncher, this.jobExplorer);
+		this.runner = new TaskJobLauncherCommandLineRunner(this.jobLauncher, this.jobExplorer, jobRepository, new TaskBatchProperties());
+
 	}
 
 
@@ -115,10 +128,27 @@ public class TaskJobLauncherCommandLineRunnerCoreTests {
 				.start(this.steps.get("step").tasklet(throwingTasklet()).build())
 				.incrementer(new RunIdIncrementer()).build();
 		runFailedJob(new JobParameters());
-		runFailedJob(new JobParameters());
+		runFailedJob(new JobParametersBuilder().addLong("run.id", 1L).toJobParameters());
 		assertThat(this.jobExplorer.getJobInstances("job", 0, 100)).hasSize(1);
 	}
 
+	@Test
+	public void runDifferentInstances() throws Exception {
+		this.job = this.jobs.get("job")
+				.start(this.steps.get("step").tasklet(throwingTasklet()).build()).build();
+		// start a job instance
+		JobParameters jobParameters = new JobParametersBuilder().addString("name", "foo")
+				.toJobParameters();
+		runFailedJob(jobParameters);
+		assertThat(this.jobExplorer.getJobInstances("job", 0, 100)).hasSize(1);
+		// start a different job instance
+		JobParameters otherJobParameters = new JobParametersBuilder()
+				.addString("name", "bar").toJobParameters();
+		runFailedJob(otherJobParameters);
+		assertThat(this.jobExplorer.getJobInstances("job", 0, 100)).hasSize(2);
+	}
+
+
 	@DirtiesContext
 	@Test
 	public void retryFailedExecutionOnNonRestartableJob() throws Exception {
@@ -130,6 +160,15 @@ public class TaskJobLauncherCommandLineRunnerCoreTests {
 		// A failed job that is not restartable does not re-use the job params of
 		// the last execution, but creates a new job instance when running it again.
 		assertThat(this.jobExplorer.getJobInstances("job", 0, 100)).hasSize(2);
+
+		// try to re-run a failed execution
+		Executable executable = () -> {
+			this.runner.execute(this.job,
+					new JobParametersBuilder().addLong("run.id", 1L).toJobParameters());
+		};
+		Throwable exception = assertThrows(JobRestartException.class, executable);
+		AssertionsForClassTypes.assertThat(exception.getMessage())
+				.isEqualTo("JobInstance already exists and is not restartable");
 	}
 
 	@DirtiesContext
@@ -140,11 +179,47 @@ public class TaskJobLauncherCommandLineRunnerCoreTests {
 				.incrementer(new RunIdIncrementer()).build();
 		JobParameters jobParameters = new JobParametersBuilder().addLong("id", 1L, false)
 				.addLong("foo", 2L, false).toJobParameters();
-		runFailedJob(new JobParameters());
-		runFailedJob(new JobParameters());
+		runFailedJob(jobParameters);
+		assertThat(this.jobExplorer.getJobInstances("job", 0, 100)).hasSize(1);
+		runFailedJob(new JobParametersBuilder(jobParameters)
+				.addLong("run.id", 1L).toJobParameters());
 		assertThat(this.jobExplorer.getJobInstances("job", 0, 100)).hasSize(1);
 	}
 
+
+	@Test
+	public void retryFailedExecutionWithDifferentNonIdentifyingParametersFromPreviousExecution()
+			throws Exception {
+		this.job = this.jobs.get("job")
+				.start(this.steps.get("step").tasklet(throwingTasklet()).build())
+				.incrementer(new RunIdIncrementer()).build();
+		JobParameters jobParameters = new JobParametersBuilder().addLong("id", 1L, false)
+				.addLong("foo", 2L, false).toJobParameters();
+		runFailedJob(jobParameters);
+		assertThat(this.jobExplorer.getJobInstances("job", 0, 100)).hasSize(1);
+		// try to re-run a failed execution with non identifying parameters
+		runFailedJob( new JobParametersBuilder().addLong("run.id", 1L)
+				.addLong("id", 2L, false).addLong("foo", 3L, false).toJobParameters());
+		assertThat(this.jobExplorer.getJobInstances("job", 0, 100)).hasSize(1);
+		JobInstance jobInstance = this.jobExplorer.getJobInstance(0L);
+		assertThat(this.jobExplorer.getJobExecutions(jobInstance)).hasSize(2);
+		// first execution
+		JobExecution firstJobExecution = this.jobExplorer.getJobExecution(0L);
+		JobParameters parameters = firstJobExecution.getJobParameters();
+		assertThat(parameters.getLong("run.id")).isEqualTo(1L);
+		assertThat(parameters.getLong("id")).isEqualTo(1L);
+		assertThat(parameters.getLong("foo")).isEqualTo(2L);
+		// second execution
+		JobExecution secondJobExecution = this.jobExplorer.getJobExecution(1L);
+		parameters = secondJobExecution.getJobParameters();
+		// identifying parameters should be the same as previous execution
+		assertThat(parameters.getLong("run.id")).isEqualTo(1L);
+		// non-identifying parameters should be the newly specified ones
+		assertThat(parameters.getLong("id")).isEqualTo(2L);
+		assertThat(parameters.getLong("foo")).isEqualTo(3L);
+	}
+
+
 	private Tasklet throwingTasklet() {
 		return (contribution, chunkContext) -> {
 			throw new RuntimeException("Planned");
@@ -154,7 +229,7 @@ public class TaskJobLauncherCommandLineRunnerCoreTests {
 	private void runFailedJob(JobParameters jobParameters) throws Exception {
 		boolean isExceptionThrown = false;
 		try {
-			this.runner.execute(this.job, new JobParameters());
+			this.runner.execute(this.job, jobParameters);
 		}
 		catch (TaskException taskException) {
 			isExceptionThrown = true;

spring-cloud-task-batch/src/test/java/org/springframework/cloud/task/batch/handler/TaskJobLauncherCommandLineRunnerTests.java

@@ -18,36 +18,49 @@ package org.springframework.cloud.task.batch.handler;
 
 import java.util.Set;
 
+import javax.sql.DataSource;
+
 import org.junit.After;
 import org.junit.Test;
+import org.junit.jupiter.api.function.Executable;
 
 import org.springframework.batch.core.Job;
 import org.springframework.batch.core.StepContribution;
+import org.springframework.batch.core.configuration.annotation.BatchConfigurer;
+import org.springframework.batch.core.configuration.annotation.DefaultBatchConfigurer;
 import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
 import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
 import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
+import org.springframework.batch.core.launch.JobLauncher;
+import org.springframework.batch.core.launch.support.SimpleJobLauncher;
 import org.springframework.batch.core.scope.context.ChunkContext;
 import org.springframework.batch.core.step.tasklet.Tasklet;
 import org.springframework.batch.repeat.RepeatStatus;
 import org.springframework.beans.factory.NoSuchBeanDefinitionException;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.ImportAutoConfiguration;
 import org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration;
 import org.springframework.boot.autoconfigure.batch.JobLauncherCommandLineRunner;
 import org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration;
 import org.springframework.boot.autoconfigure.jdbc.EmbeddedDataSourceConfiguration;
 import org.springframework.cloud.task.batch.configuration.TaskBatchAutoConfiguration;
 import org.springframework.cloud.task.batch.configuration.TaskJobLauncherAutoConfiguration;
+import org.springframework.cloud.task.batch.configuration.TaskBatchTest;
 import org.springframework.cloud.task.configuration.EnableTask;
+import org.springframework.cloud.task.configuration.SimpleTaskAutoConfiguration;
+import org.springframework.cloud.task.configuration.SingleTaskConfiguration;
 import org.springframework.cloud.task.repository.TaskExecution;
 import org.springframework.cloud.task.repository.TaskExplorer;
 import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageRequest;
+import org.springframework.scheduling.concurrent.ConcurrentTaskExecutor;
 
 import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 /**
  * @author Glenn Renfro
@@ -56,6 +69,9 @@ public class TaskJobLauncherCommandLineRunnerTests {
 
 	private ConfigurableApplicationContext applicationContext;
 
+	private static final String DEFAULT_ERROR_MESSAGE = "The following Jobs have failed: \n" +
+			"Job jobA failed during execution for jobId 1 with jobExecutionId of 1 \n";
+
 	@After
 	public void tearDown() {
 		if (this.applicationContext != null) {
@@ -65,37 +81,55 @@ public class TaskJobLauncherCommandLineRunnerTests {
 
 	@Test
 	public void testTaskJobLauncherCLRSuccessFail() {
-		String[] enabledArgs = new String[] { "--spring.cloud.task.batch.fail-on-job-failure=true" };
-		boolean isExceptionThrown = false;
-		try {
-			this.applicationContext = SpringApplication
-					.run(new Class[] { TaskJobLauncherCommandLineRunnerTests.JobWithFailureConfiguration.class,
-							PropertyPlaceholderAutoConfiguration.class,
-							EmbeddedDataSourceConfiguration.class,
-							BatchAutoConfiguration.class,
-							TaskBatchAutoConfiguration.class,
-							TaskJobLauncherAutoConfiguration.class }, enabledArgs);
-		}
-		catch (IllegalStateException exception) {
-			isExceptionThrown = true;
-		}
-		assertThat(isExceptionThrown).isTrue();
+		String[] enabledArgs = new String[] {
+				"--spring.cloud.task.batch.failOnJobFailure=true"};
+		validateForFail(DEFAULT_ERROR_MESSAGE, TaskJobLauncherCommandLineRunnerTests.JobWithFailureConfiguration.class,
+				enabledArgs);
+	}
+
+	/**
+	 * Verifies that the task will return an exit code other than zero if the
+	 * job fails with the deprecated EnableTask annotation.
+	 */
+	@Test
+	public void testTaskJobLauncherCLRSuccessFailWithAnnotation() {
+		String[] enabledArgs = new String[] {
+				"--spring.cloud.task.batch.failOnJobFailure=true"};
+		validateForFail(DEFAULT_ERROR_MESSAGE, TaskJobLauncherCommandLineRunnerTests.JobWithFailureAnnotatedConfiguration.class,
+				enabledArgs);
+	}
+
+	@Test
+	public void testTaskJobLauncherCLRSuccessFailWithTaskExecutor() {
+		String[] enabledArgs = new String[] {
+				"--spring.cloud.task.batch.failOnJobFailure=true",
+				"--spring.cloud.task.batch.failOnJobFailurePollInterval=500"};
+		validateForFail(DEFAULT_ERROR_MESSAGE, TaskJobLauncherCommandLineRunnerTests.JobWithFailureTaskExecutorConfiguration.class,
+				enabledArgs);
+	}
+
+
+	@Test
+	public void testTaskJobLauncherCLRSuccessWithLongWaitTaskExecutor() {
+		String[] enabledArgs = new String[] {
+				"--spring.cloud.task.batch.failOnJobFailure=true",
+				"--spring.cloud.task.batch.failOnJobFailurePollInterval=500",
+				"--spring.cloud.task.batch.failOnJobFailurewaitTime=1000"
+		};
+		validateForFail("Not all jobs were completed within the time specified by spring.cloud.task.batch.failOnJobFailurewaitTime.",
+				TaskJobLauncherCommandLineRunnerTests.JobWithFailureTaskExecutorLongWaitConfiguration.class,
+				enabledArgs);
 	}
 
 	@Test
 	public void testTaskJobLauncherPickOneJob() {
 		String[] enabledArgs = new String[] {
 				"--spring.cloud.task.batch.fail-on-job-failure=true",
-				"--spring.cloud.task.batch.jobNames=jobSucceed" };
+				"--spring.cloud.task.batch.jobNames=jobSucceed"};
 		boolean isExceptionThrown = false;
 		try {
 			this.applicationContext = SpringApplication
-					.run(new Class[] { TaskJobLauncherCommandLineRunnerTests.JobWithFailureConfiguration.class,
-							PropertyPlaceholderAutoConfiguration.class,
-							EmbeddedDataSourceConfiguration.class,
-							BatchAutoConfiguration.class,
-							TaskBatchAutoConfiguration.class,
-							TaskJobLauncherAutoConfiguration.class }, enabledArgs);
+					.run(new Class[] { TaskJobLauncherCommandLineRunnerTests.JobWithFailureConfiguration.class }, enabledArgs);
 		}
 		catch (IllegalStateException exception) {
 			isExceptionThrown = true;
@@ -106,24 +140,18 @@ public class TaskJobLauncherCommandLineRunnerTests {
 
 	@Test
 	public void testCommandLineRunnerSetToFalse() {
-		String[] enabledArgs = new String[] { };
+		String[] enabledArgs = new String[] {};
 		this.applicationContext = SpringApplication
-				.run(new Class[] { TaskJobLauncherCommandLineRunnerTests.JobConfiguration.class,
-						PropertyPlaceholderAutoConfiguration.class,
-						EmbeddedDataSourceConfiguration.class,
-						BatchAutoConfiguration.class,
-						TaskBatchAutoConfiguration.class,
-						TaskJobLauncherAutoConfiguration.class }, enabledArgs);
+				.run(new Class[] { TaskJobLauncherCommandLineRunnerTests.JobConfiguration.class }, enabledArgs);
 		validateContext();
 		assertThat(applicationContext.getBean(JobLauncherCommandLineRunner.class)).isNotNull();
-		boolean exceptionThrown = false;
-		try {
+
+		Executable executable = () -> {
 			applicationContext.getBean(TaskJobLauncherCommandLineRunner.class);
-		}
-		catch (NoSuchBeanDefinitionException exception) {
-			exceptionThrown = true;
-		}
-		assertThat(exceptionThrown).isTrue();
+		};
+		Throwable exception = assertThrows(NoSuchBeanDefinitionException.class, executable);
+		assertThat(exception.getMessage()).isEqualTo("No qualifying bean of type " +
+				"'org.springframework.cloud.task.batch.handler.TaskJobLauncherCommandLineRunner' available");
 		validateContext();
 	}
 
@@ -137,12 +165,20 @@ public class TaskJobLauncherCommandLineRunnerTests {
 
 		assertThat(jobExecutionIds.size()).isEqualTo(1);
 		assertThat(taskExplorer.getTaskExecution(jobExecutionIds.iterator().next()).getExecutionId()).isEqualTo(1);
-
 	}
 
-	@Configuration
+	private void validateForFail(String errorMessage, Class clazz, String [] enabledArgs) {
+		Executable executable = () -> {
+			this.applicationContext = SpringApplication
+					.run(new Class[] { clazz,PropertyPlaceholderAutoConfiguration.class}, enabledArgs);};
+		Throwable exception = assertThrows(IllegalStateException.class, executable);
+		assertThat(exception.getCause().getMessage()).isEqualTo(errorMessage);
+	}
+
+
 	@EnableBatchProcessing
-	@EnableTask
+	@TaskBatchTest
+	@Import(EmbeddedDataSourceConfiguration.class)
 	public static class JobConfiguration {
 
 		@Autowired
@@ -156,8 +192,7 @@ public class TaskJobLauncherCommandLineRunnerTests {
 			return jobBuilderFactory.get("job")
 					.start(stepBuilderFactory.get("step1").tasklet(new Tasklet() {
 						@Override
-						public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext)
-								throws Exception {
+						public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) {
 							System.out.println("Executed");
 							return RepeatStatus.FINISHED;
 						}
@@ -166,9 +201,15 @@ public class TaskJobLauncherCommandLineRunnerTests {
 		}
 	}
 
-	@Configuration
 	@EnableBatchProcessing
-	@EnableTask
+	@ImportAutoConfiguration({
+			PropertyPlaceholderAutoConfiguration.class,
+			BatchAutoConfiguration.class,
+			TaskBatchAutoConfiguration.class,
+			TaskJobLauncherAutoConfiguration.class,
+			SingleTaskConfiguration.class,
+			SimpleTaskAutoConfiguration.class })
+	@Import(EmbeddedDataSourceConfiguration.class)
 	public static class JobWithFailureConfiguration {
 
 		@Autowired
@@ -198,8 +239,7 @@ public class TaskJobLauncherCommandLineRunnerTests {
 					.start(stepBuilderFactory.get("step1Succeed").tasklet(new Tasklet() {
 						@Override
 						public RepeatStatus execute(StepContribution contribution,
-								ChunkContext chunkContext)
-								throws Exception {
+								ChunkContext chunkContext) {
 							System.out.println("Executed");
 							return RepeatStatus.FINISHED;
 						}
@@ -207,4 +247,83 @@ public class TaskJobLauncherCommandLineRunnerTests {
 					.build();
 		}
 	}
+
+	@EnableTask
+	public static class JobWithFailureAnnotatedConfiguration extends JobWithFailureConfiguration{
+
+	}
+
+	public static class JobWithFailureTaskExecutorConfiguration extends JobWithFailureConfiguration{
+		@Bean
+		public BatchConfigurer batchConfigurer(DataSource dataSource) {
+			return new TestBatchConfigurer(dataSource);
+		}
+	}
+
+
+	@EnableBatchProcessing
+	@ImportAutoConfiguration({
+			PropertyPlaceholderAutoConfiguration.class,
+			BatchAutoConfiguration.class,
+			TaskBatchAutoConfiguration.class,
+			TaskJobLauncherAutoConfiguration.class,
+			SingleTaskConfiguration.class,
+			SimpleTaskAutoConfiguration.class })
+	@Import(EmbeddedDataSourceConfiguration.class)
+	public static class JobWithFailureTaskExecutorLongWaitConfiguration {
+
+		@Autowired
+		private JobBuilderFactory jobBuilderFactory;
+
+		@Autowired
+		private StepBuilderFactory stepBuilderFactory;
+		@Bean
+		public BatchConfigurer batchConfigurer(DataSource dataSource) {
+			return new TestBatchConfigurer(dataSource);
+		}
+
+		@Bean
+		public Job jobShortRunner() {
+			return jobBuilderFactory.get("jobSucceedShort")
+					.start(stepBuilderFactory.get("step1SucceedSort").tasklet(new Tasklet() {
+						@Override
+						public RepeatStatus execute(StepContribution contribution,
+								ChunkContext chunkContext)
+								throws Exception {
+							System.out.println("Executed Short Runner");
+							return RepeatStatus.FINISHED;
+						}
+					}).build())
+					.build();
+		}
+
+		@Bean
+		public Job jobLongRunner() {
+			return jobBuilderFactory.get("jobSucceedLong")
+					.start(stepBuilderFactory.get("step1SucceedLong").tasklet(new Tasklet() {
+						@Override
+						public RepeatStatus execute(StepContribution contribution,
+								ChunkContext chunkContext)
+								throws Exception {
+							System.out.println("Executed Long Runner");
+							Thread.sleep(5000);
+							return RepeatStatus.FINISHED;
+						}
+					}).build())
+					.build();
+		}
+	}
+
+	private static class TestBatchConfigurer extends DefaultBatchConfigurer{
+		public TestBatchConfigurer(DataSource dataSource) {
+			super(dataSource);
+		}
+		protected JobLauncher createJobLauncher() throws Exception {
+			SimpleJobLauncher jobLauncher = new SimpleJobLauncher();
+			jobLauncher.setJobRepository(getJobRepository());
+			jobLauncher.setTaskExecutor(new ConcurrentTaskExecutor());
+			jobLauncher.afterPropertiesSet();
+			return jobLauncher;
+		}
+	}
 }

spring-cloud-task-batch/src/test/java/org/springframework/cloud/task/batch/listener/PrefixTests.java

@@ -29,10 +29,7 @@ import org.springframework.batch.core.configuration.annotation.StepBuilderFactor
 import org.springframework.batch.repeat.RepeatStatus;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.SpringApplication;
-import org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration;
-import org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration;
-import org.springframework.cloud.task.batch.configuration.TaskBatchAutoConfiguration;
-import org.springframework.cloud.task.configuration.EnableTask;
+import org.springframework.cloud.task.batch.configuration.TaskBatchTest;
 import org.springframework.cloud.task.repository.TaskExplorer;
 import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.context.annotation.Bean;
@@ -58,11 +55,8 @@ public class PrefixTests {
 
 	@Test
 	public void testPrefix() {
-		this.applicationContext = SpringApplication.run(new Class[] {
-				JobConfiguration.class,
-				PropertyPlaceholderAutoConfiguration.class,
-				BatchAutoConfiguration.class,
-				TaskBatchAutoConfiguration.class }, new String[] { "--spring.cloud.task.tablePrefix=FOO_" });
+		this.applicationContext = SpringApplication.run(
+				JobConfiguration.class, new String[] { "--spring.cloud.task.tablePrefix=FOO_" });
 
 		TaskExplorer taskExplorer = this.applicationContext.getBean(TaskExplorer.class);
 
@@ -73,7 +67,7 @@ public class PrefixTests {
 
 	@Configuration
 	@EnableBatchProcessing
-	@EnableTask
+	@TaskBatchTest
 	public static class JobConfiguration {
 
 		@Autowired

spring-cloud-task-batch/src/test/java/org/springframework/cloud/task/batch/listener/TaskBatchExecutionListenerTests.java

@@ -20,6 +20,7 @@ import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
+
 import javax.sql.DataSource;
 
 import org.junit.After;
@@ -43,15 +44,16 @@ import org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoCon
 import org.springframework.boot.autoconfigure.jdbc.EmbeddedDataSourceConfiguration;
 import org.springframework.cloud.task.batch.configuration.TaskBatchAutoConfiguration;
 import org.springframework.cloud.task.batch.configuration.TaskBatchExecutionListenerBeanPostProcessor;
+import org.springframework.cloud.task.batch.configuration.TaskBatchTest;
 import org.springframework.cloud.task.configuration.DefaultTaskConfigurer;
-import org.springframework.cloud.task.configuration.EnableTask;
+import org.springframework.cloud.task.configuration.SimpleTaskAutoConfiguration;
+import org.springframework.cloud.task.configuration.SingleTaskConfiguration;
 import org.springframework.cloud.task.configuration.TaskConfigurer;
 import org.springframework.cloud.task.repository.TaskExecution;
 import org.springframework.cloud.task.repository.TaskExplorer;
-import org.springframework.cloud.task.repository.support.TaskRepositoryInitializer;
 import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
 import org.springframework.context.annotation.Primary;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageRequest;
@@ -62,6 +64,7 @@ import static org.junit.Assert.assertEquals;
 
 /**
  * @author Michael Minella
+ * @author Glenn Renfro
  */
 public class TaskBatchExecutionListenerTests {
 
@@ -78,71 +81,50 @@ public class TaskBatchExecutionListenerTests {
 
 	@Test
 	public void testAutobuiltDataSource() {
-		this.applicationContext = SpringApplication.run(new Class[] {JobConfiguration.class,
-				PropertyPlaceholderAutoConfiguration.class,
-				EmbeddedDataSourceConfiguration.class,
-				BatchAutoConfiguration.class,
-				TaskBatchAutoConfiguration.class}, ARGS);
+		this.applicationContext = SpringApplication.run(JobConfiguration.class ,
+				ARGS);
 		validateContext();
 	}
 
 	@Test(expected = AssertionError.class)
 	public void testNoAutoConfigurationEnabled() {
-		this.applicationContext = SpringApplication.run(new Class[] {JobConfiguration.class,
-				PropertyPlaceholderAutoConfiguration.class,
-				EmbeddedDataSourceConfiguration.class,
-				BatchAutoConfiguration.class,
-				TaskBatchAutoConfiguration.class}, new String[] {"--spring.cloud.task.batch.listener.enabled=false"});
+		this.applicationContext = SpringApplication.run(JobConfiguration.class,
+				new String[] {"--spring.cloud.task.batch.listener.enabled=false"});
 		validateContext();
 	}
 
 	@Test(expected = AssertionError.class)
 	public void testNoAutoConfigurationEnable() {
-		this.applicationContext = SpringApplication.run(new Class[] {JobConfiguration.class,
-				PropertyPlaceholderAutoConfiguration.class,
-				EmbeddedDataSourceConfiguration.class,
-				BatchAutoConfiguration.class,
-				TaskBatchAutoConfiguration.class}, new String[] {"--spring.cloud.task.batch.listener.enable=false"});
+		this.applicationContext = SpringApplication.run(JobConfiguration.class ,
+				new String[] {"--spring.cloud.task.batch.listener.enable=false"});
 		validateContext();
 	}
 
 	@Test(expected = AssertionError.class)
 	public void testNoAutoConfigurationBothDisabled() {
-		this.applicationContext = SpringApplication.run(new Class[] {JobConfiguration.class,
-				PropertyPlaceholderAutoConfiguration.class,
-				EmbeddedDataSourceConfiguration.class,
-				BatchAutoConfiguration.class,
-				TaskBatchAutoConfiguration.class}, new String[] {"--spring.cloud.task.batch.listener.enable=false --spring.cloud.task.batch.listener.enabled=false"});
+		this.applicationContext = SpringApplication.run(JobConfiguration.class ,
+				new String[] {"--spring.cloud.task.batch.listener.enable=false --spring.cloud.task.batch.listener.enabled=false"});
 		validateContext();
 	}
 
 	@Test
 	public void testAutoConfigurationEnable() {
-		this.applicationContext = SpringApplication.run(new Class[] {JobConfiguration.class,
-				PropertyPlaceholderAutoConfiguration.class,
-				EmbeddedDataSourceConfiguration.class,
-				BatchAutoConfiguration.class,
-				TaskBatchAutoConfiguration.class}, new String[] {"--spring.cloud.task.batch.listener.enable=true"});
+		this.applicationContext = SpringApplication.run(JobConfiguration.class ,
+				new String[] {"--spring.cloud.task.batch.listener.enable=true"});
 		validateContext();
 	}
 
 	@Test
 	public void testAutoConfigurationEnabled() {
-		this.applicationContext = SpringApplication.run(new Class[] {JobConfiguration.class,
-				PropertyPlaceholderAutoConfiguration.class,
-				EmbeddedDataSourceConfiguration.class,
-				BatchAutoConfiguration.class,
-				TaskBatchAutoConfiguration.class}, new String[] {"--spring.cloud.task.batch.listener.enabled=true"});
+		this.applicationContext = SpringApplication.run(JobConfiguration.class ,
+				new String[] {"--spring.cloud.task.batch.listener.enabled=true"});
 		validateContext();
 	}
 
 	@Test
 	public void testFactoryBean() {
-		this.applicationContext = SpringApplication.run(new Class[]{JobFactoryBeanConfiguration.class,
-				PropertyPlaceholderAutoConfiguration.class,
-				EmbeddedDataSourceConfiguration.class,
-				BatchAutoConfiguration.class,
-				TaskBatchAutoConfiguration.class}, ARGS);
+		this.applicationContext = SpringApplication.run(JobFactoryBeanConfiguration.class,
+				ARGS);
 		validateContext();
 	}
 
@@ -159,11 +141,7 @@ public class TaskBatchExecutionListenerTests {
 	}
 	@Test
 	public void testMultipleDataSources() {
-		this.applicationContext = SpringApplication.run(new Class[] {JobConfigurationMultipleDataSources.class,
-				PropertyPlaceholderAutoConfiguration.class,
-				EmbeddedDataSourceConfiguration.class,
-				BatchAutoConfiguration.class,
-				TaskBatchAutoConfiguration.class}, ARGS);
+		this.applicationContext = SpringApplication.run(JobConfigurationMultipleDataSources.class, ARGS);
 
 		TaskExplorer taskExplorer = this.applicationContext.getBean(TaskExplorer.class);
 
@@ -177,11 +155,7 @@ public class TaskBatchExecutionListenerTests {
 
 	@Test
 	public void testAutobuiltDataSourceNoJob() {
-		this.applicationContext = SpringApplication.run(new Class[] {NoJobConfiguration.class,
-				PropertyPlaceholderAutoConfiguration.class,
-				EmbeddedDataSourceConfiguration.class,
-				BatchAutoConfiguration.class,
-				TaskBatchAutoConfiguration.class}, ARGS);
+		this.applicationContext = SpringApplication.run(NoJobConfiguration.class, ARGS);
 
 		TaskExplorer taskExplorer = this.applicationContext.getBean(TaskExplorer.class);
 
@@ -194,10 +168,7 @@ public class TaskBatchExecutionListenerTests {
 
 	@Test
 	public void testMapBased() {
-		this.applicationContext = SpringApplication.run(new Class[] {JobConfiguration.class,
-				PropertyPlaceholderAutoConfiguration.class, EmbeddedDataSourceConfiguration.class,
-				BatchAutoConfiguration.class,
-				TaskBatchAutoConfiguration.class}, ARGS);
+		this.applicationContext = SpringApplication.run(JobConfiguration.class, ARGS);
 
 		TaskExplorer taskExplorer = this.applicationContext.getBean(TaskExplorer.class);
 
@@ -211,10 +182,7 @@ public class TaskBatchExecutionListenerTests {
 
 	@Test
 	public void testMultipleJobs() {
-		this.applicationContext = SpringApplication.run(new Class[] {EmbeddedDataSourceConfiguration.class, MultipleJobConfiguration.class,
-				PropertyPlaceholderAutoConfiguration.class,
-				BatchAutoConfiguration.class,
-				TaskBatchAutoConfiguration.class}, ARGS);
+		this.applicationContext = SpringApplication.run(MultipleJobConfiguration.class, ARGS);
 
 		TaskExplorer taskExplorer = this.applicationContext.getBean(TaskExplorer.class);
 
@@ -267,7 +235,9 @@ public class TaskBatchExecutionListenerTests {
 		this.applicationContext = SpringApplication.run(new Class[] {JobConfiguration.class,
 				PropertyPlaceholderAutoConfiguration.class, EmbeddedDataSourceConfiguration.class,
 				BatchAutoConfiguration.class,
-				TaskBatchAutoConfiguration.class}, ARGS);
+				TaskBatchAutoConfiguration.class,
+				SimpleTaskAutoConfiguration.class,
+				SingleTaskConfiguration.class }, ARGS);
 
 		TaskBatchExecutionListenerBeanPostProcessor beanPostProcessor =
 				this.applicationContext.getBean(
@@ -277,16 +247,16 @@ public class TaskBatchExecutionListenerTests {
 		return beanPostProcessor;
 	}
 
-	@Configuration
 	@EnableBatchProcessing
-	@EnableTask
+	@TaskBatchTest
+	@Import(EmbeddedDataSourceConfiguration.class)
 	public static class NoJobConfiguration {
 
 	}
 
-	@Configuration
 	@EnableBatchProcessing
-	@EnableTask
+	@TaskBatchTest
+	@Import(EmbeddedDataSourceConfiguration.class)
 	public static class JobConfiguration {
 
 		@Autowired
@@ -309,9 +279,9 @@ public class TaskBatchExecutionListenerTests {
 		}
 	}
 
-	@Configuration
 	@EnableBatchProcessing
-	@EnableTask
+	@TaskBatchTest
+	@Import(EmbeddedDataSourceConfiguration.class)
 	public static class JobFactoryBeanConfiguration {
 
 		@Autowired
@@ -349,9 +319,9 @@ public class TaskBatchExecutionListenerTests {
 		}
 	}
 
-	@Configuration
 	@EnableBatchProcessing
-	@EnableTask
+	@TaskBatchTest
+	@Import(EmbeddedDataSourceConfiguration.class)
 	public static class JobConfigurationMultipleDataSources {
 
 		@Autowired
@@ -396,24 +366,15 @@ public class TaskBatchExecutionListenerTests {
 			return new DefaultTaskConfigurer(myDataSource());
 		}
 
-		@Bean
-		public TaskRepositoryInitializer taskRepositoryInitializer() {
-			TaskRepositoryInitializer taskRepositoryInitializer = new TaskRepositoryInitializer();
-
-			taskRepositoryInitializer.setDataSource(myDataSource());
-
-			return taskRepositoryInitializer;
-		}
-
 		@Bean
 		public DefaultBatchConfigurer batchConfigurer() {
 			return new DefaultBatchConfigurer(myDataSource());
 		}
 	}
 
-	@Configuration
 	@EnableBatchProcessing
-	@EnableTask
+	@TaskBatchTest
+	@Import(EmbeddedDataSourceConfiguration.class)
 	public static class MultipleJobConfiguration {
 
 		@Autowired

spring-cloud-task-batch/src/test/resources/META-INF/spring.factories

@@ -0,0 +1,6 @@
+org.springframework.cloud.task.batch.configuration.TaskBatchTest=\
+org.springframework.cloud.task.batch.configuration.TaskBatchAutoConfiguration,\
+org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
+org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
+org.springframework.cloud.task.configuration.SimpleTaskAutoConfiguration,\
+org.springframework.cloud.task.configuration.SingleTaskConfiguration