public void TestEqOperator()
{
var c = StepFunctionBuilder.ChoiceState()
.Choice(StepFunctionBuilder.Choice()
.Transition(StepFunctionBuilder.Next("NextState"))
.Condition(StepFunctionBuilder.Eq("$.varstr", "value")))
.Choice(StepFunctionBuilder.Choice()
.Transition(StepFunctionBuilder.Next("NextState"))
.Condition(StepFunctionBuilder.Eq("$.varint", 33)))
.Choice(StepFunctionBuilder.Choice()
.Transition(StepFunctionBuilder.Next("NextState"))
.Condition(StepFunctionBuilder.Eq("$.vardate", new DateTime(2018, 10, 22, 22, 33, 11))))
.Choice(StepFunctionBuilder.Choice()
.Transition(StepFunctionBuilder.Next("NextState"))
.Condition(StepFunctionBuilder.Eq("$.varbool", true)))
.Build();
var choices = c.Choices.ToArray();
Assert.True(choices[0].Condition.Match(JObject.FromObject(new { varstr = "value" })));
Assert.False(choices[0].Condition.Match(JObject.FromObject(new { varstr = "notValue" })));
Assert.True(choices[1].Condition.Match(JObject.FromObject(new { varint = 33 })));
Assert.False(choices[1].Condition.Match(JObject.FromObject(new { varint = 34 })));
Assert.True(choices[2].Condition.Match(JObject.FromObject(new { vardate = new DateTime(2018, 10, 22, 22, 33, 11) })));
Assert.False(choices[2].Condition.Match(JObject.FromObject(new { vardate = new DateTime(2018, 10, 22, 22, 33, 12) })));
Assert.True(choices[3].Condition.Match(JObject.FromObject(new { varbool = true })));
Assert.False(choices[3].Condition.Match(JObject.FromObject(new { varbool = false })));
}
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())))));
}
public void TestNotOperator()
{
var c = StepFunctionBuilder.ChoiceState()
.Choice(StepFunctionBuilder.Choice()
.Transition(StepFunctionBuilder.Next("NextState"))
.Condition(StepFunctionBuilder.Not(StepFunctionBuilder.Eq("$.varstr", "value"))))
.Build();
var choices = c.Choices.ToArray();
Assert.False(choices[0].Condition.Match(JObject.FromObject(new { varstr = "value" }))); //Equal
}
public void MissingExpectedValue_StringEqualsCondition_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.ChoiceState()
.Choice(StepFunctionBuilder.Choice()
.Condition(StepFunctionBuilder.Eq("$.Foo", null))
.Transition(StepFunctionBuilder.Next("Terminal")))
.DefaultStateName("Terminal"))
.State("Terminal", StepFunctionBuilder.SucceedState())
.Build());
}
public void ChoiceStateWithInvalidChoiceTransition_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.ChoiceState()
.Choice(StepFunctionBuilder.Choice()
.Condition(StepFunctionBuilder.Eq("$.Foo", "bar"))
.Transition(StepFunctionBuilder.Next("NoSuchState")))
.DefaultStateName("Terminal"))
.State("Terminal", StepFunctionBuilder.SucceedState())
.Build());
}
public void ChoiceStateWithAndCondition()
{
StateMachine stateMachine = StepFunctionBuilder.StateMachine()
.StartAt("InitialState")
.State("InitialState", StepFunctionBuilder.ChoiceState()
.DefaultStateName("DefaultState")
.Choice(StepFunctionBuilder.Choice().Transition(StepFunctionBuilder.Next("NextState"))
.Condition(
StepFunctionBuilder.And(StepFunctionBuilder.Eq("$.var", "value"),
StepFunctionBuilder.Eq("$.other-var", 10)
))))
.State("NextState", StepFunctionBuilder.SucceedState())
.State("DefaultState", StepFunctionBuilder.SucceedState())
.Build();
AssertStateMachine(stateMachine, "ChoiceStateWithAndCondition.json");
}
public void SimpleChoiceState()
{
StateMachine stateMachine = StepFunctionBuilder.StateMachine()
.StartAt("InitialState")
.State("InitialState", StepFunctionBuilder.ChoiceState()
.Comment("My choice state")
.DefaultStateName("DefaultState")
.InputPath("$.input")
.OutputPath("$.output")
.Choice(StepFunctionBuilder.Choice().Transition(StepFunctionBuilder.Next("NextState"))
.Condition(StepFunctionBuilder.Eq("$.var", "value"))))
.State("NextState", StepFunctionBuilder.SucceedState())
.State("DefaultState", StepFunctionBuilder.SucceedState())
.Build();
AssertStateMachine(stateMachine, "SimpleChoiceState.json");
}
public void TestOrOperator()
{
var c = StepFunctionBuilder.ChoiceState()
.Choice(StepFunctionBuilder.Choice()
.Transition(StepFunctionBuilder.Next("NextState"))
.Condition(StepFunctionBuilder.Or(StepFunctionBuilder.Eq("$.varstr", "value"),
StepFunctionBuilder.Eq("$.varbool", false)))
)
.Build();
var choices = c.Choices.ToArray();
Assert.True(choices[0].Condition.Match(JObject.FromObject(new { varstr = "value", varbool = false })));
Assert.True(choices[0].Condition.Match(JObject.FromObject(new { varstr = "valuee", varbool = false })));
Assert.True(choices[0].Condition.Match(JObject.FromObject(new { varstr = "value", varbool = true })));
Assert.False(choices[0].Condition.Match(JObject.FromObject(new { varstr = "valuee", varbool = true })));
}
public void ChoiceStateWithMultipleChoices()
{
StateMachine stateMachine = StepFunctionBuilder.StateMachine()
.StartAt("InitialState")
.State("InitialState", StepFunctionBuilder.ChoiceState()
.DefaultStateName("DefaultState")
.Choices(
StepFunctionBuilder.Choice().Transition(StepFunctionBuilder.Next("NextState"))
.Condition(StepFunctionBuilder.Eq("$.var", "value")),
StepFunctionBuilder.Choice().Transition(StepFunctionBuilder.Next("OtherNextState"))
.Condition(StepFunctionBuilder.Gt("$.number", 10))))
.State("NextState", StepFunctionBuilder.SucceedState())
.State("OtherNextState", StepFunctionBuilder.SucceedState())
.State("DefaultState", StepFunctionBuilder.SucceedState())
.Build();
AssertStateMachine(stateMachine, "ChoiceStateWithMultipleChoices.json");
}
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 TestBadFormat()
{
var dt = new DateTime(2018, 10, 22, 22, 33, 11);
var c = StepFunctionBuilder.ChoiceState()
.Choice(StepFunctionBuilder.Choice()
.Transition(StepFunctionBuilder.Next("NextState"))
.Condition(StepFunctionBuilder.Or(StepFunctionBuilder.Eq("$.varint", 33),
StepFunctionBuilder.Gt("$.varint", 33),
StepFunctionBuilder.Gte("$.varint", 33),
StepFunctionBuilder.Lt("$.varint", 33),
StepFunctionBuilder.Lte("$.varint", 33))))
.Choice(StepFunctionBuilder.Choice()
.Transition(StepFunctionBuilder.Next("NextState"))
.Condition(StepFunctionBuilder.Or(StepFunctionBuilder.Eq("$.vardate", dt),
StepFunctionBuilder.Gt("$.vardate", dt),
StepFunctionBuilder.Gte("$.vardate", dt),
StepFunctionBuilder.Lt("$.vardate", dt),
StepFunctionBuilder.Lte("$.vardate", dt))))
.Choice(StepFunctionBuilder.Choice()
.Transition(StepFunctionBuilder.Next("NextState"))
.Condition(StepFunctionBuilder.Eq("$.varbool", true)))
.Build();
var choices = c.Choices.ToArray();
//Unknown prop
Assert.False(choices[0].Condition.Match(JObject.FromObject(new { other = "value" })));
Assert.False(choices[1].Condition.Match(JObject.FromObject(new { other = "value" })));
Assert.False(choices[2].Condition.Match(JObject.FromObject(new { other = "value" })));
//Assert.False(choices[0].Condition.Match(JObject.FromObject(new { varstr = "1000" })));
//string instead of correct type
Assert.False(choices[0].Condition.Match(JObject.FromObject(new { varint = "hello" })));
Assert.False(choices[1].Condition.Match(JObject.FromObject(new { vardate = "hello" })));
Assert.False(choices[2].Condition.Match(JObject.FromObject(new { varbool = "hello" })));
//Invalid date
Assert.False(choices[1].Condition.Match(JObject.FromObject(new { varbool = "2016-14-14T01:59:00Z" })));
}
public void ParallelState_BranchContainsChoiceStateWithClosedCycle_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 ChoiceStateWithAllPrimitiveConditions()
{
DateTime date = DateTime.Parse("2016-03-14T01:59:00.000Z").ToUniversalTime();
StateMachine stateMachine = StepFunctionBuilder.StateMachine()
.StartAt("InitialState")
.State("InitialState", StepFunctionBuilder.ChoiceState()
.DefaultStateName("DefaultState")
.Choice(StepFunctionBuilder.Choice().Transition(StepFunctionBuilder.Next("NextState"))
.Condition(StepFunctionBuilder.And(
StepFunctionBuilder.Eq("$.string", "value"),
StepFunctionBuilder.Gt("$.string", "value"),
StepFunctionBuilder.Gte("$.string", "value"),
StepFunctionBuilder.Lt("$.string", "value"),
StepFunctionBuilder.Lte("$.string", "value"),
StepFunctionBuilder.Eq("$.integral", 42),
StepFunctionBuilder.Gt("$.integral", 42),
StepFunctionBuilder.Gte("$.integral", 42),
StepFunctionBuilder.Lt("$.integral", 42),
StepFunctionBuilder.Lte("$.integral", 42),
StepFunctionBuilder.Eq("$.double", 9000.1),
StepFunctionBuilder.Gt("$.double", 9000.1),
StepFunctionBuilder.Gte("$.double", 9000.1),
StepFunctionBuilder.Lt("$.double", 9000.1),
StepFunctionBuilder.Lte("$.double", 9000.1),
StepFunctionBuilder.Eq("$.timestamp", date),
StepFunctionBuilder.Gt("$.timestamp", date),
StepFunctionBuilder.Gte("$.timestamp", date),
StepFunctionBuilder.Lt("$.timestamp", date),
StepFunctionBuilder.Lte("$.timestamp", date),
StepFunctionBuilder.Eq("$.boolean", true),
StepFunctionBuilder.Eq("$.boolean", false)
))))
.State("NextState", StepFunctionBuilder.SucceedState())
.State("DefaultState", StepFunctionBuilder.SucceedState())
.Build();
AssertStateMachine(stateMachine, "ChoiceStateWithAllPrimitiveCondition.json");
}
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")))));
}
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")))))));
}
