Example #1
0
        public void GivenItContainsDateAndTimeDifferenceAs(string parentName, string activityName, Table table)
        {
            var activity = new DsfDateTimeDifferenceActivity {
                DisplayName = activityName
            };

            foreach (var tableRow in table.Rows)
            {
                var input1      = tableRow["Input1"];
                var input2      = tableRow["Input2"];
                var inputFormat = tableRow["Input Format"];
                var output      = tableRow["Output In"];
                var result      = tableRow["Result"];

                _commonSteps.AddVariableToVariableList(result);

                activity.Input1      = input1;
                activity.Input2      = input2;
                activity.InputFormat = inputFormat;
                activity.OutputType  = output;
                activity.Result      = result;
            }

            _commonSteps.AddActivityToActivityList(parentName, activityName, activity);
        }
Example #2
0
        public void DateTimeDifference_GetOutputs_Expected_One_Output()
        {
            DsfDateTimeDifferenceActivity testAct = new DsfDateTimeDifferenceActivity {
                Input1 = "27-10-2012", Input2 = "28-10-2012", InputFormat = "dd-mm-yyyy", OutputType = "Years", Result = "[[result]]"
            };

            IBinaryDataList outputs = testAct.GetOutputs();

            // remove test datalist ;)

            Assert.AreEqual(1, outputs.FetchAllEntries().Count);
        }
        public void DsfDateTimeDifferenceActivity_GetOutputs_Called_ShouldReturnListWithResultValueInIt()
        {
            //------------Setup for test--------------------------
            var act = new DsfDateTimeDifferenceActivity {
                Input1 = "", Input2 = "", InputFormat = "", OutputType = "", Result = "[[dtd]]"
            };
            //------------Execute Test---------------------------
            var outputs = act.GetOutputs();

            //------------Assert Results-------------------------
            Assert.AreEqual(1, outputs.Count);
            Assert.AreEqual("[[dtd]]", outputs[0]);
        }
        protected override void BuildDataList()
        {
            List <Tuple <string, string> > variableList;

            scenarioContext.TryGetValue("variableList", out variableList);

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

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

            string resVar;

            if (!scenarioContext.TryGetValue("resultVar", out resVar))
            {
                resVar = ResultVariable;
            }

            string inputFormat;

            scenarioContext.TryGetValue("inputFormat", out inputFormat);
            string input1;

            scenarioContext.TryGetValue("input1", out input1);
            string input2;

            scenarioContext.TryGetValue("input2", out input2);
            string outputIn;

            scenarioContext.TryGetValue("outputIn", out outputIn);

            var dateTimeDifference = new DsfDateTimeDifferenceActivity
            {
                Result      = resVar,
                InputFormat = string.IsNullOrEmpty(inputFormat) ? "" : inputFormat,
                Input1      = string.IsNullOrEmpty(input1) ? "" : input1,
                Input2      = string.IsNullOrEmpty(input2) ? "" : input2,
                OutputType  = outputIn
            };

            TestStartNode = new FlowStep
            {
                Action = dateTimeDifference
            };
            scenarioContext.Add("activity", dateTimeDifference);
        }
        public void GetActivityFieldsOffDsfDateTimeDifferenceActivityExpectedAllFindMissingFieldsToBeReturned()
        {
            DsfDateTimeDifferenceActivity activity = new DsfDateTimeDifferenceActivity();

            activity.Input1      = "[[Input1]]";
            activity.Input2      = "[[Input2]]";
            activity.InputFormat = "[[InputFormat]]";
            activity.Result      = "[[Result]]";
            Dev2FindMissingStrategyFactory fac      = new Dev2FindMissingStrategyFactory();
            IFindMissingStrategy           strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
            List <string> actual   = strategy.GetActivityFields(activity);
            List <string> expected = new List <string> {
                "[[Input1]]", "[[Input2]]", "[[InputFormat]]", "[[Result]]"
            };

            CollectionAssert.AreEqual(expected, actual);
        }
        public void Dev2FindMissingStrategyFactory_GetActivityFieldsOff_DsfDateTimeDifference_Activity_ExpectAllFindMissingFieldsToBeReturned()
        {
            var activity = new DsfDateTimeDifferenceActivity
            {
                Input1      = "[[Input1]]",
                Input2      = "[[Input2]]",
                InputFormat = "[[InputFormat]]",
                Result      = "[[Result]]"
            };
            var fac      = new Dev2FindMissingStrategyFactory();
            var strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
            var actual   = strategy.GetActivityFields(activity);
            var expected = new List <string> {
                "[[Input1]]", "[[Input2]]", "[[InputFormat]]", "[[Result]]"
            };

            CollectionAssert.AreEqual(expected, actual);
        }
Example #7
0
        public void Equals_Given_DisplayName_Different_DisplayName_Is_Not_Equal()
        {
            //---------------Set up test pack-------------------
            var uniqueId  = Guid.NewGuid().ToString();
            var activity1 = new DsfDateTimeDifferenceActivity()
            {
                UniqueID = uniqueId, DisplayName = "A"
            };
            var activity = new DsfDateTimeDifferenceActivity()
            {
                UniqueID = uniqueId, DisplayName = "ass"
            };

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

            //---------------Test Result -----------------------
            Assert.IsFalse(@equals);
        }
