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