How to use

org.springframework.batch.core.job.flow.support.SimpleFlow

constructor

protected Flow flow() {
  if (!dirty) {
    // optimization in case this method is called consecutively
    return flow;
  }
  flow = new SimpleFlow(name);
  // optimization for flows that only have one state that itself is a flow:
  if (currentState instanceof FlowState && states.size() == 1) {
    return ((FlowState) currentState).getFlows().iterator().next();
  }
  addDanglingEndStates();
  flow.setStateTransitions(transitions);
  dirty = false;
  return flow;
}

@Before
public void setUp() {
  flow = new SimpleFlow("job");
}

@Bean
public SimpleFlow simpleFlow() {
  SimpleFlow simpleFlow = new SimpleFlow("simpleFlow");
  List<StateTransition> transitions = new ArrayList<>();
  transitions.add(StateTransition.createStateTransition(new StepState(dummyStep()), "end0"));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.COMPLETED, "end0")));
  simpleFlow.setStateTransitions(transitions);
  return simpleFlow;
}

@Test
public void testBasicFlow() throws Throwable {
  SimpleFlow flow = new SimpleFlow("job");
  List<StateTransition> transitions = new ArrayList<>();
  transitions.add(StateTransition.createStateTransition(new StepState(new StubStep("step")), "end0"));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.COMPLETED, "end0")));
  flow.setStateTransitions(transitions);
  job.setFlow(flow);
  job.execute(jobExecution);
  if (!jobExecution.getAllFailureExceptions().isEmpty()) {
    throw jobExecution.getAllFailureExceptions().get(0);
  }
  assertEquals(BatchStatus.COMPLETED, jobExecution.getStatus());
}

@Test
public void testGetStepNestedFlow() throws Exception {
  SimpleFlow nested = new SimpleFlow("nested");
  List<StateTransition> transitions = new ArrayList<>();
  transitions.add(StateTransition.createStateTransition(new StepState(new StubStep("step2")), "end1"));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.COMPLETED, "end1")));
  nested.setStateTransitions(transitions);
  nested.afterPropertiesSet();
  SimpleFlow flow = new SimpleFlow("job");
  transitions = new ArrayList<>();
  transitions.add(StateTransition.createStateTransition(new StepState(new StubStep("step1")), "nested"));
  transitions.add(StateTransition.createStateTransition(new FlowState(nested, "nested"), "end0"));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.COMPLETED, "end0")));
  flow.setStateTransitions(transitions);
  flow.afterPropertiesSet();
  job.setFlow(flow);
  job.afterPropertiesSet();
  List<String> names = new ArrayList<>(job.getStepNames());
  Collections.sort(names);
  assertEquals("[step1, step2]", names.toString());
}

@Test
public void testGetSteps() throws Exception {
  SimpleFlow flow = new SimpleFlow("job");
  List<StateTransition> transitions = new ArrayList<>();
  transitions.add(StateTransition.createStateTransition(new StepState(new StubStep("step1")), "step2"));
  transitions.add(StateTransition.createStateTransition(new StepState(new StubStep("step2")), "end0"));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.COMPLETED, "end0")));
  flow.setStateTransitions(transitions);
  flow.afterPropertiesSet();
  job.setFlow(flow);
  job.afterPropertiesSet();
  assertEquals(2, job.getStepNames().size());
}

@Test
public void testGetStepNamesWithPrefix() throws Exception {
  SimpleFlow flow = new SimpleFlow("job");
  List<StateTransition> transitions = new ArrayList<>();
  transitions.add(StateTransition.createStateTransition(new StepState("job.step", new StubStep("step")), "end0"));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.COMPLETED, "end0")));
  flow.setStateTransitions(transitions);
  flow.afterPropertiesSet();
  job.setFlow(flow);
  job.setName(flow.getName());
  job.afterPropertiesSet();
  assertEquals("[step]", job.getStepNames().toString());
}

@Test
public void testStepFailure() throws Exception {
  SimpleFlow flow = new SimpleFlow("job");
  List<StateTransition> transitions = new ArrayList<>();
  StepState step = new StepState(new StepSupport("step"));
  transitions.add(StateTransition.createStateTransition(step, ExitStatus.FAILED.getExitCode(), "end0"));
  transitions.add(StateTransition.createStateTransition(step, ExitStatus.COMPLETED.getExitCode(), "end1"));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.FAILED, "end0")));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.COMPLETED, "end1")));
  flow.setStateTransitions(transitions);
  job.setFlow(flow);
  job.afterPropertiesSet();
  job.execute(execution);
  assertEquals(BatchStatus.FAILED, execution.getStatus());
}

@Test
public void testInterruptedException() throws Exception {
  SimpleFlow flow = new SimpleFlow("job");
  List<StateTransition> transitions = new ArrayList<>();
  transitions.add(StateTransition.createStateTransition(new StepState(new StubStep("step1") {
    @Override
    public void execute(StepExecution stepExecution) throws JobInterruptedException {
      throw new JobInterruptedException("Stopped");
    }
  }), "end0"));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.COMPLETED, "end0")));
  flow.setStateTransitions(transitions);
  flow.afterPropertiesSet();
  job.setFlow(flow);
  job.afterPropertiesSet();
  job.execute(jobExecution);
  assertEquals(BatchStatus.STOPPED, jobExecution.getStatus());
  checkRepository(BatchStatus.STOPPED, ExitStatus.STOPPED);
  assertEquals(1, jobExecution.getAllFailureExceptions().size());
  assertEquals(JobInterruptedException.class, jobExecution.getFailureExceptions().get(0).getClass());
}

