示例#1
0
        protected override void BuildDataList()
        {
            List <Tuple <string, string> > variableList;

            ScenarioContext.Current.TryGetValue("variableList", out variableList);

            if (variableList == null)
            {
                variableList = new List <Tuple <string, string> >();
                ScenarioContext.Current.Add("variableList", variableList);
            }

            variableList.Add(new Tuple <string, string>(ResultVariable, ""));
            BuildShapeAndTestData();

            enRandomType randomType;

            ScenarioContext.Current.TryGetValue("randomType", out randomType);
            string length;

            ScenarioContext.Current.TryGetValue("length", out length);
            string rangeFrom;

            ScenarioContext.Current.TryGetValue("rangeFrom", out rangeFrom);
            string rangeTo;

            ScenarioContext.Current.TryGetValue("rangeTo", out rangeTo);

            var dsfRandom = new DsfRandomActivity
            {
                RandomType = randomType,
                Result     = ResultVariable
            };

            if (!string.IsNullOrEmpty(length))
            {
                dsfRandom.Length = length;
            }

            if (!string.IsNullOrEmpty(rangeFrom))
            {
                dsfRandom.From = rangeFrom;
            }

            if (!string.IsNullOrEmpty(rangeTo))
            {
                dsfRandom.To = rangeTo;
            }

            TestStartNode = new FlowStep
            {
                Action = dsfRandom
            };

            ScenarioContext.Current.Add("activity", dsfRandom);
        }
        protected override void BuildDataList()
        {
            List<Tuple<string, string>> variableList;
            ScenarioContext.Current.TryGetValue("variableList", out variableList);

            if (variableList == null)
            {
                variableList = new List<Tuple<string, string>>();
                ScenarioContext.Current.Add("variableList", variableList);
            }

            variableList.Add(new Tuple<string, string>(ResultVariable, ""));
            BuildShapeAndTestData();

            enRandomType randomType;
            ScenarioContext.Current.TryGetValue("randomType", out randomType);
            string length;
            ScenarioContext.Current.TryGetValue("length", out length);
            string rangeFrom;
            ScenarioContext.Current.TryGetValue("rangeFrom", out rangeFrom);
            string rangeTo;
            ScenarioContext.Current.TryGetValue("rangeTo", out rangeTo);

            var dsfRandom = new DsfRandomActivity
                {
                    RandomType = randomType,
                    Result = ResultVariable
                };

            if (!string.IsNullOrEmpty(length))
            {
                dsfRandom.Length = length;
            }

            if (!string.IsNullOrEmpty(rangeFrom))
            {
                dsfRandom.From = rangeFrom;
            }

            if (!string.IsNullOrEmpty(rangeTo))
            {
                dsfRandom.To = rangeTo;
            }

            TestStartNode = new FlowStep
                {
                    Action = dsfRandom
                };

            ScenarioContext.Current.Add("activity", dsfRandom);
        }
        public void DsfRandomActivity_UpdateForEachOutputs_NullUpdates_DoesNothing()
        {
            //------------Setup for test--------------------------
            const string From   = "[[Numeric(1).num]]";
            const string To     = "Up";
            const string Result = "[[res]]";
            const string Length = "2";
            var          act    = new DsfRandomActivity {
                From = From, To = To, Length = Length, Result = Result
            };

            act.UpdateForEachOutputs(null, null);
            //------------Assert Results-------------------------
            Assert.AreEqual(Result, act.Result);
        }
