コード例 #1
0
 private static void AssignNotJson(IDSFDataObject dataObject, IServiceTestOutput output, string variable, string value)
 {
     if (!DataListUtil.IsValueRecordset(output.Variable))
     {
         dataObject.Environment.Assign(variable, value, 0);
     }
 }
コード例 #2
0
ファイル: Evaluator.cs プロジェクト: Year-2019-20/Warewolf
 static void UpdateToPending(IServiceTestOutput serviceTestOutput)
 {
     if (serviceTestOutput?.Result != null)
     {
         serviceTestOutput.Result.RunTestResult = RunResult.TestPending;
     }
     else
     {
         if (serviceTestOutput != null)
         {
             serviceTestOutput.Result = new TestRunResult {
                 RunTestResult = RunResult.TestPending
             };
         }
     }
 }
コード例 #3
0
ファイル: ServiceTestModel.cs プロジェクト: tuga1975/Warewolf
        void AddBlankRowToRecordset(IServiceTestOutput dlItem, IList <IScalar> columns, int indexToInsertAt, int indexNum, IDataListModel dataList)
        {
            IList <IScalar> recsetCols = columns.Distinct(Scalar.Comparer).ToList();
            string          colName    = null;

            foreach (var col in recsetCols.Distinct(new ScalarNameComparer()))
            {
                if (string.IsNullOrEmpty(colName) || !colName.Equals(col.Name))
                {
                    var recSetName        = DataListUtil.ExtractRecordsetNameFromValue(dlItem.Variable);
                    var varName           = string.Concat(recSetName, @"(", indexNum, @").", col.Name);
                    var serviceTestOutput = new ServiceTestOutput(varName, string.Empty, string.Empty, string.Empty);
                    serviceTestOutput.AddNewAction = () => AddRow(serviceTestOutput, dataList);
                    Outputs.Insert(indexToInsertAt + 1, serviceTestOutput);
                    indexToInsertAt++;
                }
                colName = col.Name;
            }
        }
コード例 #4
0
        private static ServiceTestOutput GetTestOutput(ServiceTestStep testStep, IServiceTestOutput serviceTestOutput)
        {
            var variable = serviceTestOutput.Variable ?? "";
            var value    = serviceTestOutput.Value ?? "";
            var to       = serviceTestOutput.To ?? "";
            var from     = serviceTestOutput.From ?? "";

            var testOutput = new ServiceTestOutput(variable, value, from, to)
            {
                AddStepOutputRow   = testStep.AddNewOutput,
                AssertOp           = serviceTestOutput.AssertOp ?? "=",
                HasOptionsForValue = serviceTestOutput.HasOptionsForValue,
                OptionsForValue    = serviceTestOutput.OptionsForValue ?? new List <string>(),
                Result             = serviceTestOutput.Result ?? new TestRunResult {
                    RunTestResult = RunResult.TestPending
                }
            };

            return(testOutput);
        }
コード例 #5
0
ファイル: ServiceTestModel.cs プロジェクト: tuga1975/Warewolf
        public void AddRow(IServiceTestOutput itemToAdd, IDataListModel dataList)
        {
            if (itemToAdd != null && DataListUtil.IsValueRecordset(itemToAdd.Variable))
            {
                var recordsetNameFromValue = DataListUtil.ExtractRecordsetNameFromValue(itemToAdd.Variable);
                var recordset = dataList.ShapeRecordSets.FirstOrDefault(set => set.Name == recordsetNameFromValue);
                if (recordset == null)
                {
                    return;
                }
                var recsetCols = new List <IScalar>();
                foreach (var column in recordset.Columns)
                {
                    var cols = column.Value.Where(scalar => scalar.IODirection == enDev2ColumnArgumentDirection.Output || scalar.IODirection == enDev2ColumnArgumentDirection.Both);
                    recsetCols.AddRange(cols);
                }

                var numberOfRows = Outputs.Where(c => DataListUtil.ExtractRecordsetNameFromValue(c.Variable) == recordsetNameFromValue);
                IEnumerable <IServiceTestOutput> dataListItems = numberOfRows as IServiceTestOutput[] ?? numberOfRows.ToArray();
                var lastItem        = dataListItems.Last();
                var indexToInsertAt = Outputs.IndexOf(lastItem);
                var indexString     = DataListUtil.ExtractIndexRegionFromRecordset(lastItem.Variable);
                var indexNum        = Convert.ToInt32(indexString) + 1;
                var lastRow         = dataListItems.Where(c => DataListUtil.ExtractIndexRegionFromRecordset(c.Variable) == indexString);
                var addRow          = false;
                foreach (var item in lastRow)
                {
                    if (item.Value != string.Empty)
                    {
                        addRow = true;
                    }
                }
                if (addRow)
                {
                    AddBlankRowToRecordset(itemToAdd, recsetCols, indexToInsertAt, indexNum, dataList);
                }
            }
        }
