Removed BatchConfigurer and @EnableBatchProcessing from tests and samples

TaskJobLauncherApplicationRunnerTests updated

Signed-off-by: Glenn Renfro <grenfro@vmware.com>

Updated Integration tests

Updated Tests for samples

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

@@ -16,214 +16,138 @@
 
 package org.springframework.cloud.task.batch.handler;
 
+import java.util.Arrays;
 import java.util.List;
 
 import javax.sql.DataSource;
 
-import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.junit.jupiter.api.function.Executable;
 
 import org.springframework.batch.core.Job;
-import org.springframework.batch.core.JobExecution;
+import org.springframework.batch.core.JobExecutionException;
 import org.springframework.batch.core.JobInstance;
 import org.springframework.batch.core.JobParameters;
 import org.springframework.batch.core.JobParametersBuilder;
 import org.springframework.batch.core.Step;
-import org.springframework.batch.core.configuration.annotation.BatchConfigurer;
 import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
 import org.springframework.batch.core.explore.JobExplorer;
-import org.springframework.batch.core.explore.support.JobExplorerFactoryBean;
 import org.springframework.batch.core.job.builder.JobBuilder;
+import org.springframework.batch.core.job.builder.SimpleJobBuilder;
 import org.springframework.batch.core.launch.JobLauncher;
 import org.springframework.batch.core.launch.support.RunIdIncrementer;
-import org.springframework.batch.core.launch.support.TaskExecutorJobLauncher;
 import org.springframework.batch.core.repository.JobRepository;
 import org.springframework.batch.core.repository.JobRestartException;
-import org.springframework.batch.core.repository.dao.Jackson2ExecutionContextStringSerializer;
-import org.springframework.batch.core.repository.support.JobRepositoryFactoryBean;
 import org.springframework.batch.core.step.builder.StepBuilder;
 import org.springframework.batch.core.step.tasklet.Tasklet;
-import org.springframework.batch.repeat.RepeatStatus;
-import org.springframework.batch.support.transaction.ResourcelessTransactionManager;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.autoconfigure.jdbc.EmbeddedDataSourceConfiguration;
+import org.springframework.boot.autoconfigure.AutoConfigurations;
+import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
+import org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration;
+import org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration;
+import org.springframework.boot.jdbc.init.DataSourceScriptDatabaseInitializer;
+import org.springframework.boot.sql.init.DatabaseInitializationSettings;
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
 import org.springframework.cloud.task.batch.configuration.TaskBatchProperties;
 import org.springframework.cloud.task.listener.TaskException;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Import;
-import org.springframework.core.io.ClassPathResource;
-import org.springframework.core.task.SyncTaskExecutor;
-import org.springframework.jdbc.core.JdbcTemplate;
-import org.springframework.jdbc.datasource.init.DataSourceInitializer;
-import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator;
-import org.springframework.test.annotation.DirtiesContext;
-import org.springframework.test.context.ContextConfiguration;
-import org.springframework.test.context.junit.jupiter.SpringExtension;
 import org.springframework.transaction.PlatformTransactionManager;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.assertj.core.api.Assertions.fail;
 
 /**
  * @author Glenn Renfro
  */
-@ExtendWith(SpringExtension.class)
-@ContextConfiguration(classes = { TaskJobLauncherApplicationRunnerCoreTests.BatchConfiguration.class })
 public class TaskJobLauncherApplicationRunnerCoreTests {
 
-	@Autowired
-	private JobRepository jobRepository;
+	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
+			.withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class,
+					TransactionAutoConfiguration.class, DataSourceTransactionManagerAutoConfiguration.class))
+			.withUserConfiguration(BatchConfiguration.class);
 
-	@Autowired
-	private JobLauncher jobLauncher;
-
-	@Autowired
-	private JobExplorer jobExplorer;
-
-	private PlatformTransactionManager transactionManager;
-
-	private TaskJobLauncherApplicationRunner runner;
-
-	private Job job;
-
-	private Step step;
-
-	@BeforeEach
-	public void init() {
-		this.transactionManager = new ResourcelessTransactionManager();
-		Tasklet tasklet = (contribution, chunkContext) -> RepeatStatus.FINISHED;
-		this.step = new StepBuilder("step").repository(this.jobRepository).tasklet(tasklet)
-				.transactionManager(this.transactionManager).build();
-		this.job = new JobBuilder("job").repository(this.jobRepository).start(this.step).build();
-		this.runner = new TaskJobLauncherApplicationRunner(this.jobLauncher, this.jobExplorer, this.jobRepository,
-				new TaskBatchProperties());
-
-	}
-
-	@DirtiesContext
 	@Test