示例#4
0
        public void DsfRandomActivity_GetOutputs_Called_ShouldReturnListWithResultValueInIt()
        {
            //------------Setup for test--------------------------
            const string From   = "[[Numeric(1).num]]";
            const string To     = "Up";
            const string Result = "[[res]]";
            const string Length = "2";
            var          act    = new DsfRandomActivity {
                From = From, To = To, Length = Length, Result = Result
            };
            //------------Execute Test---------------------------
            var outputs = act.GetOutputs();

            //------------Assert Results-------------------------
            Assert.AreEqual(1, outputs.Count);
            Assert.AreEqual("[[res]]", outputs[0]);
        }
        public void DsfRandomActivity_UpdateForEachInputs_NullUpdates_DoesNothing()
        {
            //------------Setup for test--------------------------
            const string From   = "[[Numeric(1).num]]";
            const string To     = "Up";
            const string Result = "[[res]]";
            const string Length = "2";
            var          act    = new DsfRandomActivity {
                From = From, To = To, Length = Length, Result = Result
            };

            //------------Execute Test---------------------------
            act.UpdateForEachInputs(null);
            //------------Assert Results-------------------------
            Assert.AreEqual(From, act.From);
            Assert.AreEqual(To, act.To);
            Assert.AreEqual(Length, act.Length);
        }
        public void DsfRandomActivity_GetForEachOutputs_WhenHasResult_ReturnsOutputList()
        {
            //------------Setup for test--------------------------
            const string From   = "[[Numeric(1).num]]";
            const string To     = "Up";
            const string Result = "[[res]]";
            const string Length = "2";
            var          act    = new DsfRandomActivity {
                From = From, To = To, Length = Length, Result = Result
            };

            //------------Execute Test---------------------------
            var dsfForEachItems = act.GetForEachOutputs();

            //------------Assert Results-------------------------
            Assert.AreEqual(1, dsfForEachItems.Count);
            Assert.AreEqual(Result, dsfForEachItems[0].Name);
            Assert.AreEqual(Result, dsfForEachItems[0].Value);
        }
        public void DsfRandomActivity_UpdateForEachOutputs_1Updates_UpdateCommandResult()
        {
            //------------Setup for test--------------------------
            const string From   = "[[Numeric(1).num]]";
            const string To     = "Up";
            const string Result = "[[res]]";
            const string Length = "2";
            var          act    = new DsfRandomActivity {
                From = From, To = To, Length = Length, Result = Result
            };

            var tuple1 = new Tuple <string, string>("[[res]]", "Test");

            //------------Execute Test---------------------------
            act.UpdateForEachOutputs(new List <Tuple <string, string> > {
                tuple1
            }, null);
            //------------Assert Results-------------------------
            Assert.AreEqual("Test", act.Result);
        }
示例#8
0
        public void Equals_Given_EmptyActivityTools_AreEqual()
        {
            //---------------Set up test pack-------------------
            var uniqueId = Guid.NewGuid().ToString();
            var activity = new DsfRandomActivity()
            {
                UniqueID = uniqueId
            };
            var activity1 = new DsfRandomActivity()
            {
                UniqueID = uniqueId
            };

            //---------------Assert Precondition----------------
            Assert.IsNotNull(activity);
            //---------------Execute Test ----------------------
            var @equals = activity.Equals(activity1);

            //---------------Test Result -----------------------
            Assert.IsTrue(@equals);
        }
示例#9
0
        public void Equals_Given_Different_DisplayName_Is_Not_Equal()
        {
            //---------------Set up test pack-------------------
            var uniqueId  = Guid.NewGuid().ToString();
            var activity1 = new DsfRandomActivity()
            {
                UniqueID = uniqueId, DisplayName = "A"
            };
            var activity = new DsfRandomActivity()
            {
                UniqueID = uniqueId, DisplayName = "ass"
            };

            //---------------Assert Precondition----------------
            Assert.IsNotNull(activity1);
            //---------------Execute Test ----------------------
            var @equals = activity1.Equals(activity);

            //---------------Test Result -----------------------
            Assert.IsFalse(@equals);
        }
示例#10
0
        public void Equals_Given_Same_RandomType_IsEqual()
        {
            //---------------Set up test pack-------------------
            var uniqueId = Guid.NewGuid().ToString();

            var activity1 = new DsfRandomActivity()
            {
                UniqueID = uniqueId, RandomType = enRandomType.Numbers
            };
            var activity = new DsfRandomActivity()
            {
                UniqueID = uniqueId, RandomType = enRandomType.Numbers
            };

            //---------------Assert Precondition----------------
            Assert.IsNotNull(activity1);
            //---------------Execute Test ----------------------
            var @equals = activity1.Equals(activity);

            //---------------Test Result -----------------------
            Assert.IsTrue(@equals);
        }
示例#11
0
        public void GivenItContainsRandomAs(string parentName, string activityName, Table table)
        {
            var activity = new DsfRandomActivity {
                DisplayName = activityName
            };

            foreach (var tableRow in table.Rows)
            {
                var type   = (enRandomType)Enum.Parse(typeof(enRandomType), tableRow["Type"]);
                var from   = tableRow["From"];
                var to     = tableRow["To"];
                var result = tableRow["Result"];

                _commonSteps.AddVariableToVariableList(result);

                activity.RandomType = type;
                activity.To         = to;
                activity.From       = from;
                activity.Result     = result;
            }

            _commonSteps.AddActivityToActivityList(parentName, activityName, activity);
        }