@Test
public void testInterrupted() throws Exception {
  SimpleFlow flow = new SimpleFlow("job");
  List<StateTransition> transitions = new ArrayList<>();
  transitions.add(StateTransition.createStateTransition(new StepState(new StubStep("step1") {
    @Override
    public void execute(StepExecution stepExecution) throws JobInterruptedException {
      stepExecution.setStatus(BatchStatus.STOPPING);
      jobRepository.update(stepExecution);
    }
  }), "end0"));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.COMPLETED, "end0")));
  flow.setStateTransitions(transitions);
  flow.afterPropertiesSet();
  job.setFlow(flow);
  job.afterPropertiesSet();
  job.execute(jobExecution);
  assertEquals(BatchStatus.STOPPED, jobExecution.getStatus());
  checkRepository(BatchStatus.STOPPED, ExitStatus.STOPPED);
  assertEquals(1, jobExecution.getAllFailureExceptions().size());
  assertEquals(JobInterruptedException.class, jobExecution.getFailureExceptions().get(0).getClass());
}

@Test
public void testGetStepNotStepState() throws Exception {
  SimpleFlow flow = new SimpleFlow("job");
  List<StateTransition> transitions = new ArrayList<>();
  transitions.add(StateTransition.createStateTransition(new StepState(new StubStep("step1")), "step2"));
  transitions.add(StateTransition.createStateTransition(new StepState(new StubStep("step2")), "end0"));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.COMPLETED, "end0")));
  flow.setStateTransitions(transitions);
  flow.afterPropertiesSet();
  job.setFlow(flow);
  job.afterPropertiesSet();
  Step step = job.getStep("end0");
  assertNull(step);
}

@Test
public void testGetStepNotExists() throws Exception {
  SimpleFlow flow = new SimpleFlow("job");
  List<StateTransition> transitions = new ArrayList<>();
  transitions.add(StateTransition.createStateTransition(new StepState(new StubStep("step1")), "step2"));
  transitions.add(StateTransition.createStateTransition(new StepState(new StubStep("step2")), "end0"));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.COMPLETED, "end0")));
  flow.setStateTransitions(transitions);
  flow.afterPropertiesSet();
  job.setFlow(flow);
  job.afterPropertiesSet();
  Step step = job.getStep("foo");
  assertNull(step);
}

@Test
public void testEndStateStopped() throws Exception {
  SimpleFlow flow = new SimpleFlow("job");
  List<StateTransition> transitions = new ArrayList<>();
  transitions.add(StateTransition.createStateTransition(new StepState(new StubStep("step1")), "end"));
  transitions.add(StateTransition
      .createStateTransition(new EndState(FlowExecutionStatus.STOPPED, "end"), "step2"));
  StepState step2 = new StepState(new StubStep("step2"));
  transitions.add(StateTransition.createStateTransition(step2, ExitStatus.FAILED.getExitCode(), "end0"));
  transitions.add(StateTransition.createStateTransition(step2, ExitStatus.COMPLETED.getExitCode(), "end1"));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.FAILED, "end0")));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.COMPLETED, "end1")));
  flow.setStateTransitions(transitions);
  job.setFlow(flow);
  job.afterPropertiesSet();
  job.doExecute(jobExecution);
  assertEquals(1, jobExecution.getStepExecutions().size());
  assertEquals(BatchStatus.STOPPED, jobExecution.getStatus());
}

@Test
public void testStoppingStep() throws Exception {
  SimpleFlow flow = new SimpleFlow("job");
  List<StateTransition> transitions = new ArrayList<>();
  transitions.add(StateTransition.createStateTransition(new StepState(new StubStep("step1")), "step2"));
  State state2 = new StateSupport("step2", FlowExecutionStatus.FAILED);
  transitions.add(StateTransition.createStateTransition(state2, ExitStatus.FAILED.getExitCode(), "end0"));
  transitions.add(StateTransition.createStateTransition(state2, ExitStatus.COMPLETED.getExitCode(), "end1"));
  transitions.add(StateTransition.createStateTransition(new EndState(FlowExecutionStatus.STOPPED, "end0"),
      "step3"));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.COMPLETED, "end1")));
  transitions.add(StateTransition.createStateTransition(new StepState(new StubStep("step3")), "end2"));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.COMPLETED, "end2")));
  flow.setStateTransitions(transitions);
  job.setFlow(flow);
  job.afterPropertiesSet();
  job.doExecute(jobExecution);
  assertEquals(2, jobExecution.getStepExecutions().size());
  assertEquals(BatchStatus.STOPPED, jobExecution.getStatus());
}

