@Override public JobExecution createJobExecution(JobInstance jobInstance, JobParameters jobParameters, String jobConfigurationLocation) { Assert.notNull(jobInstance, "A JobInstance is required to associate the JobExecution with"); Assert.notNull(jobParameters, "A JobParameters object is required to create a JobExecution"); JobExecution jobExecution = new JobExecution(jobInstance, jobParameters, jobConfigurationLocation); ExecutionContext executionContext = new ExecutionContext(); jobExecution.setExecutionContext(executionContext); jobExecution.setLastUpdated(new Date(System.currentTimeMillis())); // Save the JobExecution so that it picks up an ID (useful for clients // monitoring asynchronous executions): jobExecutionDao.saveJobExecution(jobExecution); ecDao.saveExecutionContext(jobExecution); return jobExecution; } }
/** * Executions should be returned in the reverse order they were saved. */ @Transactional @Test public void testFindExecutionsOrdering() { List<JobExecution> execs = new ArrayList<>(); for (int i = 0; i < 10; i++) { JobExecution exec = new JobExecution(jobInstance, jobParameters); exec.setCreateTime(new Date(i)); execs.add(exec); dao.saveJobExecution(exec); } List<JobExecution> retrieved = dao.findJobExecutions(jobInstance); Collections.reverse(retrieved); for (int i = 0; i < 10; i++) { assertExecutionsAreEqual(execs.get(i), retrieved.get(i)); } }
/** * Save and find a job execution. */ @Transactional @Test public void testSaveAndFind() { execution.setStartTime(new Date(System.currentTimeMillis())); execution.setLastUpdated(new Date(System.currentTimeMillis())); execution.setExitStatus(ExitStatus.UNKNOWN); execution.setEndTime(new Date(System.currentTimeMillis())); dao.saveJobExecution(execution); List<JobExecution> executions = dao.findJobExecutions(jobInstance); assertEquals(1, executions.size()); assertEquals(execution, executions.get(0)); assertExecutionsAreEqual(execution, executions.get(0)); }
/** * Check the execution with most recent start time is returned */ @Transactional @Test public void testGetLastExecution() { JobExecution exec1 = new JobExecution(jobInstance, jobParameters); exec1.setCreateTime(new Date(0)); JobExecution exec2 = new JobExecution(jobInstance, jobParameters); exec2.setCreateTime(new Date(1)); dao.saveJobExecution(exec1); dao.saveJobExecution(exec2); JobExecution last = dao.getLastJobExecution(jobInstance); assertEquals(exec2, last); }
@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); }
@Override public void run() { try { JobExecution jobExecution = new JobExecution(new JobInstance((long) -1, "mapJob"), new JobParameters()); latch.await(); tested.saveJobExecution(jobExecution); ids.add(jobExecution.getId()); } catch(Exception e) { exception.set(e); } } };
@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); }
jobExecutionDao.saveJobExecution(jobExecution); ecDao.saveExecutionContext(jobExecution);
@Transactional @Test public void testGetLastJobExecution() { JobExecution lastExecution = new JobExecution(jobInstance, jobParameters); lastExecution.setStatus(BatchStatus.STARTED); int JUMP_INTO_FUTURE = 1000; // makes sure start time is 'greatest' lastExecution.setCreateTime(new Date(System.currentTimeMillis() + JUMP_INTO_FUTURE)); jobExecutionDao.saveJobExecution(lastExecution); assertEquals(lastExecution, jobExecutionDao.getLastJobExecution(jobInstance)); assertNotNull(lastExecution.getJobParameters()); assertEquals("jobKey", lastExecution.getJobParameters().getString("job.key")); }
exec.setEndTime(new Date(2L)); exec.setLastUpdated(new Date(5L)); dao.saveJobExecution(exec); dao.saveJobExecution(exec); exec.setLastUpdated(new Date(5L)); exec.createStepExecution("step"); dao.saveJobExecution(exec);
/** * Update and retrieve job execution - check attributes have changed as * expected. */ @Transactional @Test public void testUpdateExecution() { execution.setStatus(BatchStatus.STARTED); dao.saveJobExecution(execution); execution.setLastUpdated(new Date(0)); execution.setStatus(BatchStatus.COMPLETED); dao.updateJobExecution(execution); JobExecution updated = dao.findJobExecutions(jobInstance).get(0); assertEquals(execution, updated); assertEquals(BatchStatus.COMPLETED, updated.getStatus()); assertExecutionsAreEqual(execution, updated); }
/** * Saving sets id to the entity. */ @Transactional @Test public void testSaveAddsIdAndVersion() { assertNull(execution.getId()); assertNull(execution.getVersion()); dao.saveJobExecution(execution); assertNotNull(execution.getId()); assertNotNull(execution.getVersion()); }
@Transactional @Test public void testSaveAddsVersionAndId() { JobExecution jobExecution = new JobExecution(jobInstance, jobParameters); assertNull(jobExecution.getId()); assertNull(jobExecution.getVersion()); jobExecutionDao.saveJobExecution(jobExecution); assertNotNull(jobExecution.getId()); assertNotNull(jobExecution.getVersion()); }
/** * Check the execution is returned */ @Transactional @Test public void testGetExecution() { JobExecution exec = new JobExecution(jobInstance, jobParameters); exec.setCreateTime(new Date(0)); exec.createStepExecution("step"); dao.saveJobExecution(exec); StepExecutionDao stepExecutionDao = getStepExecutionDao(); if (stepExecutionDao != null) { for (StepExecution stepExecution : exec.getStepExecutions()) { stepExecutionDao.saveStepExecution(stepExecution); } } JobExecution value = dao.getJobExecution(exec.getId()); assertEquals(exec, value); // N.B. the job instance is not re-hydrated in the JDBC case... }
@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); } }
/** * Modifications to saved entity do not affect the persisted object. */ @Test public void testPersistentCopy() { JobExecutionDao tested = new MapJobExecutionDao(); JobExecution jobExecution = new JobExecution(new JobInstance((long) 1, "mapJob"), new JobParameters()); assertNull(jobExecution.getStartTime()); tested.saveJobExecution(jobExecution); jobExecution.setStartTime(new Date()); JobExecution retrieved = tested.getJobExecution(jobExecution.getId()); assertNull(retrieved.getStartTime()); tested.updateJobExecution(jobExecution); jobExecution.setEndTime(new Date()); assertNull(retrieved.getEndTime()); }
@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); }
/** * Exception should be raised when the version of update argument doesn't * match the version of persisted entity. */ @Transactional @Test public void testConcurrentModificationException() { JobExecution exec1 = new JobExecution(jobInstance, jobParameters); dao.saveJobExecution(exec1); JobExecution exec2 = new JobExecution(jobInstance, jobParameters); exec2.setId(exec1.getId()); exec2.incrementVersion(); assertEquals((Integer) 0, exec1.getVersion()); assertEquals(exec1.getVersion(), exec2.getVersion()); dao.updateJobExecution(exec1); assertEquals((Integer) 1, exec1.getVersion()); try { dao.updateJobExecution(exec2); fail(); } catch (OptimisticLockingFailureException e) { // expected } }
/** * Successful synchronization from STARTED to STOPPING status. */ @Transactional @Test public void testSynchronizeStatusUpgrade() { JobExecution exec1 = new JobExecution(jobInstance, jobParameters); exec1.setStatus(BatchStatus.STOPPING); dao.saveJobExecution(exec1); JobExecution exec2 = new JobExecution(jobInstance, jobParameters); assertTrue(exec1.getId() != null); exec2.setId(exec1.getId()); exec2.setStatus(BatchStatus.STARTED); exec2.setVersion(7); assertTrue(exec1.getVersion() != exec2.getVersion()); assertTrue(exec1.getStatus() != exec2.getStatus()); dao.synchronizeStatus(exec2); assertEquals(exec1.getVersion(), exec2.getVersion()); assertEquals(exec1.getStatus(), exec2.getStatus()); }
/** * UNKNOWN status won't be changed by synchronizeStatus, because it is the * 'largest' BatchStatus (will not downgrade). */ @Transactional @Test public void testSynchronizeStatusDowngrade() { JobExecution exec1 = new JobExecution(jobInstance, jobParameters); exec1.setStatus(BatchStatus.STARTED); dao.saveJobExecution(exec1); JobExecution exec2 = new JobExecution(jobInstance, jobParameters); assertTrue(exec1.getId() != null); exec2.setId(exec1.getId()); exec2.setStatus(BatchStatus.UNKNOWN); exec2.setVersion(7); assertTrue(exec1.getVersion() != exec2.getVersion()); assertTrue(exec1.getStatus().isLessThan(exec2.getStatus())); dao.synchronizeStatus(exec2); assertEquals(exec1.getVersion(), exec2.getVersion()); assertEquals(BatchStatus.UNKNOWN, exec2.getStatus()); }