Exemple #1
0
 public void NoConditionsInAnd_IsNotValid()
 {
     Assert.Throws <ValidationException>(() =>
                                         StepFunctionBuilder.StateMachine()
                                         .StartAt("Initial")
                                         .State("Initial", StepFunctionBuilder.ChoiceState()
                                                .Choice(StepFunctionBuilder.Choice()
                                                        .Condition(StepFunctionBuilder.And())
                                                        .Transition(StepFunctionBuilder.Next("Terminal")))
                                                .DefaultStateName("Terminal"))
                                         .State("Terminal", StepFunctionBuilder.SucceedState())
                                         .Build());
 }
Exemple #2
0
        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 TestAndOperator()
        {
            var c = StepFunctionBuilder.ChoiceState()
                    .Choice(StepFunctionBuilder.Choice()
                            .Transition(StepFunctionBuilder.Next("NextState"))
                            .Condition(StepFunctionBuilder.And(StepFunctionBuilder.Eq("$.varstr", "value"),
                                                               StepFunctionBuilder.Eq("$.varbool", true)))
                            )
                    .Build();

            var choices = c.Choices.ToArray();

            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 })));
            Assert.False(choices[0].Condition.Match(JObject.FromObject(new { varstr = "valuee", varbool = false })));
            Assert.False(choices[0].Condition.Match(JObject.FromObject(new { varstr = "valuee", varbool = true })));
        }
Exemple #4
0
        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");
        }
Exemple #5
0
        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");
        }