@Test
public void testTwoSteps() throws Exception {
  SimpleFlow flow = new SimpleFlow("job");
  List<StateTransition> transitions = new ArrayList<>();
  transitions.add(StateTransition.createStateTransition(new StepState(new StubStep("step1")), "step2"));
  StepState step2 = new StepState(new StubStep("step2"));
  transitions.add(StateTransition.createStateTransition(step2, ExitStatus.FAILED.getExitCode(), "end0"));
  transitions.add(StateTransition.createStateTransition(step2, ExitStatus.COMPLETED.getExitCode(), "end1"));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.FAILED, "end0")));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.COMPLETED, "end1")));
  flow.setStateTransitions(transitions);
  job.setFlow(flow);
  job.afterPropertiesSet();
  job.doExecute(jobExecution);
  StepExecution stepExecution = getStepExecution(jobExecution, "step2");
  assertEquals(ExitStatus.COMPLETED, stepExecution.getExitStatus());
  assertEquals(2, jobExecution.getStepExecutions().size());
}

@Test
public void testGetStepExists() throws Exception {
  SimpleFlow flow = new SimpleFlow("job");
  List<StateTransition> transitions = new ArrayList<>();
  transitions.add(StateTransition.createStateTransition(new StepState(new StubStep("step1")), "step2"));
  transitions.add(StateTransition.createStateTransition(new StepState(new StubStep("step2")), "end0"));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.COMPLETED, "end0")));
  flow.setStateTransitions(transitions);
  flow.afterPropertiesSet();
  job.setFlow(flow);
  job.afterPropertiesSet();
  Step step = job.getStep("step2");
  assertNotNull(step);
  assertEquals("step2", step.getName());
}

@Test
public void testGetStepExistsWithPrefix() throws Exception {
  SimpleFlow flow = new SimpleFlow("job");
  List<StateTransition> transitions = new ArrayList<>();
  transitions.add(StateTransition.createStateTransition(new StepState("job.step", new StubStep("step")), "end0"));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.COMPLETED, "end0")));
  flow.setStateTransitions(transitions);
  flow.afterPropertiesSet();
  job.setFlow(flow);
  job.setName(flow.getName());
  job.afterPropertiesSet();
  Step step = job.getStep("step");
  assertNotNull(step);
  assertEquals("step", step.getName());
}

public void testEndStateFailed() throws Exception {
  SimpleFlow flow = new SimpleFlow("job");
  List<StateTransition> transitions = new ArrayList<>();
  transitions.add(StateTransition.createStateTransition(new StepState(new StubStep("step1")), "end"));
  transitions
  .add(StateTransition.createStateTransition(new EndState(FlowExecutionStatus.FAILED, "end"), "step2"));
  transitions.add(StateTransition.createStateTransition(new StepState(new StubStep("step2")), ExitStatus.FAILED
      .getExitCode(), "end0"));
  transitions.add(StateTransition.createStateTransition(new StepState(new StubStep("step2")),
      ExitStatus.COMPLETED.getExitCode(), "end1"));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.FAILED, "end0")));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.COMPLETED, "end1")));
  flow.setStateTransitions(transitions);
  job.setFlow(flow);
  job.afterPropertiesSet();
  job.doExecute(jobExecution);
  assertEquals(BatchStatus.FAILED, jobExecution.getStatus());
  assertEquals(1, jobExecution.getStepExecutions().size());
}

@Test
public void testFailedStep() throws Exception {
  SimpleFlow flow = new SimpleFlow("job");
  List<StateTransition> transitions = new ArrayList<>();
  transitions.add(StateTransition.createStateTransition(new StateSupport("step1", FlowExecutionStatus.FAILED),
      "step2"));
  StepState step2 = new StepState(new StubStep("step2"));
  transitions.add(StateTransition.createStateTransition(step2, ExitStatus.FAILED.getExitCode(), "end0"));
  transitions.add(StateTransition.createStateTransition(step2, ExitStatus.COMPLETED.getExitCode(), "end1"));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.FAILED, "end0")));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.COMPLETED, "end1")));
  flow.setStateTransitions(transitions);
  job.setFlow(flow);
  job.afterPropertiesSet();
  job.doExecute(jobExecution);
  StepExecution stepExecution = getStepExecution(jobExecution, "step2");
  assertEquals(ExitStatus.COMPLETED, stepExecution.getExitStatus());
  assertEquals(BatchStatus.COMPLETED, stepExecution.getStatus());
  assertEquals(2, jobExecution.getStepExecutions().size());
}

@Test
public void testFlowStep() throws Exception {
  StepParserStepFactoryBean<Object, Object> fb = new StepParserStepFactoryBean<>();
  fb.setBeanName("step1");
  fb.setAllowStartIfComplete(true);
  fb.setJobRepository(new JobRepositorySupport());
  fb.setStartLimit(5);
  fb.setListeners(new StepListener[] { new StepExecutionListenerSupport() });
  fb.setTaskExecutor(new SyncTaskExecutor());
  fb.setFlow(new SimpleFlow("foo"));
  Object step = fb.getObject();
  assertTrue(step instanceof FlowStep);
  Object handler = ReflectionTestUtils.getField(step, "flow");
  assertTrue(handler instanceof SimpleFlow);
}