How to use

createStateTransition

method

in

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

/**
 * Create a new end state {@link StateTransition} specification. This
 * transition explicitly goes unconditionally to an end state (i.e. no more
 * executions).
 *
 * @param state the {@link State} used to generate the outcome for this
 * transition
 * @return {@link StateTransition} that was created.
 */
public static StateTransition createEndStateTransition(State state) {
  return createStateTransition(state, null, null);
}

/**
 * Create a new state {@link StateTransition} specification with a wildcard
 * pattern that matches all outcomes.
 *
 * @param state the {@link State} used to generate the outcome for this
 * transition
 * @param next the name of the next {@link State} to execute
 * @return {@link StateTransition} that was created.
 */
public static StateTransition createStateTransition(State state, String next) {
  return createStateTransition(state, null, next);
}

private void addTransition(String pattern, State next) {
  tos.put(next.getName(), next);
  transitions.add(StateTransition.createStateTransition(currentState, pattern, next.getName()));
  if (transitions.size() == 1) {
    transitions.add(StateTransition.createEndStateTransition(failedState));
    transitions.add(StateTransition.createEndStateTransition(completedState));
    transitions.add(StateTransition.createEndStateTransition(stoppedState));
  }
  if (next.isEndState()) {
    transitions.add(StateTransition.createEndStateTransition(next));
  }
  dirty = true;
}

@Test
public void testSubstringAndWildcard() {
  StateTransition transition = StateTransition.createStateTransition(state, "CONTIN*", "start");
  StateTransition other = StateTransition.createStateTransition(state, "CONTINUABLE", "start");
  assertEquals(1, comparator.compare(transition, other));
  assertEquals(-1, comparator.compare(other, transition));
}

@Test
public void testSimpleOrderingMostGeneral() {
  StateTransition transition = StateTransition.createStateTransition(state, "*", "start");
  StateTransition other = StateTransition.createStateTransition(state, "CONTINUABLE", "start");
  assertEquals(1, comparator.compare(transition, other));
  assertEquals(-1, comparator.compare(other, transition));
}

  @Test
  public void testSimpleOrderingAdjacent() {
    StateTransition transition = StateTransition.createStateTransition(state, "CON*", "start");
    StateTransition other = StateTransition.createStateTransition(state, "CON?", "start");
    assertEquals(1, comparator.compare(transition, other));
    assertEquals(-1, comparator.compare(other, transition));
  }
}

@Test
public void testSimpleOrderingEqual() {
  StateTransition transition = StateTransition.createStateTransition(state, "CONTIN???LE", "start");
  assertEquals(0, comparator.compare(transition, transition));
}

@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 testToString() {
  StateTransition transition = StateTransition.createStateTransition(state, "CONTIN???LE", "start");
  String string = transition.toString();
  assertTrue("Wrong string: " + string, string.contains("Transition"));
  assertTrue("Wrong string: " + string, string.contains("start"));
  assertTrue("Wrong string: " + string, string.contains("CONTIN???LE"));
  assertTrue("Wrong string: " + string, string.contains("next="));
}

@Test
public void testMatchesStar() {
  StateTransition transition = StateTransition.createStateTransition(state, "*", "start");
  assertTrue(transition.matches("CONTINUABLE"));
}

@Test
public void testMatchesNull() {
  StateTransition transition = StateTransition.createStateTransition(state, null, "start");
  assertTrue(transition.matches("CONTINUABLE"));
}

@Test
public void testMatchesExact() {
  StateTransition transition = StateTransition.createStateTransition(state, "CONTINUABLE", "start");
  assertTrue(transition.matches("CONTINUABLE"));
}

@Test
public void testMatchesPlaceholder() {
  StateTransition transition = StateTransition.createStateTransition(state, "CONTIN???LE", "start");
  assertTrue(transition.matches("CONTINUABLE"));
}

@Test(expected = IllegalArgumentException.class)
public void testNoNextStepSpecified() throws Exception {
  flow.setStateTransitions(Collections.singletonList(StateTransition.createStateTransition(new StateSupport(
      "step"), "foo")));
  flow.afterPropertiesSet();
}

@Test
public void testMatchesEmpty() {
  StateTransition transition = StateTransition.createStateTransition(state, "", "start");
  assertTrue(transition.matches("CONTINUABLE"));
}

@Test(expected = IllegalArgumentException.class)
public void testNoEndStep() throws Exception {
  flow.setStateTransitions(Collections.singletonList(StateTransition.createStateTransition(new StateSupport(
      "step"), ExitStatus.FAILED.getExitCode(), "step")));
  flow.afterPropertiesSet();
}

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

@Test
public void testFailedStep() throws Exception {
  flow.setStateTransitions(collect(StateTransition.createStateTransition(new StubState("step1") {
    @Override
    public FlowExecutionStatus handle(FlowExecutor executor) {
      return FlowExecutionStatus.FAILED;
    }
  }, "step2"), StateTransition.createEndStateTransition(new StubState("step2"))));
  flow.afterPropertiesSet();
  FlowExecution execution = flow.start(executor);
  assertEquals(FlowExecutionStatus.COMPLETED, execution.getStatus());
  assertEquals("step2", execution.getName());
}

@Test
public void testStepLoop() throws Exception {
  flow.setStateTransitions(collect(StateTransition.createStateTransition(new StateSupport("step"),
      ExitStatus.FAILED.getExitCode(), "step"), StateTransition.createEndStateTransition(new StateSupport("step"))));
  flow.afterPropertiesSet();
  FlowExecution execution = flow.start(executor);
  assertEquals(FlowExecutionStatus.COMPLETED, execution.getStatus());
  assertEquals("step", execution.getName());
}

@Test
public void testExplicitStartStep() throws Exception {
  flow.setStateTransitions(collect(StateTransition.createStateTransition(new StubState("step"),
      ExitStatus.FAILED.getExitCode(), "step"), StateTransition.createEndStateTransition(new StubState("step"))));
  flow.afterPropertiesSet();
  FlowExecution execution = flow.start(executor);
  assertEquals(FlowExecutionStatus.COMPLETED, execution.getStatus());
  assertEquals("step", execution.getName());
}