コード例 #6
0
        private static IEnumerable <TestRunResult> GetTestRunResults(IDSFDataObject dataObject, IServiceTestOutput output, Dev2DecisionFactory factory, IDebugState debugState)
        {
            if (output == null)
            {
                var testResult = new TestRunResult
                {
                    RunTestResult = RunResult.None
                };
                return(new List <TestRunResult> {
                    testResult
                });
            }
            if (string.IsNullOrEmpty(output.Variable) && string.IsNullOrEmpty(output.Value))
            {
                var testResult = new TestRunResult
                {
                    RunTestResult = RunResult.None
                };
                output.Result = testResult;
                return(new List <TestRunResult> {
                    testResult
                });
            }
            if (output.Result != null)
            {
                output.Result.RunTestResult = RunResult.TestInvalid;
            }
            if (string.IsNullOrEmpty(output.Variable))
            {
                var testResult = new TestRunResult
                {
                    RunTestResult = RunResult.TestInvalid,
                    Message       = Messages.Test_NothingToAssert
                };
                output.Result = testResult;
                if (dataObject.IsDebugMode())
                {
                    var       debugItemStaticDataParams = new DebugItemServiceTestStaticDataParams(testResult.Message, true);
                    DebugItem itemToAdd = new DebugItem();
                    itemToAdd.AddRange(debugItemStaticDataParams.GetDebugItemResult());
                    debugState.AssertResultList.Add(itemToAdd);
                }
                return(new List <TestRunResult> {
                    testResult
                });
            }
            IFindRecsetOptions opt = FindRecsetOptions.FindMatch(output.AssertOp);
            var decisionType       = DecisionDisplayHelper.GetValue(output.AssertOp);
            var value = new List <DataStorage.WarewolfAtom> {
                DataStorage.WarewolfAtom.NewDataString(output.Value)
            };
            var from = new List <DataStorage.WarewolfAtom> {
                DataStorage.WarewolfAtom.NewDataString(output.From)
            };
            var to = new List <DataStorage.WarewolfAtom> {
                DataStorage.WarewolfAtom.NewDataString(output.To)
            };

            IList <TestRunResult> ret = new List <TestRunResult>();
            var iter  = new WarewolfListIterator();
            var cols1 = dataObject.Environment.EvalAsList(DataListUtil.AddBracketsToValueIfNotExist(output.Variable), 0);
            var c1    = new WarewolfAtomIterator(cols1);
            var c2    = new WarewolfAtomIterator(value);
            var c3    = new WarewolfAtomIterator(@from);

            if (opt.ArgumentCount > 2)
            {
                c2 = new WarewolfAtomIterator(to);
            }
            iter.AddVariableToIterateOn(c1);
            iter.AddVariableToIterateOn(c2);
            iter.AddVariableToIterateOn(c3);
            while (iter.HasMoreData())
            {
                var val1         = iter.FetchNextValue(c1);
                var val2         = iter.FetchNextValue(c2);
                var val3         = iter.FetchNextValue(c3);
                var assertResult = factory.FetchDecisionFunction(decisionType).Invoke(new[] { val1, val2, val3 });
                var testResult   = new TestRunResult();
                if (assertResult)
                {
                    testResult.RunTestResult = RunResult.TestPassed;
                }
                else
                {
                    testResult.RunTestResult = RunResult.TestFailed;
                    var msg    = DecisionDisplayHelper.GetFailureMessage(decisionType);
                    var actMsg = string.Format(msg, val2, output.Variable, val1, val3);
                    testResult.Message = new StringBuilder(testResult.Message).AppendLine(actMsg).ToString();
                }
                if (dataObject.IsDebugMode())
                {
                    var msg = testResult.Message;
                    if (testResult.RunTestResult == RunResult.TestPassed)
                    {
                        msg = Messages.Test_PassedResult;
                    }

                    var hasError = testResult.RunTestResult == RunResult.TestFailed;

                    var       debugItemStaticDataParams = new DebugItemServiceTestStaticDataParams(msg, hasError);
                    DebugItem itemToAdd = new DebugItem();
                    itemToAdd.AddRange(debugItemStaticDataParams.GetDebugItemResult());

                    if (debugState.AssertResultList != null)
                    {
                        bool addItem = debugState.AssertResultList.Select(debugItem => debugItem.ResultsList.Where(debugItemResult => debugItemResult.Value == Messages.Test_PassedResult)).All(debugItemResults => !debugItemResults.Any());

                        if (addItem)
                        {
                            debugState.AssertResultList.Add(itemToAdd);
                        }
                    }
                }
                output.Result = testResult;
                ret.Add(testResult);
            }
            return(ret);
        }
