public void ParallelState_ChoiceStateWithTerminalPath_IsValid()
{
AssertHasPathToTerminal(
StepFunctionBuilder.StateMachine()
.StartAt("Parallel")
.State("Parallel", StepFunctionBuilder.ParallelState()
.Transition(StepFunctionBuilder.End())
.Branch(StepFunctionBuilder.Branch()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.PassState()
.Transition(StepFunctionBuilder
.Next("Choice")))
.State("Choice", StepFunctionBuilder.ChoiceState()
.DefaultStateName("Default")
.Choice(StepFunctionBuilder.Choice()
.Transition(StepFunctionBuilder
.Next("Initial"))
.Condition(StepFunctionBuilder
.Eq("$.foo",
"bar")))
.Choice(StepFunctionBuilder.Choice()
.Transition(StepFunctionBuilder
.Next("Default"))
.Condition(StepFunctionBuilder
.Eq("$.foo",
"bar"))))
.State("Default",
StepFunctionBuilder
.PassState().Transition(StepFunctionBuilder.End())))));
}
[Fact]//
public void ValidTransitionInPassState_IsValid()
{
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.PassState()
.Transition(StepFunctionBuilder.Next("Terminal")))
.State("Terminal", StepFunctionBuilder.SucceedState())
.Build();
}
public void InvalidTransitionInPassState_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.PassState()
.Transition(StepFunctionBuilder.Next("NoSuchState")))
.Build());
}
public void SimpleStateMachine_WithCycle_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
AssertCycle(StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.PassState()
.Transition(StepFunctionBuilder.Next("Next")))
.State("Next", StepFunctionBuilder.PassState()
.Transition(StepFunctionBuilder.Next("Initial")))));
}
public void SinglePassStateWithObjectResult()
{
StateMachine stateMachine = StepFunctionBuilder.StateMachine()
.StartAt("InitialState")
.State("InitialState", StepFunctionBuilder.PassState()
.Transition(StepFunctionBuilder.End())
.Result(new SimplePojo("value")))
.Build();
AssertStateMachine(stateMachine, "SinglePassStateWithObjectResult.json");
}
public void SinglePassStateWithJsonResult()
{
StateMachine stateMachine = StepFunctionBuilder.StateMachine()
.StartAt("InitialState")
.State("InitialState", StepFunctionBuilder.PassState()
.Comment("Pass through state")
.InputPath("$.input")
.OutputPath("$.output")
.ResultPath("$.result")
.Transition(StepFunctionBuilder.Next("NextState"))
.Result("{\"Foo\": \"Bar\"}"))
.State("NextState", StepFunctionBuilder.SucceedState())
.Build();
AssertStateMachine(stateMachine, "SinglePassStateWithJsonResult.json");
}
public void ParallelState_NoCycles()
{
AssertNoCycle(StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.ParallelState()
.Branch(StepFunctionBuilder.Branch()
.StartAt("BranchOneStart")
.State("BranchOneStart", StepFunctionBuilder.SucceedState()))
.Branch(StepFunctionBuilder.Branch()
.StartAt("BranchTwoStart")
.State("BranchTwoStart", StepFunctionBuilder.PassState()
.Transition(StepFunctionBuilder
.Next("NextState")))
.State("NextState", StepFunctionBuilder.SucceedState()))
.Transition(StepFunctionBuilder.End())));
}
public void ChoiceStateWithClosedCycle_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
AssertCycle(StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.PassState()
.Transition(StepFunctionBuilder.Next("Choice")))
.State("Choice", StepFunctionBuilder.ChoiceState()
.DefaultStateName("Terminal")
.Choice(StepFunctionBuilder.Choice()
.Transition(StepFunctionBuilder.Next("Terminal"))
.Condition(StepFunctionBuilder.Eq("$.foo", "bar")))
.Choice(StepFunctionBuilder.Choice()
.Transition(StepFunctionBuilder.Next("NonTerminal"))
.Condition(StepFunctionBuilder.Eq("$.foo", "bar"))))
.State("Terminal", StepFunctionBuilder.PassState().Transition(StepFunctionBuilder.End()))
.State("NonTerminal",
StepFunctionBuilder.PassState().Transition(StepFunctionBuilder.Next("Cyclic")))
.State("Cyclic",
StepFunctionBuilder.PassState().Transition(StepFunctionBuilder.Next("NonTerminal")))));
}
public void ChoiceStateWithPathOut_IsValid()
{
AssertNoCycle(
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.PassState()
.Transition(StepFunctionBuilder.Next("ChoiceOne")))
.State("ChoiceOne", StepFunctionBuilder.ChoiceState()
.DefaultStateName("DefaultOne")
.Choice(StepFunctionBuilder.Choice()
.Transition(StepFunctionBuilder.Next("ChoiceTwo"))
.Condition(StepFunctionBuilder.Eq("$.foo", "bar"))))
.State("DefaultOne", StepFunctionBuilder.SucceedState())
.State("ChoiceTwo", StepFunctionBuilder.ChoiceState()
.DefaultStateName("DefaultTwo")
.Choice(StepFunctionBuilder.Choice()
.Transition(StepFunctionBuilder.Next("ChoiceOne"))
.Condition(StepFunctionBuilder.Eq("$.foo", "bar"))))
.State("DefaultTwo",
StepFunctionBuilder.PassState().Transition(StepFunctionBuilder.Next("ChoiceTwo"))));
}
public void ParallelState_WithChoiceThatHasNoTerminalPath_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
AssertDoesNotHaveTerminalPath(
StepFunctionBuilder.StateMachine()
.StartAt("Parallel")
.State("Parallel", StepFunctionBuilder.ParallelState()
.Transition(StepFunctionBuilder.End())
.Branch(StepFunctionBuilder.Branch()
.StartAt("Initial")
.State("Initial",
StepFunctionBuilder
.PassState()
.Transition(StepFunctionBuilder
.Next("Choice")))
.State("Choice",
StepFunctionBuilder
.ChoiceState()
.DefaultStateName("Default")
.Choice(StepFunctionBuilder
.Choice()
.Transition(StepFunctionBuilder
.Next("Initial"))
.Condition(StepFunctionBuilder
.Eq("$.foo",
"bar")))
.Choice(StepFunctionBuilder
.Choice()
.Transition(StepFunctionBuilder
.Next("Default"))
.Condition(StepFunctionBuilder
.Eq("$.foo",
"bar"))))
.State("Default",
StepFunctionBuilder
.PassState()
.Transition(StepFunctionBuilder
.Next("Choice")))))));
}
public void ChoiceStateWithOnlyCycles_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
AssertDoesNotHaveTerminalPath(StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.PassState()
.Transition(StepFunctionBuilder.Next("Choice")))
.State("Choice", StepFunctionBuilder.ChoiceState()
.DefaultStateName("Default")
.Choice(StepFunctionBuilder.Choice()
.Transition(StepFunctionBuilder
.Next("Initial"))
.Condition(StepFunctionBuilder
.Eq("$.foo",
"bar")))
.Choice(StepFunctionBuilder.Choice()
.Transition(StepFunctionBuilder
.Next("Default"))
.Condition(StepFunctionBuilder
.Eq("$.foo",
"bar"))))
.State("Default",
StepFunctionBuilder.PassState().Transition(StepFunctionBuilder.Next("Choice")))));
}
private PassState.Builder NewPassState()
{
return(StepFunctionBuilder.PassState().Transition(StepFunctionBuilder.End()));
}
public void ParallelState_WithCycles_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
AssertCycle(StepFunctionBuilder.StateMachine()
.StartAt("Parallel")
.State("Parallel", StepFunctionBuilder.ParallelState()
.Branch(StepFunctionBuilder.Branch()
.StartAt("BranchOneInitial")
.State("BranchOneInitial", StepFunctionBuilder
.PassState()
.Transition(StepFunctionBuilder
.Next("CyclicState")))
.State("CyclicState", StepFunctionBuilder
.PassState()
.Transition(StepFunctionBuilder
.Next("BranchOneInitial"))))
.Transition(StepFunctionBuilder.End()))));
}