Example #8
0
        public void Equals_Given_EmptyActivityTools_AreEqual()
        {
            //---------------Set up test pack-------------------
            var uniqueId = Guid.NewGuid().ToString();
            var activity = new DsfDateTimeDifferenceActivity()
            {
                UniqueID = uniqueId
            };
            var activity1 = new DsfDateTimeDifferenceActivity()
            {
                UniqueID = uniqueId
            };

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

            //---------------Test Result -----------------------
            Assert.IsTrue(@equals);
        }
Example #9
0
        public void Equals_Given_Same_InputFormat_IsEqual()
        {
            //---------------Set up test pack-------------------
            var uniqueId  = Guid.NewGuid().ToString();
            var activity1 = new DsfDateTimeDifferenceActivity()
            {
                UniqueID = uniqueId, InputFormat = "a"
            };
            var activity = new DsfDateTimeDifferenceActivity()
            {
                UniqueID = uniqueId, InputFormat = "a"
            };

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

            //---------------Test Result -----------------------
            Assert.IsTrue(@equals);
        }
        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();

            string inputFormat;
            ScenarioContext.Current.TryGetValue("inputFormat", out inputFormat);
            string input1;
            ScenarioContext.Current.TryGetValue("input1", out input1);
            string input2;
            ScenarioContext.Current.TryGetValue("input2", out input2);
            string outputIn;
            ScenarioContext.Current.TryGetValue("outputIn", out outputIn);

            var dateTimeDifference = new DsfDateTimeDifferenceActivity
                {
                    Result = ResultVariable,
                    InputFormat = string.IsNullOrEmpty(inputFormat) ? "" : inputFormat,
                    Input1 = string.IsNullOrEmpty(input1) ? "" : input1,
                    Input2 = string.IsNullOrEmpty(input2) ? "" : input2,
                    OutputType = outputIn
                };

            TestStartNode = new FlowStep
                {
                    Action = dateTimeDifference
                };
            ScenarioContext.Current.Add("activity", dateTimeDifference);
        }
 public void GetActivityFieldsOffDsfDateTimeDifferenceActivityExpectedAllFindMissingFieldsToBeReturned()
 {
     DsfDateTimeDifferenceActivity activity = new DsfDateTimeDifferenceActivity();
     activity.Input1 = "[[Input1]]";
     activity.Input2 = "[[Input2]]";
     activity.InputFormat = "[[InputFormat]]";
     activity.Result = "[[Result]]";
     Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
     IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
     List<string> actual = strategy.GetActivityFields(activity);
     List<string> expected = new List<string> { "[[Input1]]", "[[Input2]]", "[[InputFormat]]", "[[Result]]" };
     CollectionAssert.AreEqual(expected, actual);
 }
Example #12
0
        public void DsfDateTimeDifferenceActivity_GetState_ReturnsStateVariable()
        {
            //------------Setup for test--------------------------
            var dateTimeDifferenceActivity = new DsfDateTimeDifferenceActivity
            {
                Input1      = "date1",
                Input2      = "date2",
                InputFormat = "yyyy/MM/dd",
                OutputType  = "Years",
                Result      = "DateChanged"
            };
            //------------Execute Test---------------------------
            var stateItems = dateTimeDifferenceActivity.GetState();

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

            var expectedResults = new[]
            {
                new StateVariable
                {
                    Name  = "Input1",
                    Type  = StateVariable.StateType.Input,
                    Value = "date1"
                },
                new StateVariable
                {
                    Name  = "Input2",
                    Type  = StateVariable.StateType.Input,
                    Value = "date2"
                },
                new StateVariable
                {
                    Name  = "InputFormat",
                    Type  = StateVariable.StateType.Input,
                    Value = "yyyy/MM/dd"
                },
                new StateVariable
                {
                    Name  = "OutputType",
                    Type  = StateVariable.StateType.Input,
                    Value = "Years"
                },
                new StateVariable
                {
                    Name  = "Result",
                    Type  = StateVariable.StateType.Output,
                    Value = "DateChanged"
                }
            };

            var iter = dateTimeDifferenceActivity.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);
            }
        }
        public void GivenItContainsDateAndTimeDifferenceAs(string parentName, string activityName, Table table)
        {
            var activity = new DsfDateTimeDifferenceActivity { DisplayName = activityName };
            foreach(var tableRow in table.Rows)
            {
                var input1 = tableRow["Input1"];
                var input2 = tableRow["Input2"];
                var inputFormat = tableRow["Input Format"];
                var output = tableRow["Output In"];
                var result = tableRow["Result"];

                CommonSteps.AddVariableToVariableList(result);

                activity.Input1 = input1;
                activity.Input2 = input2;
                activity.InputFormat = inputFormat;
                activity.OutputType = output;
                activity.Result = result;

            }

            CommonSteps.AddActivityToActivityList(parentName, activityName, activity);
        }
        public void DateTimeDifference_GetOutputs_Expected_One_Output()
        {
            DsfDateTimeDifferenceActivity testAct = new DsfDateTimeDifferenceActivity { Input1 = "27-10-2012", Input2 = "28-10-2012", InputFormat = "dd-mm-yyyy", OutputType = "Years", Result = "[[result]]" };

            IBinaryDataList outputs = testAct.GetOutputs();

            // remove test datalist ;)

            Assert.AreEqual(1, outputs.FetchAllEntries().Count);
        }