コード例 #7
0
        private void DispatchDebugState(IDSFDataObject dataObject, IDev2MethodInfo dev2MethodInfo, int index, IServiceTestOutput serviceTestOutput)
        {
            var start = DateTime.Now;

            if (dev2MethodInfo.IsObject)
            {
                var jContainer = JToken.Parse(serviceTestOutput.Value) as JContainer
                                 ?? serviceTestOutput.Value.DeserializeToObject();
                if (!string.IsNullOrEmpty(serviceTestOutput.Variable))
                {
                    dataObject.Environment.AddToJsonObjects(serviceTestOutput.Variable, jContainer);
                }
            }
            else
            {
                dataObject.Environment.Assign(serviceTestOutput.Variable, serviceTestOutput.Value, 0);
            }
            dev2MethodInfo.MethodResult      = serviceTestOutput.Value;
            MethodsToRun[index].MethodResult = serviceTestOutput.Value;
            DispatchDebugStateForMethod(MethodsToRun[index], dataObject, 0, true, start);
        }
コード例 #8
0
        private IEnumerable <TestRunResult> GetTestRunResults(IDSFDataObject dataObject, IServiceTestOutput output, Dev2DecisionFactory factory)
        {
            var expressionType     = output.AssertOp ?? string.Empty;
            IFindRecsetOptions opt = FindRecsetOptions.FindMatch(expressionType);
            var decisionType       = DecisionDisplayHelper.GetValue(expressionType);

            if (decisionType == enDecisionType.IsError)
            {
                var hasErrors  = dataObject.Environment.AllErrors.Count > 0;
                var testResult = new TestRunResult();
                if (hasErrors)
                {
                    testResult.RunTestResult = RunResult.TestPassed;
                }
                else
                {
                    testResult.RunTestResult = RunResult.TestFailed;
                    var msg    = DecisionDisplayHelper.GetFailureMessage(decisionType);
                    var actMsg = string.Format(msg);
                    testResult.Message = new StringBuilder(testResult.Message).AppendLine(actMsg).ToString();
                }
                return(new[] { testResult });
            }
            if (decisionType == enDecisionType.IsNotError)
            {
                var noErrors   = dataObject.Environment.AllErrors.Count == 0;
                var testResult = new TestRunResult();
                if (noErrors)
                {
                    testResult.RunTestResult = RunResult.TestPassed;
                }
                else
                {
                    testResult.RunTestResult = RunResult.TestFailed;
                    var msg    = DecisionDisplayHelper.GetFailureMessage(decisionType);
                    var actMsg = string.Format(msg);
                    testResult.Message = new StringBuilder(testResult.Message).AppendLine(actMsg).ToString();
                }
                return(new[] { testResult });
            }
            var value = new List <DataStorage.WarewolfAtom> {
                DataStorage.WarewolfAtom.NewDataString(output.Value)
            };
            var from = new List <DataStorage.WarewolfAtom> {
                DataStorage.WarewolfAtom.NewDataString(output.From)
            };
            var to = new List <DataStorage.WarewolfAtom> {
                DataStorage.WarewolfAtom.NewDataString(output.To)
            };

            IList <TestRunResult> ret = new List <TestRunResult>();
            var iter     = new WarewolfListIterator();
            var variable = DataListUtil.AddBracketsToValueIfNotExist(output.Variable);
            var cols1    = dataObject.Environment.EvalAsList(variable, 0);
            var c1       = new WarewolfAtomIterator(cols1);
            var c2       = new WarewolfAtomIterator(value);
            var c3       = new WarewolfAtomIterator(to);

            if (opt.ArgumentCount > 2)
            {
                c2 = new WarewolfAtomIterator(from);
            }
            iter.AddVariableToIterateOn(c1);
            iter.AddVariableToIterateOn(c2);
            iter.AddVariableToIterateOn(c3);
            while (iter.HasMoreData())
            {
                var val1         = iter.FetchNextValue(c1);
                var val2         = iter.FetchNextValue(c2);
                var val3         = iter.FetchNextValue(c3);
                var assertResult = factory.FetchDecisionFunction(decisionType).Invoke(new[] { val1, val2, val3 });
                var testResult   = new TestRunResult();
                if (assertResult)
                {
                    testResult.RunTestResult = RunResult.TestPassed;
                }
                else
                {
                    testResult.RunTestResult = RunResult.TestFailed;
                    var msg    = DecisionDisplayHelper.GetFailureMessage(decisionType);
                    var actMsg = string.Format(msg, val2, variable, val1, val3);
                    testResult.Message = new StringBuilder(testResult.Message).AppendLine(actMsg).ToString();
                }
                output.Result = testResult;
                ret.Add(testResult);
            }
            return(ret);
        }