示例#12
0
        public void DsfRandomActivity_UpdateForEachInputs_MoreThan1Updates_Updates()
        {
            //------------Setup for test--------------------------
            const string From   = "[[Numeric(1).num]]";
            const string To     = "Up";
            const string Result = "[[res]]";
            const string Length = "2";
            var          act    = new DsfRandomActivity {
                From = From, To = To, Length = Length, Result = Result
            };

            var tuple1 = new Tuple <string, string>(From, "Test");
            var tuple2 = new Tuple <string, string>(To, "Test2");
            var tuple3 = new Tuple <string, string>(Length, "Test3");

            //------------Execute Test---------------------------
            act.UpdateForEachInputs(new List <Tuple <string, string> > {
                tuple1, tuple2, tuple3
            }, null);
            //------------Assert Results-------------------------
            Assert.AreEqual("Test2", act.To);
            Assert.AreEqual("Test", act.From);
            Assert.AreEqual("Test3", act.Length);
        }
        public void DsfRandomActivity_UpdateForEachOutputs_NullUpdates_DoesNothing()
        {
            //------------Setup for test--------------------------
            const string From = "[[Numeric(1).num]]";
            const string To = "Up";
            const string Result = "[[res]]";
            const string Length = "2";
            var act = new DsfRandomActivity { From = From, To = To, Length = Length, Result = Result };

            act.UpdateForEachOutputs(null);
            //------------Assert Results-------------------------
            Assert.AreEqual(Result, act.Result);
        }
