diff --git a/spring-batch-core-tests/src/test/java/org/springframework/batch/core/test/AbstractIntegrationTests.java b/spring-batch-core-tests/src/test/java/org/springframework/batch/core/test/AbstractIntegrationTests.java new file mode 100644 index 000000000..0dfa9fb51 --- /dev/null +++ b/spring-batch-core-tests/src/test/java/org/springframework/batch/core/test/AbstractIntegrationTests.java @@ -0,0 +1,41 @@ +/* + * Copyright 2006-2019 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.batch.core.test; + +import javax.sql.DataSource; + +import org.junit.Before; + +import org.springframework.core.io.ClassPathResource; +import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator; + +/** + * @author Mahmoud Ben Hassine + */ +public class AbstractIntegrationTests { + + protected DataSource dataSource; + + @Before + public void setUp() { + ResourceDatabasePopulator databasePopulator = new ResourceDatabasePopulator(); + databasePopulator.addScript(new ClassPathResource("/org/springframework/batch/core/schema-drop-hsqldb.sql")); + databasePopulator.addScript(new ClassPathResource("/org/springframework/batch/core/schema-hsqldb.sql")); + databasePopulator.addScript(new ClassPathResource("/business-schema-hsqldb.sql")); + databasePopulator.execute(this.dataSource); + } + +} diff --git a/spring-batch-core-tests/src/test/java/org/springframework/batch/core/test/football/FootballJobIntegrationTests.java b/spring-batch-core-tests/src/test/java/org/springframework/batch/core/test/football/FootballJobIntegrationTests.java index 240fa2342..7776481b3 100644 --- a/spring-batch-core-tests/src/test/java/org/springframework/batch/core/test/football/FootballJobIntegrationTests.java +++ b/spring-batch-core-tests/src/test/java/org/springframework/batch/core/test/football/FootballJobIntegrationTests.java @@ -1,84 +1,76 @@ -/* - * Copyright 2006-2009 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.batch.core.test.football; - -import static org.junit.Assert.assertEquals; - -import javax.sql.DataSource; - -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.springframework.batch.core.BatchStatus; -import org.springframework.batch.core.Job; -import org.springframework.batch.core.JobExecution; -import org.springframework.batch.core.JobParametersBuilder; -import org.springframework.batch.core.StepExecution; -import org.springframework.batch.core.launch.JobLauncher; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.jdbc.core.JdbcTemplate; -import org.springframework.test.context.ContextConfiguration; -import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; -import org.springframework.test.jdbc.JdbcTestUtils; - -/** - * @author Dave Syer - * - */ -@RunWith(SpringJUnit4ClassRunner.class) -@ContextConfiguration(locations = { "/simple-job-launcher-context.xml", "/META-INF/batch/footballJob.xml" }) -public class FootballJobIntegrationTests { - - /** Logger */ - private final Log logger = LogFactory.getLog(getClass()); - - private JdbcTemplate jdbcTemplate; - - @Autowired - private JobLauncher jobLauncher; - - @Autowired - private Job job; - - @Autowired - public void setDataSource(DataSource dataSource) { - this.jdbcTemplate = new JdbcTemplate(dataSource); - } - - @Before - public void clear() { - JdbcTestUtils.deleteFromTables(jdbcTemplate, "PLAYER_SUMMARY", "GAMES", "PLAYERS"); - } - - @Test - public void testLaunchJob() throws Exception { - JobExecution execution = jobLauncher.run(job, new JobParametersBuilder().addLong("commit.interval", 10L) - .toJobParameters()); - assertEquals(BatchStatus.COMPLETED, execution.getStatus()); - for (StepExecution stepExecution : execution.getStepExecutions()) { - logger.info("Processed: " + stepExecution); - if (stepExecution.getStepName().equals("playerload")) { - // The effect of the retries - assertEquals(new Double(Math.ceil(stepExecution.getReadCount() / 10. + 1)).intValue(), - stepExecution.getCommitCount()); - } - } - } - -} +/* + * Copyright 2006-2019 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.batch.core.test.football; + +import static org.junit.Assert.assertEquals; + +import javax.sql.DataSource; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.batch.core.BatchStatus; +import org.springframework.batch.core.Job; +import org.springframework.batch.core.JobExecution; +import org.springframework.batch.core.JobParametersBuilder; +import org.springframework.batch.core.StepExecution; +import org.springframework.batch.core.launch.JobLauncher; +import org.springframework.batch.core.test.AbstractIntegrationTests; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +/** + * @author Dave Syer + * @author Mahmoud Ben Hassine + * + */ +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(locations = { "/simple-job-launcher-context.xml", "/META-INF/batch/footballJob.xml" }) +public class FootballJobIntegrationTests extends AbstractIntegrationTests { + + /** Logger */ + private final Log logger = LogFactory.getLog(getClass()); + + @Autowired + private JobLauncher jobLauncher; + + @Autowired + private Job job; + + @Autowired + public void setDataSource(DataSource dataSource) { + this.dataSource = dataSource; + } + + @Test + public void testLaunchJob() throws Exception { + JobExecution execution = jobLauncher.run(job, new JobParametersBuilder().addLong("commit.interval", 10L) + .toJobParameters()); + assertEquals(BatchStatus.COMPLETED, execution.getStatus()); + for (StepExecution stepExecution : execution.getStepExecutions()) { + logger.info("Processed: " + stepExecution); + if (stepExecution.getStepName().equals("playerload")) { + // The effect of the retries + assertEquals(new Double(Math.ceil(stepExecution.getReadCount() / 10. + 1)).intValue(), + stepExecution.getCommitCount()); + } + } + } + +} diff --git a/spring-batch-core-tests/src/test/java/org/springframework/batch/core/test/football/FootballJobSkipIntegrationTests.java b/spring-batch-core-tests/src/test/java/org/springframework/batch/core/test/football/FootballJobSkipIntegrationTests.java index feceecc20..2244f6955 100644 --- a/spring-batch-core-tests/src/test/java/org/springframework/batch/core/test/football/FootballJobSkipIntegrationTests.java +++ b/spring-batch-core-tests/src/test/java/org/springframework/batch/core/test/football/FootballJobSkipIntegrationTests.java @@ -1,116 +1,112 @@ -/* - * Copyright 2006-2009 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.batch.core.test.football; - -import static org.junit.Assert.assertEquals; - -import javax.sql.DataSource; - -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.springframework.batch.core.BatchStatus; -import org.springframework.batch.core.Job; -import org.springframework.batch.core.JobExecution; -import org.springframework.batch.core.JobParametersBuilder; -import org.springframework.batch.core.StepExecution; -import org.springframework.batch.core.launch.JobLauncher; -import org.springframework.batch.support.DatabaseType; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.jdbc.core.JdbcTemplate; -import org.springframework.test.context.ContextConfiguration; -import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; -import org.springframework.test.jdbc.JdbcTestUtils; - -/** - * @author Dave Syer - * - */ -@RunWith(SpringJUnit4ClassRunner.class) -@ContextConfiguration(locations = { "/simple-job-launcher-context.xml", "/META-INF/batch/footballSkipJob.xml" }) -public class FootballJobSkipIntegrationTests { - - /** Logger */ - private final Log logger = LogFactory.getLog(getClass()); - - private JdbcTemplate jdbcTemplate; - - @Autowired - private JobLauncher jobLauncher; - - @Autowired - private Job job; - - private DatabaseType databaseType; - - @Autowired - public void setDataSource(DataSource dataSource) throws Exception { - this.jdbcTemplate = new JdbcTemplate(dataSource); - databaseType = DatabaseType.fromMetaData(dataSource); - } - - @Before - public void clear() { - JdbcTestUtils.deleteFromTables(jdbcTemplate, "PLAYER_SUMMARY", "GAMES", "PLAYERS"); - } - - @Test - public void testLaunchJob() throws Exception { - try { - if (databaseType == DatabaseType.POSTGRES || databaseType == DatabaseType.ORACLE) { - // Extra special test for these platforms (would have failed - // the job with UNKNOWN status in Batch 2.0): - jdbcTemplate.update("SET CONSTRAINTS ALL DEFERRED"); - } - } - catch (Exception e) { - // Ignore (wrong platform) - } - JobExecution execution = jobLauncher.run(job, new JobParametersBuilder().addLong("skip.limit", 0L) - .toJobParameters()); - assertEquals(BatchStatus.COMPLETED, execution.getStatus()); - for (StepExecution stepExecution : execution.getStepExecutions()) { - logger.info("Processed: " + stepExecution); - } - // They all skip on the second execution because of a primary key - // violation - long retryLimit = 2L; - execution = jobLauncher.run(job, - new JobParametersBuilder().addLong("skip.limit", 100000L).addLong("retry.limit", retryLimit) - .toJobParameters()); - assertEquals(BatchStatus.COMPLETED, execution.getStatus()); - for (StepExecution stepExecution : execution.getStepExecutions()) { - logger.info("Processed: " + stepExecution); - if (stepExecution.getStepName().equals("playerload")) { - // The effect of the retries is to increase the number of - // rollbacks - int commitInterval = stepExecution.getReadCount() / (stepExecution.getCommitCount() - 1); - // Account for the extra empty commit if the read count is - // commensurate with the commit interval - int effectiveCommitCount = stepExecution.getReadCount() % commitInterval == 0 ? stepExecution - .getCommitCount() - 1 : stepExecution.getCommitCount(); - long expectedRollbacks = Math.max(1, retryLimit) * effectiveCommitCount + stepExecution.getReadCount(); - assertEquals(expectedRollbacks, stepExecution.getRollbackCount()); - assertEquals(stepExecution.getReadCount(), stepExecution.getWriteSkipCount()); - } - } - - } - -} +/* + * Copyright 2006-2019 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.batch.core.test.football; + +import static org.junit.Assert.assertEquals; + +import javax.sql.DataSource; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.batch.core.BatchStatus; +import org.springframework.batch.core.Job; +import org.springframework.batch.core.JobExecution; +import org.springframework.batch.core.JobParametersBuilder; +import org.springframework.batch.core.StepExecution; +import org.springframework.batch.core.launch.JobLauncher; +import org.springframework.batch.core.test.AbstractIntegrationTests; +import org.springframework.batch.support.DatabaseType; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +/** + * @author Dave Syer + * @author Mahmoud Ben Hassine + * + */ +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(locations = { "/simple-job-launcher-context.xml", "/META-INF/batch/footballSkipJob.xml" }) +public class FootballJobSkipIntegrationTests extends AbstractIntegrationTests { + + /** Logger */ + private final Log logger = LogFactory.getLog(getClass()); + + private JdbcTemplate jdbcTemplate; + + @Autowired + private JobLauncher jobLauncher; + + @Autowired + private Job job; + + private DatabaseType databaseType; + + @Autowired + public void setDataSource(DataSource dataSource) throws Exception { + this.dataSource = dataSource; + this.jdbcTemplate = new JdbcTemplate(dataSource); + databaseType = DatabaseType.fromMetaData(dataSource); + } + + @Test + public void testLaunchJob() throws Exception { + try { + if (databaseType == DatabaseType.POSTGRES || databaseType == DatabaseType.ORACLE) { + // Extra special test for these platforms (would have failed + // the job with UNKNOWN status in Batch 2.0): + jdbcTemplate.update("SET CONSTRAINTS ALL DEFERRED"); + } + } + catch (Exception e) { + // Ignore (wrong platform) + } + JobExecution execution = jobLauncher.run(job, new JobParametersBuilder().addLong("skip.limit", 0L) + .toJobParameters()); + assertEquals(BatchStatus.COMPLETED, execution.getStatus()); + for (StepExecution stepExecution : execution.getStepExecutions()) { + logger.info("Processed: " + stepExecution); + } + // They all skip on the second execution because of a primary key + // violation + long retryLimit = 2L; + execution = jobLauncher.run(job, + new JobParametersBuilder().addLong("skip.limit", 100000L).addLong("retry.limit", retryLimit) + .toJobParameters()); + assertEquals(BatchStatus.COMPLETED, execution.getStatus()); + for (StepExecution stepExecution : execution.getStepExecutions()) { + logger.info("Processed: " + stepExecution); + if (stepExecution.getStepName().equals("playerload")) { + // The effect of the retries is to increase the number of + // rollbacks + int commitInterval = stepExecution.getReadCount() / (stepExecution.getCommitCount() - 1); + // Account for the extra empty commit if the read count is + // commensurate with the commit interval + int effectiveCommitCount = stepExecution.getReadCount() % commitInterval == 0 ? stepExecution + .getCommitCount() - 1 : stepExecution.getCommitCount(); + long expectedRollbacks = Math.max(1, retryLimit) * effectiveCommitCount + stepExecution.getReadCount(); + assertEquals(expectedRollbacks, stepExecution.getRollbackCount()); + assertEquals(stepExecution.getReadCount(), stepExecution.getWriteSkipCount()); + } + } + + } + +} diff --git a/spring-batch-core-tests/src/test/java/org/springframework/batch/core/test/repository/JdbcJobRepositoryTests.java b/spring-batch-core-tests/src/test/java/org/springframework/batch/core/test/repository/JdbcJobRepositoryTests.java index 43bd55740..41934a123 100644 --- a/spring-batch-core-tests/src/test/java/org/springframework/batch/core/test/repository/JdbcJobRepositoryTests.java +++ b/spring-batch-core-tests/src/test/java/org/springframework/batch/core/test/repository/JdbcJobRepositoryTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2006-2018 the original author or authors. + * Copyright 2006-2019 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. @@ -26,7 +26,6 @@ import javax.sql.DataSource; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.junit.After; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; @@ -36,6 +35,7 @@ import org.springframework.batch.core.JobExecution; import org.springframework.batch.core.JobParameters; import org.springframework.batch.core.repository.JobExecutionAlreadyRunningException; import org.springframework.batch.core.repository.JobRepository; +import org.springframework.batch.core.test.AbstractIntegrationTests; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.test.context.ContextConfiguration; @@ -48,7 +48,7 @@ import static org.junit.Assert.fail; @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations = { "/simple-job-launcher-context.xml" }) -public class JdbcJobRepositoryTests { +public class JdbcJobRepositoryTests extends AbstractIntegrationTests { private JobSupport job; @@ -68,39 +68,17 @@ public class JdbcJobRepositoryTests { @Autowired public void setDataSource(DataSource dataSource) { + this.dataSource = dataSource; this.jdbcTemplate = new JdbcTemplate(dataSource); } @Before public void onSetUpInTransaction() throws Exception { + super.setUp(); job = new JobSupport("test-job"); job.setRestartable(true); } - @After - public void onTearDownAfterTransaction() throws Exception { - - jdbcTemplate.update("DELETE FROM BATCH_STEP_EXECUTION_CONTEXT"); - jdbcTemplate.update("DELETE FROM BATCH_JOB_EXECUTION_CONTEXT"); - jdbcTemplate.update("DELETE FROM BATCH_STEP_EXECUTION"); - jdbcTemplate.update("DELETE FROM BATCH_JOB_EXECUTION_PARAMS"); - jdbcTemplate.update("DELETE FROM BATCH_JOB_EXECUTION"); - jdbcTemplate.update("DELETE FROM BATCH_JOB_INSTANCE"); - -// for (Long id : jobExecutionIds) { -// jdbcTemplate.update("DELETE FROM BATCH_JOB_EXECUTION_CONTEXT where JOB_EXECUTION_ID=?", id); -// jdbcTemplate.update("DELETE FROM BATCH_JOB_EXECUTION where JOB_EXECUTION_ID=?", id); -// } -// for (Long id : jobIds) { -// jdbcTemplate.update("DELETE FROM BATCH_JOB_INSTANCE where JOB_INSTANCE_ID=?", id); -// } -// for (Long id : jobIds) { -// int count = jdbcTemplate.queryForObject( -// "SELECT COUNT(*) FROM BATCH_JOB_INSTANCE where JOB_INSTANCE_ID=?", Integer.class, id); -// assertEquals(0, count); -// } - } - @Test public void testFindOrCreateJob() throws Exception { job.setName("foo"); diff --git a/spring-batch-core-tests/src/test/java/org/springframework/batch/core/test/timeout/TimeoutJobIntegrationTests.java b/spring-batch-core-tests/src/test/java/org/springframework/batch/core/test/timeout/TimeoutJobIntegrationTests.java index eec8e7fed..4fef87a68 100644 --- a/spring-batch-core-tests/src/test/java/org/springframework/batch/core/test/timeout/TimeoutJobIntegrationTests.java +++ b/spring-batch-core-tests/src/test/java/org/springframework/batch/core/test/timeout/TimeoutJobIntegrationTests.java @@ -1,67 +1,75 @@ -/* - * Copyright 2014 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.batch.core.test.timeout; - -import static org.junit.Assert.assertEquals; - -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.springframework.batch.core.BatchStatus; -import org.springframework.batch.core.Job; -import org.springframework.batch.core.JobExecution; -import org.springframework.batch.core.JobParametersBuilder; -import org.springframework.batch.core.launch.JobLauncher; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.beans.factory.annotation.Qualifier; -import org.springframework.test.context.ContextConfiguration; -import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; - -@RunWith(SpringJUnit4ClassRunner.class) -@ContextConfiguration(locations = { "/simple-job-launcher-context.xml", "/META-INF/batch/timeoutJob.xml" }) -public class TimeoutJobIntegrationTests { - - /** Logger */ - @SuppressWarnings("unused") - private final Log logger = LogFactory.getLog(getClass()); - - @Autowired - private JobLauncher jobLauncher; - - @Autowired - @Qualifier("chunkTimeoutJob") - private Job chunkTimeoutJob; - - @Autowired - @Qualifier("taskletTimeoutJob") - private Job taskletTimeoutJob; - - @Test - public void testChunkTimeoutShouldFail() throws Exception { - JobExecution execution = jobLauncher.run(chunkTimeoutJob, new JobParametersBuilder().addLong("id", System.currentTimeMillis()) - .toJobParameters()); - assertEquals(BatchStatus.FAILED, execution.getStatus()); - } - - @Test - public void testTaskletTimeoutShouldFail() throws Exception { - JobExecution execution = jobLauncher.run(taskletTimeoutJob, new JobParametersBuilder().addLong("id", System.currentTimeMillis()) - .toJobParameters()); - assertEquals(BatchStatus.FAILED, execution.getStatus()); - } - -} +/* + * Copyright 2014 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.batch.core.test.timeout; + +import javax.sql.DataSource; + +import static org.junit.Assert.assertEquals; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.batch.core.BatchStatus; +import org.springframework.batch.core.Job; +import org.springframework.batch.core.JobExecution; +import org.springframework.batch.core.JobParametersBuilder; +import org.springframework.batch.core.launch.JobLauncher; +import org.springframework.batch.core.test.AbstractIntegrationTests; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(locations = { "/simple-job-launcher-context.xml", "/META-INF/batch/timeoutJob.xml" }) +public class TimeoutJobIntegrationTests extends AbstractIntegrationTests { + + /** Logger */ + @SuppressWarnings("unused") + private final Log logger = LogFactory.getLog(getClass()); + + @Autowired + private JobLauncher jobLauncher; + + @Autowired + @Qualifier("chunkTimeoutJob") + private Job chunkTimeoutJob; + + @Autowired + @Qualifier("taskletTimeoutJob") + private Job taskletTimeoutJob; + + @Autowired + public void setDataSource(DataSource dataSource) { + this.dataSource = dataSource; + } + + @Test + public void testChunkTimeoutShouldFail() throws Exception { + JobExecution execution = jobLauncher.run(chunkTimeoutJob, new JobParametersBuilder().addLong("id", System.currentTimeMillis()) + .toJobParameters()); + assertEquals(BatchStatus.FAILED, execution.getStatus()); + } + + @Test + public void testTaskletTimeoutShouldFail() throws Exception { + JobExecution execution = jobLauncher.run(taskletTimeoutJob, new JobParametersBuilder().addLong("id", System.currentTimeMillis()) + .toJobParameters()); + assertEquals(BatchStatus.FAILED, execution.getStatus()); + } + +}