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 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");
}
[Fact]//
public void ValidMinimalStateMachine_IsValid()
{
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.SucceedState())
.Build();
}
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 StartAtStateDoesNotExist_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
StepFunctionBuilder.StateMachine()
.StartAt("Foo")
.State("Initial", StepFunctionBuilder.SucceedState())
.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 ChoiceStateWithNoChoices_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.ChoiceState()
.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 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());
}
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 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 SingleSucceedState()
{
StateMachine stateMachine = StepFunctionBuilder.StateMachine()
.StartAt("InitialState")
.TimeoutSeconds(30)
.Comment("My Simple State Machine")
.State("InitialState", StepFunctionBuilder.SucceedState()
.Comment("Initial State")
.InputPath("$.input")
.OutputPath("$.output"))
.Build();
AssertStateMachine(stateMachine, "SingleSucceedState.json");
}
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 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 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 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 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 CanSerializeStatesToJson()
{
StateMachine stateMachine = StepFunctionBuilder.StateMachine()
.StartAt("InitialState")
.TimeoutSeconds(30)
.Comment("My Simple State Machine")
.State("InitialState", StepFunctionBuilder.SucceedState()
.Comment("Initial State")
.InputPath("$.input")
.OutputPath("$.output"))
.Build();
string value = stateMachine.States["InitialState"].ToJson();
State s = State.FromJson(value);
Assert.True(s.Type == StateType.Succeed);
}
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 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 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 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 ParallelStateInvalidCatcher_IsNotValid()
{
Assert.Throws <ValidationException>(() =>
StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.ParallelState()
.Branch(StepFunctionBuilder.Branch()
.StartAt("InitialBranchState")
.State("InitialBranchState", StepFunctionBuilder.SucceedState()))
.Transition(StepFunctionBuilder.End())
.Catcher(StepFunctionBuilder.Catcher()
.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 SingleTerminalState_HasNoCycle_IsValid()
{
AssertNoCycle(StepFunctionBuilder.StateMachine()
.StartAt("Initial")
.State("Initial", StepFunctionBuilder.SucceedState()));
}
