public void SimpleParallelState()
{
StateMachine stateMachine = StepFunctionBuilder.StateMachine()
.StartAt("InitialState")
.State("InitialState", StepFunctionBuilder.ParallelState()
.Comment("My parallel state")
.InputPath("$.input")
.OutputPath("$.output")
.ResultPath("$.result")
.Transition(StepFunctionBuilder.Next("NextState"))
.Branches(
StepFunctionBuilder.Branch()
.Comment("Branch one")
.StartAt("BranchOneInitial")
.State("BranchOneInitial", StepFunctionBuilder.SucceedState()),
StepFunctionBuilder.Branch()
.Comment("Branch two")
.StartAt("BranchTwoInitial")
.State("BranchTwoInitial", StepFunctionBuilder.SucceedState())
))
.State("NextState", StepFunctionBuilder.SucceedState())
.Build();
AssertStateMachine(stateMachine, "SimpleParallelState.json");
}
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 TestGteOperator()
{
var c = StepFunctionBuilder.ChoiceState()
.Choice(StepFunctionBuilder.Choice()
.Transition(StepFunctionBuilder.Next("NextState"))
.Condition(StepFunctionBuilder.Gte("$.varstr", "value")))
.Choice(StepFunctionBuilder.Choice()
.Transition(StepFunctionBuilder.Next("NextState"))
.Condition(StepFunctionBuilder.Gte("$.varint", 33)))
.Choice(StepFunctionBuilder.Choice()
.Transition(StepFunctionBuilder.Next("NextState"))
.Condition(StepFunctionBuilder.Gte("$.vardate", new DateTime(2018, 10, 22, 22, 33, 11))))
.Build();
var choices = c.Choices.ToArray();
Assert.True(choices[0].Condition.Match(JObject.FromObject(new { varstr = "vvalue" })));
Assert.False(choices[0].Condition.Match(JObject.FromObject(new { varstr = "notValue" })));
Assert.True(choices[0].Condition.Match(JObject.FromObject(new { varstr = "value" }))); //Equal
Assert.True(choices[1].Condition.Match(JObject.FromObject(new { varint = 34 })));
Assert.False(choices[1].Condition.Match(JObject.FromObject(new { varint = 30 })));
Assert.True(choices[1].Condition.Match(JObject.FromObject(new { varint = 33 }))); //Equal
Assert.True(choices[2].Condition.Match(JObject.FromObject(new { vardate = new DateTime(2018, 10, 22, 22, 33, 20) })));
Assert.False(choices[2].Condition.Match(JObject.FromObject(new { vardate = new DateTime(2018, 10, 22, 22, 33, 10) })));
Assert.True(choices[2].Condition.Match(JObject.FromObject(new { vardate = new DateTime(2018, 10, 22, 22, 33, 11) })));//Equal
}
public void ParallelStateWithCatchers()
{
StateMachine stateMachine = StepFunctionBuilder.StateMachine()
.StartAt("InitialState")
.State("InitialState", StepFunctionBuilder.ParallelState()
.Transition(StepFunctionBuilder.End())
.Branches(
StepFunctionBuilder.Branch()
.Comment("Branch one")
.StartAt("BranchOneInitial")
.State("BranchOneInitial", StepFunctionBuilder.SucceedState()),
StepFunctionBuilder.Branch()
.Comment("Branch two")
.StartAt("BranchTwoInitial")
.State("BranchTwoInitial", StepFunctionBuilder.SucceedState())
)
.Catchers(StepFunctionBuilder.Catcher()
.ErrorEquals("Foo", "Bar")
.Transition(StepFunctionBuilder.Next("RecoveryState"))
.ResultPath("$.result"),
StepFunctionBuilder.Catcher()
.CatchAll()
.Transition(StepFunctionBuilder.Next("OtherRecoveryState"))
.ResultPath("$.result")
))
.State("RecoveryState", StepFunctionBuilder.SucceedState())
.State("OtherRecoveryState", StepFunctionBuilder.SucceedState())
.Build();
AssertStateMachine(stateMachine, "ParallelStateWithCatchers.json");
}
[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 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 ParallelStateWithInvalidTransition_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.ParallelState()
.Branch(StepFunctionBuilder.Branch()
.StartAt("InitialBranchState")
.State("InitialBranchState", StepFunctionBuilder.SucceedState()))
.Transition(StepFunctionBuilder.Next("NoSuchState")))
.Build());
}
public void CatcherInTaskState_InvalidTransition_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.TaskState()
.Transition(StepFunctionBuilder.End())
.Catcher(StepFunctionBuilder.Catcher()
.Transition(StepFunctionBuilder.Next("NoSuchState"))
.CatchAll())
.Resource("arn"))
.Build());
}
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 NoConditionSetForNot_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.ChoiceState()
.Choice(StepFunctionBuilder.Choice()
.Condition(NotCondition.GetBuilder())
.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());
}
[Fact]//
public void CatcherInTaskState_ValidTransition_IsValid()
{
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.TaskState()
.Transition(StepFunctionBuilder.End())
.Catcher(StepFunctionBuilder.Catcher()
.Transition(StepFunctionBuilder.Next("Terminal"))
.CatchAll())
.Resource("arn"))
.State("Terminal", StepFunctionBuilder.SucceedState())
.Build();
}
public void CatcherInTaskState_CatchAllHasOtherErrorCodes_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.TaskState()
.Transition(StepFunctionBuilder.End())
.Catcher(StepFunctionBuilder.Catcher()
.Transition(StepFunctionBuilder.Next("Terminal"))
.ErrorEquals("Foo", "Bar", ErrorCodes.ALL))
.Resource("arn"))
.State("Terminal", StepFunctionBuilder.SucceedState())
.Build());
}
public void SingleWaitState_WaitForSeconds()
{
StateMachine stateMachine = StepFunctionBuilder.StateMachine()
.StartAt("InitialState")
.State("InitialState", StepFunctionBuilder.WaitState()
.Comment("My wait state")
.InputPath("$.input")
.OutputPath("$.output")
.WaitFor(StepFunctionBuilder.Seconds(10))
.Transition(StepFunctionBuilder.Next("NextState")))
.State("NextState", StepFunctionBuilder.SucceedState())
.Build();
AssertStateMachine(stateMachine, "SingleWaitStateWithSeconds.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 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 SingleTaskState()
{
StateMachine stateMachine = StepFunctionBuilder.StateMachine()
.StartAt("InitialState")
.State("InitialState", StepFunctionBuilder.TaskState()
.Comment("Initial State")
.TimeoutSeconds(10)
.HeartbeatSeconds(1)
.Transition(StepFunctionBuilder.Next("NextState"))
.Resource("resource-arn")
.InputPath("$.input")
.ResultPath("$.result")
.OutputPath("$.output"))
.State("NextState", StepFunctionBuilder.SucceedState())
.Build();
AssertStateMachine(stateMachine, "SimpleTaskState.json");
}
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 SingleTaskStateWithCatchers()
{
StateMachine stateMachine = StepFunctionBuilder.StateMachine()
.StartAt("InitialState")
.State("InitialState", StepFunctionBuilder.TaskState()
.Transition(StepFunctionBuilder.Next("NextState"))
.Resource("resource-arn")
.Catchers(StepFunctionBuilder.Catcher()
.ErrorEquals("Foo", "Bar")
.Transition(StepFunctionBuilder.Next("RecoveryState"))
.ResultPath("$.result-path"),
StepFunctionBuilder.Catcher()
.CatchAll()
.Transition(StepFunctionBuilder.Next("OtherRecoveryState"))))
.State("NextState", StepFunctionBuilder.SucceedState())
.State("RecoveryState", StepFunctionBuilder.SucceedState())
.State("OtherRecoveryState", StepFunctionBuilder.SucceedState())
.Build();
AssertStateMachine(stateMachine, "SimpleTaskStateWithCatchers.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 SingleTaskStateWithRetries()
{
StateMachine stateMachine = StepFunctionBuilder.StateMachine()
.StartAt("InitialState")
.State("InitialState", StepFunctionBuilder.TaskState()
.Transition(StepFunctionBuilder.Next("NextState"))
.Resource("resource-arn")
.Retriers(StepFunctionBuilder.Retrier()
.ErrorEquals("Foo", "Bar")
.IntervalSeconds(20)
.MaxAttempts(3)
.BackoffRate(2.0),
StepFunctionBuilder.Retrier()
.RetryOnAllErrors()
.IntervalSeconds(30)
.MaxAttempts(10)
.BackoffRate(2.0)))
.State("NextState", StepFunctionBuilder.SucceedState())
.Build();
AssertStateMachine(stateMachine, "SimpleTaskStateWithRetries.json");
}
public void ChoiceStateWithNotCondition()
{
StateMachine stateMachine = StepFunctionBuilder.StateMachine()
.StartAt("InitialState")
.State("InitialState", StepFunctionBuilder.ChoiceState()
.DefaultStateName("DefaultState")
.Choice(StepFunctionBuilder.Choice().Transition(StepFunctionBuilder.Next("NextState"))
.Condition(StepFunctionBuilder.Not(StepFunctionBuilder.Gte("$.var", "value")))))
.State("NextState", StepFunctionBuilder.SucceedState())
.State("DefaultState", StepFunctionBuilder.SucceedState())
.Build();
AssertStateMachine(stateMachine, "ChoiceStateWithNotCondition.json");
}
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 ChoiceStateWithoutDefaultState()
{
StateMachine stateMachine = StepFunctionBuilder.StateMachine()
.StartAt("InitialState")
.State("InitialState", StepFunctionBuilder.ChoiceState()
.Choice(StepFunctionBuilder.Choice().Transition(StepFunctionBuilder.Next("NextState"))
.Condition(
StepFunctionBuilder.Or(StepFunctionBuilder.Gt("$.var", "value"),
StepFunctionBuilder.Lte("$.other-var", 10)
))))
.State("NextState", StepFunctionBuilder.SucceedState())
.State("DefaultState", StepFunctionBuilder.SucceedState())
.Build();
AssertStateMachine(stateMachine, "ChoiceStateWithoutDefault.json");
}
public void ChoiceStateWithComplexCondition()
{
StateMachine stateMachine = StepFunctionBuilder.StateMachine()
.StartAt("InitialState")
.State("InitialState", StepFunctionBuilder.ChoiceState()
.DefaultStateName("DefaultState")
.Choice(StepFunctionBuilder.Choice().Transition(StepFunctionBuilder.Next("NextState"))
.Condition(StepFunctionBuilder.And(
StepFunctionBuilder.Gte("$.var", "value"),
StepFunctionBuilder.Lte("$.other-var", "foo"),
StepFunctionBuilder.Or(
StepFunctionBuilder.Lt("$.numeric", 9000.1),
StepFunctionBuilder.Not(StepFunctionBuilder.Gte("$.numeric", 42))
)
))))
.State("NextState", StepFunctionBuilder.SucceedState())
.State("DefaultState", StepFunctionBuilder.SucceedState())
.Build();
AssertStateMachine(stateMachine, "ChoiceStateWithComplexCondition.json");
}
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");
}
