How to use

SimpleFlow

in

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

@Test
public void testGetStepSplitFlow() throws Exception {
  SimpleFlow flow = new SimpleFlow("job");
  SimpleFlow flow1 = new SimpleFlow("flow1");
  SimpleFlow flow2 = new SimpleFlow("flow2");
  List<StateTransition> transitions = new ArrayList<>();
  transitions.add(StateTransition.createStateTransition(new StepState(new StubStep("step1")), "end0"));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.COMPLETED, "end0")));
  flow1.setStateTransitions(new ArrayList<>(transitions));
  flow1.afterPropertiesSet();
  transitions = new ArrayList<>();
  transitions.add(StateTransition.createStateTransition(new StepState(new StubStep("step2")), "end1"));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.COMPLETED, "end1")));
  flow2.setStateTransitions(new ArrayList<>(transitions));
  flow2.afterPropertiesSet();
  transitions = new ArrayList<>();
  transitions.add(StateTransition.createStateTransition(new SplitState(Arrays.<Flow> asList(flow1, flow2),
      "split"), "end2"));
  transitions.add(StateTransition.createEndStateTransition(new EndState(FlowExecutionStatus.COMPLETED, "end2")));
  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 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 testResume() throws Exception {
  flow.setStateTransitions(collect(StateTransition.createStateTransition(new StubState("step1"), "step2"),
      StateTransition.createEndStateTransition(new StubState("step2"))));
  flow.afterPropertiesSet();
  FlowExecution execution = flow.resume("step2", executor);
  assertEquals(FlowExecutionStatus.COMPLETED, execution.getStatus());
  assertEquals("step2", execution.getName());
}

/**
 * @see Flow#start(FlowExecutor)
 */
@Override
public FlowExecution start(FlowExecutor executor) throws FlowExecutionException {
  if (startState == null) {
    initializeTransitions();
  }
  State state = startState;
  String stateName = state.getName();
  return resume(stateName, executor);
}

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;
}

@Override
public SimpleFlow getObject() throws Exception {
  SimpleFlow flow = flowType.getConstructor(String.class).newInstance(name);
  flow.setStateTransitionComparator(stateTransitionComparator);
  List<StateTransition> updatedTransitions = new ArrayList<>();
  for (StateTransition stateTransition : stateTransitions) {
    State state = getProxyState(stateTransition.getState());
    updatedTransitions.add(StateTransition.switchOriginAndDestination(stateTransition, state,
        getNext(stateTransition.getNext())));
  }
  flow.setStateTransitions(updatedTransitions);
  flow.afterPropertiesSet();
  return flow;
}

@Test(expected = IllegalArgumentException.class)
public void testEmptySteps() throws Exception {
  flow.setStateTransitions(Collections.<StateTransition> emptyList());
  flow.afterPropertiesSet();
}

@Test
public void testOneStep() throws Exception {
  flow.setStateTransitions(Collections.singletonList(StateTransition.createEndStateTransition(new StubState(
      "step1"))));
  flow.afterPropertiesSet();
  FlowExecution execution = flow.start(executor);
  assertEquals(FlowExecutionStatus.COMPLETED, execution.getStatus());
  assertEquals("step1", execution.getName());
}

@Test
public void testGetStepNamesWithPrefix() throws Exception {
  SimpleFlow flow = new JsrFlow("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 testBranching() throws Exception {
  flow.setStateTransitions(collect(StateTransition.createStateTransition(new StubState("step1"), "step2"),
      StateTransition.createStateTransition(new StubState("step1"), ExitStatus.COMPLETED.getExitCode(), "step3"),
      StateTransition.createEndStateTransition(new StubState("step2")), StateTransition
      .createEndStateTransition(new StubState("step3"))));
  flow.setStateTransitionComparator(new DefaultStateTransitionComparator());
  flow.afterPropertiesSet();
  FlowExecution execution = flow.start(executor);
  assertEquals(FlowExecutionStatus.COMPLETED, execution.getStatus());
  assertEquals("step3", execution.getName());
}

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

@Test
public void testGetStateDoesNotExist() throws Exception {
  flow.setStateTransitions(Collections.singletonList(StateTransition.createEndStateTransition(new StubState(
      "step1"))));
  flow.afterPropertiesSet();
  State state = flow.getState("bar");
  assertNull(state);
}

while (isFlowContinued(state, status, stepExecution)) {
  stateName = state.getName();
  state = nextState(stateName, status, stepExecution);

@Test
public void testBasicFlow() throws Throwable {
  SimpleFlow flow = new JsrFlow("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());
}

throw new FlowExecutionException(String.format("No transitions found in flow=%s for state=%s", getName(),
                           stateName));
throw new FlowExecutionException(String.format("Next state not found in flow=%s for state=%s with exit status=%s", getName(), stateName, status.getName()));
                           getName(), next));

/**
 * Locate start state and pre-populate data structures needed for execution.
 *
 * @see InitializingBean#afterPropertiesSet()
 */
@Override
public void afterPropertiesSet() throws Exception {
  if (startState == null) {
    initializeTransitions();
  }
}

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

@Override
protected boolean isFlowContinued(State state, FlowExecutionStatus status, StepExecution stepExecution) {
  if(state instanceof DelegateState) {
    state = ((DelegateState) state).getState();
  }
  if(state instanceof JsrStepState) {
    currentStep = (JsrStepState) state;
  }
  return super.isFlowContinued(state, status, stepExecution);
}

state = nextState(stateName, status);

@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;
}