-	public void basicExecution() throws Exception {
-		this.runner.execute(this.job, new JobParameters());
-		assertThat(this.jobExplorer.getJobInstances("job", 0, 100)).hasSize(1);
-		this.runner.execute(this.job, new JobParametersBuilder().addLong("id", 1L).toJobParameters());
-		assertThat(this.jobExplorer.getJobInstances("job", 0, 100)).hasSize(2);
+	void basicExecution() {
+		this.contextRunner.run((context) -> {
+			JobLauncherApplicationRunnerContext jobLauncherContext = new JobLauncherApplicationRunnerContext(context);
+			jobLauncherContext.executeJob(new JobParameters());
+			assertThat(jobLauncherContext.jobInstances()).hasSize(1);
+			jobLauncherContext.executeJob(new JobParametersBuilder().addLong("id", 1L).toJobParameters());
+			assertThat(jobLauncherContext.jobInstances()).hasSize(2);
+		});
 	}
 
-	@DirtiesContext
-	// @Test
-	public void incrementExistingExecution() throws Exception {
-		this.job = new JobBuilder("job").repository(this.jobRepository).start(this.step)
-				.incrementer(new RunIdIncrementer()).build();
-		this.runner.execute(this.job, new JobParameters());
-		this.runner.execute(this.job, new JobParameters());
-		assertThat(this.jobExplorer.getJobInstances("job", 0, 100)).hasSize(2);
-	}
-
-	@DirtiesContext
-	// @Test
-	public void retryFailedExecution() throws Exception {
-		this.job = new JobBuilder("job").repository(this.jobRepository)
-				.start(new StepBuilder("step").repository(this.jobRepository).tasklet(throwingTasklet()).build())
-				.incrementer(new RunIdIncrementer()).build();
-		runFailedJob(new JobParameters());
-		runFailedJob(new JobParametersBuilder().addLong("run.id", 1L).toJobParameters());
-		assertThat(this.jobExplorer.getJobInstances("job", 0, 100)).hasSize(1);
-	}
-
-	@DirtiesContext
 	@Test
-	public void runDifferentInstances() throws Exception {
-		this.job = new JobBuilder("job").repository(this.jobRepository)
-				.start(new StepBuilder("step").repository(this.jobRepository).tasklet(throwingTasklet())
-						.transactionManager(this.transactionManager).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);
+	void incrementExistingExecution() {
+		this.contextRunner.run((context) -> {
+			JobLauncherApplicationRunnerContext jobLauncherContext = new JobLauncherApplicationRunnerContext(context);
+			Job job = jobLauncherContext.configureJob().incrementer(new RunIdIncrementer()).build();
+			jobLauncherContext.runner.execute(job, new JobParameters());
+			jobLauncherContext.runner.execute(job, new JobParameters());
+			assertThat(jobLauncherContext.jobInstances()).hasSize(2);
+		});
 	}
 
-	@DirtiesContext
 	@Test
-	public void retryFailedExecutionOnNonRestartableJob() throws Exception {
-		this.job = new JobBuilder("job").repository(this.jobRepository).preventRestart()
-				.start(new StepBuilder("step").repository(this.jobRepository).tasklet(throwingTasklet())
-						.transactionManager(this.transactionManager).build())
-				.incrementer(new RunIdIncrementer()).build();
-		runFailedJob(new JobParameters());
-		runFailedJob(new JobParameters());
-		// 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);
+	void runDifferentInstances() {
+		this.contextRunner.run((context) -> {
+			PlatformTransactionManager transactionManager = context.getBean(PlatformTransactionManager.class);
+			JobLauncherApplicationRunnerContext jobLauncherContext = new JobLauncherApplicationRunnerContext(context);
+			Job job = jobLauncherContext.jobBuilder()
+					.start(jobLauncherContext.stepBuilder().tasklet(throwingTasklet(), transactionManager).build())
+					.build();
+			// start a job instance
+			JobParameters jobParameters = new JobParametersBuilder().addString("name", "foo").toJobParameters();
+			runFailedJob(jobLauncherContext, job, jobParameters);
+			assertThat(jobLauncherContext.jobInstances()).hasSize(1);
+			// start a different job instance
+			JobParameters otherJobParameters = new JobParametersBuilder().addString("name", "bar").toJobParameters();
+			runFailedJob(jobLauncherContext, job, otherJobParameters);
 
-		// try to re-run a failed execution
-		Executable executable = () -> this.runner.execute(this.job,
-				new JobParametersBuilder().addLong("run.id", 1L).toJobParameters());
-		assertThatExceptionOfType(JobRestartException.class).isThrownBy(executable::execute)
-				.withMessage("JobInstance already exists and is not restartable");
+			assertThat(jobLauncherContext.jobInstances()).hasSize(2);
+		});
 	}
 
-	@DirtiesContext
 	@Test
-	public void retryFailedExecutionWithNonIdentifyingParameters() throws Exception {
-		this.job = new JobBuilder("job").repository(this.jobRepository)
-				.start(new StepBuilder("step").repository(this.jobRepository).tasklet(throwingTasklet())
-						.transactionManager(this.transactionManager).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);
-		runFailedJob(new JobParametersBuilder(jobParameters).addLong("run.id", 1L).toJobParameters());
-		assertThat(this.jobExplorer.getJobInstances("job", 0, 100)).hasSize(1);
+	void retryFailedExecutionOnNonRestartableJob() {
+		this.contextRunner.run((context) -> {
+			PlatformTransactionManager transactionManager = context.getBean(PlatformTransactionManager.class);
+			JobLauncherApplicationRunnerContext jobLauncherContext = new JobLauncherApplicationRunnerContext(context);
+			Job job = jobLauncherContext.jobBuilder().preventRestart()
+					.start(jobLauncherContext.stepBuilder().tasklet(throwingTasklet(), transactionManager).build())
+					.incrementer(new RunIdIncrementer()).build();
+			runFailedJob(jobLauncherContext, job, new JobParameters());
+			runFailedJob(jobLauncherContext, job, new JobParameters());
+			// 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(jobLauncherContext.jobInstances()).hasSize(2);
+			assertThatExceptionOfType(JobRestartException.class).isThrownBy(() -> {
+				// try to re-run a failed execution
+				jobLauncherContext.runner.execute(job,
+						new JobParametersBuilder().addLong("run.id", 1L).toJobParameters());
+				fail("expected JobRestartException");
+			}).withMessageContaining("JobInstance already exists and is not restartable");
+		});
 	}
 
-	@DirtiesContext
 	@Test
-	public void retryFailedExecutionWithDifferentNonIdentifyingParametersFromPreviousExecution() throws Exception {
-		this.job = new JobBuilder("job").repository(this.jobRepository)
-				.start(new StepBuilder("step").repository(this.jobRepository).tasklet(throwingTasklet())
-						.transactionManager(this.transactionManager).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 = jobExplorer.getLastJobInstance("job");
-
-		List<JobExecution> executions = this.jobExplorer.getJobExecutions(jobInstance);
-
-		assertThat(executions).hasSize(2);
-
-		JobExecution firstJobExecution = executions.get(0);
-		JobExecution secondJobExecution = executions.get(1);
-		if ((executions.get(0).getId() > executions.get(1).getId())) {
-			firstJobExecution = executions.get(1);
-			secondJobExecution = executions.get(0);
-		}
-
-		// first execution
-		JobParameters parameters = firstJobExecution.getJobParameters();
-		assertThat(parameters.getLong("run.id")).isEqualTo(1L);
-		assertThat(parameters.getLong("id")).isEqualTo(2L);
-		assertThat(parameters.getLong("foo")).isEqualTo(3L);
-		// second execution
-		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);
+	void retryFailedExecutionWithNonIdentifyingParameters() {
+		this.contextRunner.run((context) -> {
+			PlatformTransactionManager transactionManager = context.getBean(PlatformTransactionManager.class);
+			JobLauncherApplicationRunnerContext jobLauncherContext = new JobLauncherApplicationRunnerContext(context);
+			Job job = jobLauncherContext.jobBuilder()
+					.start(jobLauncherContext.stepBuilder().tasklet(throwingTasklet(), transactionManager).build())
+					.incrementer(new RunIdIncrementer()).build();
+			JobParameters jobParameters = new JobParametersBuilder().addLong("id", 1L, false).addLong("foo", 2L, false)
+					.toJobParameters();
+			runFailedJob(jobLauncherContext, job, jobParameters);
+			assertThat(jobLauncherContext.jobInstances()).hasSize(1);
+			// try to re-run a failed execution with non identifying parameters
+			runFailedJob(jobLauncherContext, job,
+					new JobParametersBuilder(jobParameters).addLong("run.id", 1L).toJobParameters());
+			assertThat(jobLauncherContext.jobInstances()).hasSize(1);
+		});
 	}
 
 	private Tasklet throwingTasklet() {
@@ -232,10 +156,11 @@ public class TaskJobLauncherApplicationRunnerCoreTests {
 		};
 	}
 
-	private void runFailedJob(JobParameters jobParameters) throws Exception {
+	private void runFailedJob(JobLauncherApplicationRunnerContext jobLauncherContext, Job job,
+			JobParameters jobParameters) throws Exception {
 		boolean isExceptionThrown = false;
 		try {
-			this.runner.execute(this.job, jobParameters);
+			jobLauncherContext.runner.execute(job, jobParameters);
 		}
 		catch (TaskException taskException) {
 			isExceptionThrown = true;
@@ -243,68 +168,70 @@ public class TaskJobLauncherApplicationRunnerCoreTests {
 		assertThat(isExceptionThrown).isTrue();
 	}
 
-	@Configuration
+	static class JobLauncherApplicationRunnerContext {
+
+		private final TaskJobLauncherApplicationRunner runner;
+
+		private final JobExplorer jobExplorer;
+
+		private final JobBuilder jobBuilder;
+
+		private final Job job;
+
+		private final StepBuilder stepBuilder;
+
+		private final Step step;
+
+		JobLauncherApplicationRunnerContext(ApplicationContext context) {
+			JobLauncher jobLauncher = context.getBean(JobLauncher.class);
+			JobRepository jobRepository = context.getBean(JobRepository.class);
+			PlatformTransactionManager transactionManager = context.getBean(PlatformTransactionManager.class);
+			this.stepBuilder = new StepBuilder("step", jobRepository);
+			this.step = this.stepBuilder.tasklet((contribution, chunkContext) -> null, transactionManager).build();
+			this.jobBuilder = new JobBuilder("job", jobRepository);
+			this.job = this.jobBuilder.start(this.step).build();
+			this.jobExplorer = context.getBean(JobExplorer.class);
+			this.runner = new TaskJobLauncherApplicationRunner(jobLauncher, this.jobExplorer, jobRepository,
+					new TaskBatchProperties());
+		}
+
+		List<JobInstance> jobInstances() {
+			return this.jobExplorer.getJobInstances("job", 0, 100);
+		}
+
+		void executeJob(JobParameters jobParameters) throws JobExecutionException {
+			this.runner.execute(this.job, jobParameters);
+		}
+
+		JobBuilder jobBuilder() {
+			return this.jobBuilder;
+		}
+
+		StepBuilder stepBuilder() {
+			return this.stepBuilder;
+		}
+
+		SimpleJobBuilder configureJob() {
+			return this.jobBuilder.start(this.step);
+		}
+
+	}
+
 	@EnableBatchProcessing
-	@Import(EmbeddedDataSourceConfiguration.class)
+	@Configuration(proxyBeanMethods = false)
+	static class BatchConfiguration {
 
-	protected static class BatchConfiguration implements BatchConfigurer {
+		private final DataSource dataSource;
 
-		private ResourcelessTransactionManager transactionManager = new ResourcelessTransactionManager();
-
-		private JobRepository jobRepository;
-
-		@Autowired
-		private DataSource dataSource;
-
-		public BatchConfiguration() throws Exception {
+		protected BatchConfiguration(DataSource dataSource) {
+			this.dataSource = dataSource;
 		}
 
-		private JobRepository jobRepositoryNew() throws Exception {
-			JobRepositoryFactoryBean jobRepositoryFactoryBean = new JobRepositoryFactoryBean();
-			jobRepositoryFactoryBean.setDataSource(dataSource);
-			jobRepositoryFactoryBean.setTransactionManager(transactionManager);
-			jobRepositoryFactoryBean.setSerializer(new Jackson2ExecutionContextStringSerializer());
-			this.jobRepository = jobRepositoryFactoryBean.getObject();
-			return this.jobRepository;
-		}
-
-		@Override
-		public JobRepository getJobRepository() throws Exception {
-			if (this.jobRepository == null) {
-				this.jobRepository = jobRepositoryNew();
-			}
-			return this.jobRepository;
-		}
-
-		@Override
-		public JobLauncher getJobLauncher() throws Exception {
-			TaskExecutorJobLauncher launcher = new TaskExecutorJobLauncher();
-
-			launcher.setJobRepository(getJobRepository());
-			launcher.setTaskExecutor(new SyncTaskExecutor());
-			return launcher;
-		}
-
-		@Override
-		public JobExplorer getJobExplorer() throws Exception {
-			dataSourceInitializer().afterPropertiesSet();
-			JobExplorerFactoryBean factoryBean = new JobExplorerFactoryBean();
-			factoryBean.setDataSource(dataSource);
-			factoryBean.setJdbcOperations(new JdbcTemplate(dataSource));
-			factoryBean.setSerializer(new Jackson2ExecutionContextStringSerializer());
-			return factoryBean.getObject();
-		}
-
-		public DataSourceInitializer dataSourceInitializer() {
-			DataSourceInitializer dataSourceInitializer = new DataSourceInitializer();
-			dataSourceInitializer.setDataSource(dataSource);
-			ResourceDatabasePopulator databasePopulator = new ResourceDatabasePopulator();
-			databasePopulator.addScript(new ClassPathResource("org/springframework/batch/core/schema-h2.sql"));
-			dataSourceInitializer.setDatabasePopulator(databasePopulator);
-			databasePopulator = new ResourceDatabasePopulator();
-			databasePopulator.addScript(new ClassPathResource("org/springframework/batch/core/schema-drop-h2.sql"));
-			dataSourceInitializer.setDatabaseCleaner(databasePopulator);
-			return dataSourceInitializer;
+		@Bean
+		DataSourceScriptDatabaseInitializer batchDataSourceInitializer() {
+			DatabaseInitializationSettings settings = new DatabaseInitializationSettings();
+			settings.setSchemaLocations(Arrays.asList("classpath:org/springframework/batch/core/schema-h2.sql"));
+			return new DataSourceScriptDatabaseInitializer(this.dataSource, settings);
 		}
 
 	}

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

@@ -16,6 +16,7 @@
 
 package org.springframework.cloud.task.batch.handler;
 
+import java.util.Arrays;
 import java.util.Set;
 
 import javax.sql.DataSource;
@@ -27,26 +28,26 @@ 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.explore.JobExplorer;
 import org.springframework.batch.core.job.builder.JobBuilder;
-import org.springframework.batch.core.launch.JobLauncher;
-import org.springframework.batch.core.launch.support.TaskExecutorJobLauncher;
 import org.springframework.batch.core.repository.JobRepository;
 import org.springframework.batch.core.scope.context.ChunkContext;
 import org.springframework.batch.core.step.builder.StepBuilder;
 import org.springframework.batch.core.step.tasklet.Tasklet;
 import org.springframework.batch.repeat.RepeatStatus;
+import org.springframework.batch.support.transaction.ResourcelessTransactionManager;
 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.BatchProperties;
 import org.springframework.boot.autoconfigure.batch.JobLauncherApplicationRunner;
 import org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration;
 import org.springframework.boot.autoconfigure.jdbc.EmbeddedDataSourceConfiguration;
+import org.springframework.boot.jdbc.init.DataSourceScriptDatabaseInitializer;
+import org.springframework.boot.sql.init.DatabaseInitializationSettings;
 import org.springframework.cloud.task.batch.configuration.TaskBatchAutoConfiguration;
 import org.springframework.cloud.task.batch.configuration.TaskBatchTest;
 import org.springframework.cloud.task.batch.configuration.TaskJobLauncherAutoConfiguration;
@@ -61,7 +62,6 @@ 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 org.springframework.transaction.PlatformTransactionManager;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -178,28 +178,48 @@ public class TaskJobLauncherApplicationRunnerTests {
 				});
 	}
 
-	@EnableBatchProcessing
 	@TaskBatchTest
 	@Import(EmbeddedDataSourceConfiguration.class)
 	@EnableTask
 	public static class JobConfiguration {
 
-		@Autowired
-		private JobRepository jobRepository;
-
-		@Autowired
-		private PlatformTransactionManager transactionManager;
-
 		@Bean
-		public Job job() {
-			return new JobBuilder("job").repository(this.jobRepository)
-					.start(new StepBuilder("step1").repository(this.jobRepository).tasklet(new Tasklet() {
+		public Job job(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
+			return new JobBuilder("job", jobRepository)
+					.start(new StepBuilder("step1", jobRepository).tasklet(new Tasklet() {
 						@Override
 						public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) {
 							System.out.println("Executed");
 							return RepeatStatus.FINISHED;
 						}
-					}).transactionManager(transactionManager).build()).build();
+					}, transactionManager).build()).build();
+		}
+
+		@Bean
+		public PlatformTransactionManager transactionManager() {
+			return new ResourcelessTransactionManager();
+		}
+
+	}
+
+	@Configuration(proxyBeanMethods = false)
+	public static class TransactionManagerTestConfiguration {
+
+		@Bean
+		public PlatformTransactionManager transactionManager() {
+			return new ResourcelessTransactionManager();
+		}
+
+		@Bean
+		public BatchProperties batchProperties() {
+			return new BatchProperties();
+		}
+
+		@Bean
+		DataSourceScriptDatabaseInitializer batchDataSourceInitializer(DataSource dataSource) {
+			DatabaseInitializationSettings settings = new DatabaseInitializationSettings();
+			settings.setSchemaLocations(Arrays.asList("classpath:org/springframework/batch/core/schema-h2.sql"));
+			return new DataSourceScriptDatabaseInitializer(dataSource, settings);
 		}
 
 	}
@@ -207,7 +227,7 @@ public class TaskJobLauncherApplicationRunnerTests {
 	@EnableBatchProcessing
 	@ImportAutoConfiguration({ PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
 			TaskBatchAutoConfiguration.class, TaskJobLauncherAutoConfiguration.class, SingleTaskConfiguration.class,
-			SimpleTaskAutoConfiguration.class })
+			SimpleTaskAutoConfiguration.class, TransactionManagerTestConfiguration.class })
 	@Import(EmbeddedDataSourceConfiguration.class)
 	@EnableTask
 	public static class JobWithFailureConfiguration {
@@ -254,27 +274,27 @@ public class TaskJobLauncherApplicationRunnerTests {
 	@Configuration
 	public static class JobWithFailureTaskExecutorConfiguration {
 
-		@Bean
-		public BatchConfigurer batchConfigurer(DataSource dataSource) {
-			return new TestBatchConfigurer(dataSource);
-		}
+		// @Bean
+		// public BatchConfigurer batchConfigurer(DataSource dataSource) {
+		// return new TestBatchConfigurer(dataSource);
+		// }
 
 	}
 
-	private static class TestBatchConfigurer extends DefaultBatchConfigurer {
-
-		TestBatchConfigurer(DataSource dataSource) {
-			super(dataSource);
-		}
-
-		protected JobLauncher createJobLauncher() throws Exception {
-			TaskExecutorJobLauncher jobLauncher = new TaskExecutorJobLauncher();
-			jobLauncher.setJobRepository(getJobRepository());
-			jobLauncher.setTaskExecutor(new ConcurrentTaskExecutor());
-			jobLauncher.afterPropertiesSet();
-			return jobLauncher;
-		}
-
-	}
+	// private static class TestBatchConfigurer extends DefaultBatchConfigurer {
+	//
+	// TestBatchConfigurer(DataSource dataSource) {
+	// super(dataSource);
+	// }
+	//
+	// protected JobLauncher createJobLauncher() throws Exception {
+	// TaskExecutorJobLauncher jobLauncher = new TaskExecutorJobLauncher();
+	// 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

@@ -24,7 +24,6 @@ import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
 
 import org.springframework.batch.core.Job;
-import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
 import org.springframework.batch.core.job.builder.JobBuilder;
 import org.springframework.batch.core.repository.JobRepository;
 import org.springframework.batch.core.step.builder.StepBuilder;
@@ -39,6 +38,7 @@ import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
 import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;
+import org.springframework.transaction.PlatformTransactionManager;
 
 import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
 
@@ -68,18 +68,17 @@ public class PrefixTests {
 	}
 
 	@Configuration(proxyBeanMethods = false)
-	@EnableBatchProcessing
 	@TaskBatchTest
 	@EnableTask
 	public static class JobConfiguration {
 
 		@Bean
-		public Job job(JobRepository jobRepository) {
-			return new JobBuilder("job").repository(jobRepository)
-					.start(new StepBuilder("step1").repository(jobRepository).tasklet((contribution, chunkContext) -> {
+		public Job job(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
+			return new JobBuilder("job", jobRepository)
+					.start(new StepBuilder("step1", jobRepository).tasklet((contribution, chunkContext) -> {
 						System.out.println("Executed");
 						return RepeatStatus.FINISHED;
-					}).transactionManager(new ResourcelessTransactionManager()).build()).build();
+					}, transactionManager).build()).build();
 		}
 
 		@Bean
@@ -88,6 +87,11 @@ public class PrefixTests {
 					.build();
 		}
 
+		@Bean
+		PlatformTransactionManager transactionManager() {
+			return new ResourcelessTransactionManager();
+		}
+
 	}
 
 }

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

@@ -24,7 +24,6 @@ import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
 
 import org.springframework.batch.core.Job;
-import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
 import org.springframework.batch.core.job.builder.JobBuilder;
 import org.springframework.batch.core.repository.JobRepository;
 import org.springframework.batch.core.step.builder.StepBuilder;
@@ -39,6 +38,7 @@ import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
 import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;
+import org.springframework.transaction.PlatformTransactionManager;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -67,18 +67,17 @@ class PrimaryKeyTests {
 	}
 
 	@Configuration(proxyBeanMethods = false)
-	@EnableBatchProcessing
 	@TaskBatchTest
 	@EnableTask
 	static class JobConfiguration {
 
 		@Bean
-		Job job(JobRepository jobRepository) {
-			return new JobBuilder("job").repository(jobRepository)
-					.start(new StepBuilder("step1").repository(jobRepository).tasklet((contribution, chunkContext) -> {
+		Job job(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
+			return new JobBuilder("job", jobRepository)
+					.start(new StepBuilder("step1", jobRepository).tasklet((contribution, chunkContext) -> {
 						System.out.println("Executed");
 						return RepeatStatus.FINISHED;
-					}).transactionManager(new ResourcelessTransactionManager()).build()).build();
+					}, transactionManager).build()).build();
 		}
 
 		@Bean
@@ -87,6 +86,11 @@ class PrimaryKeyTests {
 					.setType(EmbeddedDatabaseType.H2).build();
 		}
 
+		@Bean
+		PlatformTransactionManager transactionManager() {
+			return new ResourcelessTransactionManager();
+		}
+
 	}
 
 }

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

@@ -29,7 +29,6 @@ import org.junit.jupiter.api.Test;
 
 import org.springframework.batch.core.Job;
 import org.springframework.batch.core.StepContribution;
-import org.springframework.batch.core.configuration.annotation.DefaultBatchConfigurer;
 import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
 import org.springframework.batch.core.job.SimpleJob;
 import org.springframework.batch.core.job.builder.JobBuilder;
@@ -41,7 +40,6 @@ import org.springframework.batch.repeat.RepeatStatus;
 import org.springframework.batch.support.transaction.ResourcelessTransactionManager;
 import org.springframework.beans.factory.FactoryBean;
 import org.springframework.beans.factory.NoSuchBeanDefinitionException;
-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;
@@ -274,27 +272,30 @@ public class TaskBatchExecutionListenerTests {
 	@EnableTask
 	public static class NoJobConfiguration {
 
+		@Bean
+		PlatformTransactionManager transactionManager() {
+			return new ResourcelessTransactionManager();
+		}
+
 	}
 
-	@EnableBatchProcessing
 	@TaskBatchTest
 	@EnableTask
 	@Import(EmbeddedDataSourceConfiguration.class)
 	public static class JobConfiguration {
 
-		@Autowired
-		private JobRepository jobRepository;
-
-		@Autowired
-		private PlatformTransactionManager transactionManager;
-
 		@Bean
-		public Job job() {
-			return new JobBuilder("job").repository(this.jobRepository).start(
-					new StepBuilder("step1").repository(this.jobRepository).tasklet((contribution, chunkContext) -> {
+		public Job job(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
+			return new JobBuilder("job", jobRepository)
+					.start(new StepBuilder("step1", jobRepository).tasklet((contribution, chunkContext) -> {
 						System.out.println("Executed");
 						return RepeatStatus.FINISHED;
-					}).transactionManager(this.transactionManager).build()).build();
+					}, transactionManager).build()).build();
+		}
+
+		@Bean
+		PlatformTransactionManager transactionManager() {
+			return new ResourcelessTransactionManager();
 		}
 
 	}
@@ -304,46 +305,37 @@ public class TaskBatchExecutionListenerTests {
 	@Import(EmbeddedDataSourceConfiguration.class)
 	public static class TaskNotEnabledConfiguration {
 
-		@Autowired
-		private JobRepository jobRepository;
-
-		@Autowired
-		PlatformTransactionManager transactionManager;
-
 		@Bean
-		public Job job() {
-			return new JobBuilder("job").start(
-					new StepBuilder("step1").repository(this.jobRepository).tasklet((contribution, chunkContext) -> {
+		public Job job(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
+			return new JobBuilder("job", jobRepository)
+					.start(new StepBuilder("step1", jobRepository).tasklet((contribution, chunkContext) -> {
 						System.out.println("Executed");
 						return RepeatStatus.FINISHED;
-					}).transactionManager(transactionManager).build()).repository(this.jobRepository).build();
+					}, transactionManager).build()).build();
+		}
+
+		@Bean
+		PlatformTransactionManager transactionManager() {
+			return new ResourcelessTransactionManager();
 		}
 
 	}
 
-	@EnableBatchProcessing
 	@TaskBatchTest
 	@EnableTask
 	@Import(EmbeddedDataSourceConfiguration.class)
 	public static class JobFactoryBeanConfiguration {
 
-		@Autowired
-		private JobRepository jobRepository;
-
-		@Autowired
-		private PlatformTransactionManager transactionManager;
-
 		@Bean
-		public FactoryBean<Job> job() {
+		public FactoryBean<Job> job(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
 			return new FactoryBean<Job>() {
 				@Override
 				public Job getObject() {
-					return new JobBuilder("job")
-							.start(new StepBuilder("step1").tasklet((contribution, chunkContext) -> {
+					return new JobBuilder("job", jobRepository)
+							.start(new StepBuilder("step1", jobRepository).tasklet((contribution, chunkContext) -> {
 								System.out.println("Executed");
 								return RepeatStatus.FINISHED;
-							}).transactionManager(transactionManager).repository(jobRepository).build())
-							.repository(jobRepository).build();
+							}, transactionManager).build()).build();
 				}
 
 				@Override
@@ -358,9 +350,13 @@ public class TaskBatchExecutionListenerTests {
 			};
 		}
 
+		@Bean
+		PlatformTransactionManager transactionManager() {
+			return new ResourcelessTransactionManager();
+		}
+
 	}
 
-	@EnableBatchProcessing
 	@TaskBatchTest
 	@EnableTask
 	@Import(EmbeddedDataSourceConfiguration.class)
@@ -368,16 +364,15 @@ public class TaskBatchExecutionListenerTests {
 
 		@Bean
 		public Job job(JobRepository jobRepository) {
-			return new JobBuilder("job").repository(jobRepository)
-					.start(new StepBuilder("step1").tasklet(new Tasklet() {
+			return new JobBuilder("job", jobRepository)
+					.start(new StepBuilder("step1", jobRepository).tasklet(new Tasklet() {
 						@Override
 						public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext)
 								throws Exception {
 							System.out.println("Executed");
 							return RepeatStatus.FINISHED;
 						}
-					}).transactionManager(new ResourcelessTransactionManager()).repository(jobRepository).build())
-					.build();
+					}, new ResourcelessTransactionManager()).build()).build();
 		}
 
 		@Bean
@@ -401,40 +396,38 @@ public class TaskBatchExecutionListenerTests {
 		}
 
 		@Bean
-		public DefaultBatchConfigurer batchConfigurer() {
-			return new DefaultBatchConfigurer(myDataSource());
+		PlatformTransactionManager transactionManager() {
+			return new ResourcelessTransactionManager();
 		}
 
 	}
 
-	@EnableBatchProcessing
 	@TaskBatchTest
 	@EnableTask
 	@Import(EmbeddedDataSourceConfiguration.class)
 	public static class MultipleJobConfiguration {
 
-		@Autowired
-		private JobRepository jobRepository;
-
-		@Autowired
-		private PlatformTransactionManager transactionManager;
-
 		@Bean
-		public Job job1() {
-			return new JobBuilder("job1").repository(this.jobRepository)
-					.start(new StepBuilder("job1step1").tasklet((contribution, chunkContext) -> {
+		public Job job1(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
+			return new JobBuilder("job1", jobRepository)
+					.start(new StepBuilder("job1step1", jobRepository).tasklet((contribution, chunkContext) -> {
 						System.out.println("Executed job1");
 						return RepeatStatus.FINISHED;
-					}).transactionManager(transactionManager).repository(this.jobRepository).build()).build();
+					}, transactionManager).build()).build();
 		}
 
 		@Bean
-		public Job job2() {
-			return new JobBuilder("job2").repository(this.jobRepository)
-					.start(new StepBuilder("job2step1").tasklet((contribution, chunkContext) -> {
+		public Job job2(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
+			return new JobBuilder("job2", jobRepository)
+					.start(new StepBuilder("job2step1", jobRepository).tasklet((contribution, chunkContext) -> {
 						System.out.println("Executed job2");
 						return RepeatStatus.FINISHED;
-					}).transactionManager(transactionManager).repository(this.jobRepository).build()).build();
+					}, transactionManager).build()).build();
+		}
+
+		@Bean
+		PlatformTransactionManager transactionManager() {
+			return new ResourcelessTransactionManager();
 		}
 
 	}