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 ValidMinimalStateMachine_IsValid()
{
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.SucceedState())
.Build();
}
public void ParallelStateWithRetriers()
{
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())
)
.Retriers(StepFunctionBuilder.Retrier()
.ErrorEquals("Foo", "Bar")
.IntervalSeconds(10)
.BackoffRate(1.0)
.MaxAttempts(3),
StepFunctionBuilder.Retrier()
.RetryOnAllErrors()
.IntervalSeconds(10)
.BackoffRate(1.0)
.MaxAttempts(3)
))
.Build();
AssertStateMachine(stateMachine, "ParallelStateWithRetriers.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 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 StartAtStateDoesNotExist_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
StepFunctionBuilder.StateMachine()
.StartAt("Foo")
.State("Initial", StepFunctionBuilder.SucceedState())
.Build());
}
[Fact]//
public void MissingErrorInFailState_IsValid()
{
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.FailState()
.Cause("Cause"))
.Build();
}
public void NoWaitForSupplied_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.WaitState()
.Transition(StepFunctionBuilder.End()))
.Build());
}
public void InvalidTransitionInPassState_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.PassState()
.Transition(StepFunctionBuilder.Next("NoSuchState")))
.Build());
}
[Fact]//
public void ValidTransitionInPassState_IsValid()
{
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.PassState()
.Transition(StepFunctionBuilder.Next("Terminal")))
.State("Terminal", StepFunctionBuilder.SucceedState())
.Build();
}
public void MissingCauseInFailState_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.FailState()
.Error("Error"))
.Build());
}
[Fact]//
public void FailStateWithErrorAndCause_IsValid()
{
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.FailState()
.Error("Error")
.Cause("Cause"))
.Build();
}
public void ParallelStateWithNoBranches_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.ParallelState()
.Transition(StepFunctionBuilder.End()))
.Build());
}
public void MissingTransitionInTaskState_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.TaskState()
.Resource("arn"))
.Build());
}
public void WaitForSecondsPath_MissingPath_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.WaitState()
.WaitFor(StepFunctionBuilder.SecondsPath(null))
.Transition(StepFunctionBuilder.End()))
.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 WaitForSecondsPath_InvalidReferencePath_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.WaitState()
.WaitFor(StepFunctionBuilder.SecondsPath("$.Foo[*]"))
.Transition(StepFunctionBuilder.End()))
.Build());
}
public void WaitForTimestampPath_InvalidJsonPath_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.WaitState()
.WaitFor(StepFunctionBuilder.TimestampPath("$."))
.Transition(StepFunctionBuilder.End()))
.Build());
}
public void ChoiceStateWithNoChoices_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.ChoiceState()
.DefaultStateName("Terminal"))
.State("Terminal", StepFunctionBuilder.SucceedState())
.Build());
}
public void NegativeTimeoutSecondsInTaskState_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.TaskState()
.Transition(StepFunctionBuilder.End())
.TimeoutSeconds(-1)
.Resource("arn"))
.Build());
}
public void TaskStateWithEnd()
{
StateMachine stateMachine = StepFunctionBuilder.StateMachine()
.StartAt("InitialState")
.State("InitialState", StepFunctionBuilder.TaskState()
.Resource("resource-arn")
.Transition(StepFunctionBuilder.End()))
.Build();
AssertStateMachine(stateMachine, "TaskStateWithEnd.json");
}
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 SingleWaitState_WaitUntilTimestamp()
{
StateMachine stateMachine = StepFunctionBuilder.StateMachine()
.StartAt("InitialState")
.State("InitialState", StepFunctionBuilder.WaitState()
.WaitFor(StepFunctionBuilder.Timestamp(DateTime.Parse("2016-03-14T01:59:00Z").ToUniversalTime()))
.Transition(StepFunctionBuilder.End()))
.Build();
AssertStateMachine(stateMachine, "SingleWaitStateWithTimestamp.json");
}
public void SingleWaitState_WaitUntilTimestampWithPath()
{
StateMachine stateMachine = StepFunctionBuilder.StateMachine()
.StartAt("InitialState")
.State("InitialState", StepFunctionBuilder.WaitState()
.WaitFor(StepFunctionBuilder.TimestampPath("$.timestamp"))
.Transition(StepFunctionBuilder.End()))
.Build();
AssertStateMachine(stateMachine, "SingleWaitStateWithTimestampWithPath.json");
}
[Fact]//
public void RetrierInTaskState_OnlyErrorEqualsSet_IsValid()
{
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.TaskState()
.Transition(StepFunctionBuilder.End())
.Retrier(StepFunctionBuilder.Retrier()
.RetryOnAllErrors())
.Resource("arn"))
.Build();
}
public void ParallelStateInvalidBranchState_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.ParallelState()
.Branch(StepFunctionBuilder.Branch()
.StartAt("InitialBranchState")
.State("InitialBranchState", StepFunctionBuilder.FailState()))
.Transition(StepFunctionBuilder.End()))
.Build());
}
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());
}
[Fact]//
public void RetrierInTaskState_BackoffRateGreaterThanOne_IsValid()
{
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.TaskState()
.Transition(StepFunctionBuilder.End())
.Retrier(StepFunctionBuilder.Retrier()
.BackoffRate(1.5)
.RetryOnAllErrors())
.Resource("arn"))
.Build();
}
public void RetrierInTaskState_RetryAllHasOtherErrorCodes_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.TaskState()
.Transition(StepFunctionBuilder.End())
.Retrier(StepFunctionBuilder.Retrier()
.ErrorEquals("Foo", "Bar", ErrorCodes.ALL))
.Resource("arn"))
.Build());
}
