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");
}
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 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 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());
}
public void ParallelStateInvalidRetrier_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.ParallelState()
.Branch(StepFunctionBuilder.Branch()
.StartAt("InitialBranchState")
.State("InitialBranchState", StepFunctionBuilder.SucceedState()))
.Transition(StepFunctionBuilder.End())
.Retrier(StepFunctionBuilder.Retrier()
.IntervalSeconds(-1)))
.Build());
}
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 SimpleParallelStateWithTasks()
{
StateMachine stateMachine = StepFunctionBuilder.StateMachine()
.StartAt("para")
.State("para", StepFunctionBuilder.ParallelState()
.Transition(StepFunctionBuilder.End())
.Branches(
StepFunctionBuilder.Branch()
.StartAt("t")
.State("t", StepFunctionBuilder.TaskState().Resource("t").Transition(StepFunctionBuilder.End())),
StepFunctionBuilder.Branch()
.StartAt("u")
.State("u", StepFunctionBuilder.TaskState().Resource("u").Transition(StepFunctionBuilder.End()))
))
.Build();
AssertStateMachine(stateMachine, "SimpleParallelStateWithTasks.json");
}
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()))));
}
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")))))));
}
