@Override public JobInstance createJobInstance(String jobName, JobParameters jobParameters) { Assert.notNull(jobName, "A job name is required to create a JobInstance"); Assert.notNull(jobParameters, "Job parameters are required to create a JobInstance"); JobInstance jobInstance = jobInstanceDao.createJobInstance(jobName, jobParameters); return jobInstance; }
/** * Trying to create instance twice for the same job+parameters causes error */ @Transactional @Test public void testCreateDuplicateInstance() { dao.createJobInstance(fooJob, fooParams); try { dao.createJobInstance(fooJob, fooParams); fail(); } catch (IllegalStateException e) { // expected } }
/** * Trying to create instance twice for the same job+parameters causes error */ @Transactional @Test public void testCreateDuplicateInstance() { jobParameters = new JobParameters(); jobInstanceDao.createJobInstance(jobName, jobParameters); try { jobInstanceDao.createJobInstance(jobName, jobParameters); fail(); } catch (IllegalStateException e) { // expected } }
@Transactional @Test public void testJobWithDefaultJobIdentifier() throws Exception { String testDefaultJob = "testDefault"; // Create job. jobInstance = jobInstanceDao.createJobInstance(testDefaultJob, jobParameters); JobInstance instance = jobInstanceDao.getJobInstance(testDefaultJob, jobParameters); assertNotNull(instance); }
@Transactional @Test public void testJobWithSimpleJobIdentifier() throws Exception { String testJob = "test"; // Create job. jobInstance = jobInstanceDao.createJobInstance(testJob, jobParameters); List<Map<String, Object>> jobs = jdbcTemplate.queryForList( "SELECT * FROM BATCH_JOB_INSTANCE where JOB_INSTANCE_ID=?", jobInstance.getId()); assertEquals(1, jobs.size()); assertEquals("test", jobs.get(0).get("JOB_NAME")); }
/** * Create and retrieve a job instance. */ @Transactional @Test public void testGetLastInstancesPastEnd() throws Exception { testCreateAndRetrieve(); // unrelated job instance that should be ignored by the query dao.createJobInstance("anotherJob", new JobParameters()); // we need two instances of the same job to check ordering dao.createJobInstance(fooJob, new JobParameters()); List<JobInstance> jobInstances = dao.getJobInstances(fooJob, 4, 2); assertEquals(0, jobInstances.size()); }
@Transactional @Test public void testCreationAddsVersion() { jobInstance = jobInstanceDao.createJobInstance("testCreationAddsVersion", new JobParameters()); assertNotNull(jobInstance.getVersion()); }
@Test public void testJobInstanceWildcard() { dao.createJobInstance("anotherJob", new JobParameters()); dao.createJobInstance("someJob", new JobParameters()); List<JobInstance> jobInstances = dao.findJobInstancesByName("*Job", 0, 2); assertEquals(2, jobInstances.size()); for (JobInstance instance : jobInstances) { assertTrue(instance.getJobName().contains("Job")); } jobInstances = dao.getJobInstances("Job*", 0, 2); assertTrue(jobInstances.isEmpty()); } }
@Before public void onSetUpInTransaction() throws Exception { // Create job. jobInstance = jobInstanceDao.createJobInstance(jobName, jobParameters); // Create an execution jobExecutionStartTime = new Date(System.currentTimeMillis()); jobExecution = new JobExecution(jobInstance, jobParameters); jobExecution.setStartTime(jobExecutionStartTime); jobExecution.setStatus(BatchStatus.STARTED); jobExecutionDao.saveJobExecution(jobExecution); }
@Transactional @Test public void testFindJobInstanceByExecution() { JobParameters jobParameters = new JobParameters(); JobInstance jobInstance = dao.createJobInstance("testInstance", jobParameters); JobExecution jobExecution = new JobExecution(jobInstance, 2L, jobParameters, null); jobExecutionDao.saveJobExecution(jobExecution); JobInstance returnedInstance = dao.getJobInstance(jobExecution); assertEquals(jobInstance, returnedInstance); }
/** * Create and retrieve a job instance. */ @Transactional @Test public void testGetLastInstances() throws Exception { testCreateAndRetrieve(); // unrelated job instance that should be ignored by the query dao.createJobInstance("anotherJob", new JobParameters()); // we need two instances of the same job to check ordering dao.createJobInstance(fooJob, new JobParameters()); List<JobInstance> jobInstances = dao.getJobInstances(fooJob, 0, 2); assertEquals(2, jobInstances.size()); assertEquals(fooJob, jobInstances.get(0).getJobName()); assertEquals(fooJob, jobInstances.get(1).getJobName()); assertEquals(Integer.valueOf(0), jobInstances.get(0).getVersion()); assertEquals(Integer.valueOf(0), jobInstances.get(1).getVersion()); assertTrue("Last instance should be first on the list", jobInstances.get(0).getId() > jobInstances.get(1) .getId()); }
@Transactional @Test public void testCreationAddsVersion() { JobInstance jobInstance = new JobInstance((long) 1, "testVersionAndId"); assertNull(jobInstance.getVersion()); jobInstance = dao.createJobInstance("testVersion", new JobParameters()); assertNotNull(jobInstance.getVersion()); }
/** * Create and retrieve a job instance. */ @Transactional @Test public void testGetLastInstancesPaged() throws Exception { testCreateAndRetrieve(); // unrelated job instance that should be ignored by the query dao.createJobInstance("anotherJob", new JobParameters()); // we need multiple instances of the same job to check ordering String multiInstanceJob = "multiInstanceJob"; String paramKey = "myID"; int instanceCount = 6; for (int i = 1; i <= instanceCount; i++) { JobParameters params = new JobParametersBuilder().addLong(paramKey, Long.valueOf(i)).toJobParameters(); dao.createJobInstance(multiInstanceJob, params); } int startIndex = 3; int queryCount = 2; List<JobInstance> jobInstances = dao.getJobInstances(multiInstanceJob, startIndex, queryCount); assertEquals(queryCount, jobInstances.size()); for (int i = 0; i < queryCount; i++) { JobInstance returnedInstance = jobInstances.get(i); assertEquals(multiInstanceJob, returnedInstance.getJobName()); assertEquals(Integer.valueOf(0), returnedInstance.getVersion()); //checks the correct instances are returned and the order is descending // assertEquals(instanceCount - startIndex - i , returnedInstance.getJobParameters().getLong(paramKey)); } }
@Transactional @Test public void testCreateAndRetrieve() throws Exception { JobInstance fooInstance = dao.createJobInstance(fooJob, fooParams); assertNotNull(fooInstance.getId()); assertEquals(fooJob, fooInstance.getJobName()); JobInstance retrievedInstance = dao.getJobInstance(fooJob, fooParams); assertEquals(fooInstance, retrievedInstance); assertEquals(fooJob, retrievedInstance.getJobName()); }
@Before public void onSetUp() throws Exception { dao = getJobExecutionDao(); jobParameters = new JobParameters(); jobInstance = getJobInstanceDao().createJobInstance("execTestJob", jobParameters); execution = new JobExecution(jobInstance, new JobParameters()); }
@Transactional @Test public void testCreateAndGetById() throws Exception { JobInstance fooInstance = dao.createJobInstance(fooJob, fooParams); assertNotNull(fooInstance.getId()); assertEquals(fooJob, fooInstance.getJobName()); JobInstance retrievedInstance = dao.getJobInstance(fooInstance.getId()); assertEquals(fooInstance, retrievedInstance); assertEquals(fooJob, retrievedInstance.getJobName()); }
/** * Test that ensures that if you create a job with a given name, then find a * job with the same name, but other pieces of the identifier different, you * get no result, not the existing one. */ @Transactional @Test public void testCreateJobWithExistingName() { String scheduledJob = "ScheduledJob"; jobInstanceDao.createJobInstance(scheduledJob, jobParameters); // Modifying the key should bring back a completely different // JobInstance JobParameters tempProps = new JobParametersBuilder().addString("job.key", "testKey1").toJobParameters(); JobInstance instance; instance = jobInstanceDao.getJobInstance(scheduledJob, jobParameters); assertNotNull(instance); instance = jobInstanceDao.getJobInstance(scheduledJob, tempProps); assertNull(instance); }
@Transactional @Test public void testCreateAndRetrieveWithNullParameter() throws Exception { JobParameters jobParameters = new JobParametersBuilder().addString("foo", null).toJobParameters(); JobInstance fooInstance = dao.createJobInstance(fooJob, jobParameters); assertNotNull(fooInstance.getId()); assertEquals(fooJob, fooInstance.getJobName()); JobInstance retrievedInstance = dao.getJobInstance(fooJob, jobParameters); assertEquals(fooInstance, retrievedInstance); assertEquals(fooJob, retrievedInstance.getJobName()); }
@Transactional @Test public void testSaveAndFindExecutionContexts() { List<StepExecution> stepExecutions = new ArrayList<>(); for (int i = 0; i < 3; i++) { JobInstance ji = jobInstanceDao.createJobInstance("testJob" + i, new JobParameters()); JobExecution je = new JobExecution(ji, new JobParameters()); jobExecutionDao.saveJobExecution(je); StepExecution se = new StepExecution("step" + i, je); se.setStatus(BatchStatus.STARTED); se.setReadSkipCount(i); se.setProcessSkipCount(i); se.setWriteSkipCount(i); se.setProcessSkipCount(i); se.setRollbackCount(i); se.setLastUpdated(new Date(System.currentTimeMillis())); se.setReadCount(i); se.setFilterCount(i); se.setWriteCount(i); stepExecutions.add(se); } stepExecutionDao.saveStepExecutions(stepExecutions); contextDao.saveExecutionContexts(stepExecutions); for (int i = 0; i < 3; i++) { ExecutionContext retrieved = contextDao.getExecutionContext(stepExecutions.get(i).getJobExecution()); assertEquals(stepExecutions.get(i).getExecutionContext(), retrieved); } }
@Before public void setUp() { jobInstanceDao = getJobInstanceDao(); jobExecutionDao = getJobExecutionDao(); stepExecutionDao = getStepExecutionDao(); contextDao = getExecutionContextDao(); JobInstance ji = jobInstanceDao.createJobInstance("testJob", new JobParameters()); jobExecution = new JobExecution(ji, new JobParameters()); jobExecutionDao.saveJobExecution(jobExecution); stepExecution = new StepExecution("stepName", jobExecution); stepExecutionDao.saveStepExecution(stepExecution); }