示例#14
0
        protected override void BuildDataList()
        {
            scenarioContext.TryGetValue("variableList", out List <Tuple <string, string> > variableList);

            if (variableList == null)
            {
                variableList = new List <Tuple <string, string> >();
                scenarioContext.Add("variableList", variableList);
            }

            variableList.Add(new Tuple <string, string>(ResultRecordsetVariable, ""));

            if (scenarioContext.TryGetValue("outMapTo", out string outMapTo))
            {
                variableList.Add(new Tuple <string, string>(outMapTo, ""));
            }

            BuildShapeAndTestData();

            var activityType = scenarioContext.Get <string>("activityType");

            dynamic activity;

            if (activityType.Equals("Tool"))
            {
                activity = new DsfRandomActivity
                {
                    Result     = ResultRecordsetVariable,
                    RandomType = enRandomType.Numbers,
                    From       = "0",
                    To         = "100"
                };
            }
            else
            {
                activity = new DsfActivity
                {
                    InputMapping  = BuildInputMappings(),
                    OutputMapping = BuildOutputMappings(),
                    ServiceName   = "SpecflowForeachActivityTest"
                };
            }

            var activityFunction = new ActivityFunc <string, bool> {
                Handler = activity
            };
            var foreachType = scenarioContext.Get <enForEachType>("foreachType");

            if (!scenarioContext.TryGetValue("recordset", out string recordSet))
            {
                recordSet = string.Empty;
            }

            if (!scenarioContext.TryGetValue("from", out string from))
            {
                from = string.Empty;
            }

            if (!scenarioContext.TryGetValue("to", out string to))
            {
                to = string.Empty;
            }

            if (!scenarioContext.TryGetValue("numberAs", out string numberAs))
            {
                numberAs = string.Empty;
            }

            var dsfForEach = new DsfForEachActivity
            {
                ForEachType    = foreachType,
                Recordset      = recordSet,
                From           = from,
                To             = to,
                CsvIndexes     = numberAs,
                NumOfExections = numberAs,
                DataFunc       = activityFunction
            };

            TestStartNode = new FlowStep
            {
                Action = dsfForEach
            };

            scenarioContext.Add("activity", dsfForEach);
        }
        public void DsfRandomActivity_GetForEachOutputs_WhenHasResult_ReturnsOutputList()
        {
            //------------Setup for test--------------------------
            const string From = "[[Numeric(1).num]]";
            const string To = "Up";
            const string Result = "[[res]]";
            const string Length = "2";
            var act = new DsfRandomActivity { From = From, To = To, Length = Length, Result = Result };

            //------------Execute Test---------------------------
            var dsfForEachItems = act.GetForEachOutputs();
            //------------Assert Results-------------------------
            Assert.AreEqual(1, dsfForEachItems.Count);
            Assert.AreEqual(Result, dsfForEachItems[0].Name);
            Assert.AreEqual(Result, dsfForEachItems[0].Value);
        }
        public void DsfRandomActivity_UpdateForEachInputs_MoreThan1Updates_Updates()
        {
            //------------Setup for test--------------------------
            const string From = "[[Numeric(1).num]]";
            const string To = "Up";
            const string Result = "[[res]]";
            const string Length = "2";
            var act = new DsfRandomActivity { From = From, To = To, Length = Length, Result = Result };

            var tuple1 = new Tuple<string, string>(From, "Test");
            var tuple2 = new Tuple<string, string>(To, "Test2");
            var tuple3 = new Tuple<string, string>(Length, "Test3");
            //------------Execute Test---------------------------
            act.UpdateForEachInputs(new List<Tuple<string, string>> { tuple1, tuple2, tuple3 });
            //------------Assert Results-------------------------
            Assert.AreEqual("Test2", act.To);
            Assert.AreEqual("Test", act.From);
            Assert.AreEqual("Test3", act.Length);
        }
        public void GivenItContainsRandomAs(string parentName, string activityName, Table table)
        {
            var activity = new DsfRandomActivity { DisplayName = activityName };
            foreach(var tableRow in table.Rows)
            {
                var type = (enRandomType)Enum.Parse(typeof(enRandomType), tableRow["Type"]);
                var from = tableRow["From"];
                var to = tableRow["To"];
                var result = tableRow["Result"];

                CommonSteps.AddVariableToVariableList(result);

                activity.RandomType = type;
                activity.To = to;
                activity.From = from;
                activity.Result = result;

            }

            CommonSteps.AddActivityToActivityList(parentName, activityName, activity);
        }
        public void DsfRandomActivity_UpdateForEachOutputs_1Updates_UpdateCommandResult()
        {
            //------------Setup for test--------------------------
            const string From = "[[Numeric(1).num]]";
            const string To = "Up";
            const string Result = "[[res]]";
            const string Length = "2";
            var act = new DsfRandomActivity { From = From, To = To, Length = Length, Result = Result };

            var tuple1 = new Tuple<string, string>("[[res]]", "Test");
            //------------Execute Test---------------------------
            act.UpdateForEachOutputs(new List<Tuple<string, string>> { tuple1 });
            //------------Assert Results-------------------------
            Assert.AreEqual("Test", act.Result);
        }
        public void DsfRandomActivity_GetState_ReturnsStateVariable()
        {
            //---------------Set up test pack-------------------
            //------------Setup for test--------------------------
            var act = new DsfRandomActivity {
                RandomType = enRandomType.LetterAndNumbers, From = "1", To = "5", Length = "2", Result = "[[rand]]"
            };
            //------------Execute Test---------------------------
            var stateItems = act.GetState();

            Assert.AreEqual(5, stateItems.Count());

            var expectedResults = new[]
            {
                new StateVariable
                {
                    Name  = "RandomType",
                    Type  = StateVariable.StateType.Input,
                    Value = "LetterAndNumbers"
                },
                new StateVariable
                {
                    Name  = "From",
                    Type  = StateVariable.StateType.Input,
                    Value = "1"
                },
                new StateVariable
                {
                    Name  = "To",
                    Type  = StateVariable.StateType.Input,
                    Value = "5"
                },
                new StateVariable
                {
                    Name  = "Length",
                    Type  = StateVariable.StateType.Input,
                    Value = "2"
                },
                new StateVariable
                {
                    Name  = "Result",
                    Type  = StateVariable.StateType.Output,
                    Value = "[[rand]]"
                }
            };

            var iter = act.GetState().Select(
                (item, index) => new
            {
                value       = item,
                expectValue = expectedResults[index]
            }
                );

            //------------Assert Results-------------------------
            foreach (var entry in iter)
            {
                Assert.AreEqual(entry.expectValue.Name, entry.value.Name);
                Assert.AreEqual(entry.expectValue.Type, entry.value.Type);
                Assert.AreEqual(entry.expectValue.Value, entry.value.Value);
            }
        }