internal override bool Eval(string left, Func <string, string, string, IEnumerable <string[]> > getArgumentsFunc, bool hasError) { var factory = Dev2DecisionFactory.Instance(); if (MatchType == enDecisionType.IsError) { return(hasError); } if (MatchType == enDecisionType.IsNotError) { return(!hasError); } IList <bool> ret = new List <bool>(); var items = getArgumentsFunc(left, From, To); foreach (var arguments in items) { try { ret.Add(factory.FetchDecisionFunction(MatchType).Invoke(arguments)); } catch (Exception) { ret.Add(false); } } return(ret.All(o => o)); }
public void Dev2DecisionFactory_Instance_ShouldHaveAStaticInstance() { //------------Setup for test-------------------------- //------------Execute Test--------------------------- //------------Assert Results------------------------- Assert.IsNotNull(Dev2DecisionFactory.Instance()); }
public void GivenIsLessThanDev2DecisionFactory_HandleType_ShouldReturnIsLessThan() { var decisionType = enDecisionType.IsLessThan; //------------Setup for test-------------------------- var decisionFactory = new Dev2DecisionFactory(); //------------Execute Test--------------------------- var fetchDecisionFunction = decisionFactory.FetchDecisionFunction(decisionType); //------------Assert Results------------------------- Assert.AreEqual(decisionType, fetchDecisionFunction.HandlesType()); }
private IServiceTestModelTO Eval(Guid resourceId, IDSFDataObject dataObject, IServiceTestModelTO test) { Dev2Logger.Debug("Getting Resource to Execute"); var resourceCatalog = ResourceCat ?? ResourceCatalog.Instance; IDev2Activity resource = resourceCatalog.Parse(TheWorkspace.ID, resourceId); Dev2JsonSerializer serializer = new Dev2JsonSerializer(); var execPlan = serializer.SerializeToBuilder(resource); var clonedExecPlan = serializer.Deserialize <IDev2Activity>(execPlan); Dev2Logger.Debug("Got Resource to Execute"); if (test != null) { var testPassed = true; var canExecute = true; var failureMessage = new StringBuilder(); if (ServerAuthorizationService.Instance != null) { var authorizationService = ServerAuthorizationService.Instance; var hasView = authorizationService.IsAuthorized(AuthorizationContext.View, DataObject.ResourceID.ToString()); var hasExecute = authorizationService.IsAuthorized(AuthorizationContext.Execute, DataObject.ResourceID.ToString()); canExecute = hasExecute && hasView; } if (!canExecute) { dataObject.Environment.AllErrors.Add("Unauthorized to execute this resource."); } else { if (!dataObject.StopExecution) { dataObject.ServiceTest = test; UpdateToPending(test.TestSteps); EvalInner(dataObject, clonedExecPlan, dataObject.ForEachUpdateValue, test.TestSteps); if (test.Outputs != null) { var dev2DecisionFactory = Dev2DecisionFactory.Instance(); var testRunResults = test.Outputs.SelectMany(output => GetTestRunResults(dataObject, output, dev2DecisionFactory)).ToList(); testPassed = testRunResults.All(result => result.RunTestResult == RunResult.TestPassed); if (!testPassed) { failureMessage = failureMessage.Append(string.Join("", testRunResults.Select(result => result.Message).Where(s => !string.IsNullOrEmpty(s)).ToList())); } } } } ValidateError(test, testPassed, failureMessage); test.FailureMessage = failureMessage.ToString(); return(test); } throw new Exception($"Test {dataObject.TestName} for Resource {dataObject.ServiceName} ID {resourceId}"); }
private static void UpdateDebugStateWithAssertion(IDSFDataObject dataObject, IServiceTestStep stepToBeAsserted, IDebugState debugState) { if (debugState != null) { var factory = Dev2DecisionFactory.Instance(); var res = stepToBeAsserted.StepOutputs.SelectMany(output => GetTestRunResults(dataObject, output, factory, debugState)); var testRunResults = res as IList <TestRunResult> ?? res.ToList(); var testPassed = testRunResults.All(result => result.RunTestResult == RunResult.TestPassed || result.RunTestResult == RunResult.None); var serviceTestFailureMessage = string.Join("", testRunResults.Select(result => result.Message)); UpdateBasedOnFinalResult(dataObject, stepToBeAsserted, testPassed, testRunResults, serviceTestFailureMessage); } }
static void GetTestResults(IDSFDataObject dataObject, IServiceTestModelTO test, ref bool testPassed, ref StringBuilder failureMessage) { if (test.Outputs is null) { return; } var dev2DecisionFactory = Dev2DecisionFactory.Instance(); var testRunResults = test.Outputs.SelectMany(output => GetTestRunResults(dataObject, output, dev2DecisionFactory)).ToList(); testPassed = testRunResults.All(result => result.RunTestResult == RunResult.TestPassed); if (!testPassed) { failureMessage = failureMessage.Append(string.Join("", testRunResults.Select(result => result.Message).Where(s => !string.IsNullOrEmpty(s)).ToList())); } }
public bool ExecuteDecisionStack(string decisionDataPayload, IList <string> oldAmbientData, int update) { var dlId = FetchDataListID(oldAmbientData); var newDecisionData = Dev2DecisionStack.FromVBPersitableModelToJSON(decisionDataPayload); var dds = EvaluateRegion(newDecisionData, dlId, update); var env = Dev2DataListDecisionHandler._environments[dlId]; if (dds != null) { if (dlId != GlobalConstants.NullDataListID) { try { if (dds.TheStack != null) { for (int i = 0; i < dds.TotalDecisions; i++) { var dd = dds.GetModelItem(i); var typeOf = dd.EvaluationFn; // Treat Errors special if (typeOf == enDecisionType.IsError || typeOf == enDecisionType.IsNotError) { dd.Col1 = env.FetchErrors(); } var op = Dev2DecisionFactory.Instance().FetchDecisionFunction(typeOf); if (op != null) { try { var result = op.Invoke(dds.GetModelItem(i).FetchColsAsArray()); if (!result && dds.Mode == Dev2DecisionMode.AND) { // Naughty stuff, we have a false in AND mode... break return(false); } if (result && dds.Mode == Dev2DecisionMode.OR) { return(true); } } catch (Exception e) { // An error, push into the DL env.AddError(e.Message); return(false); } } else { throw new InvalidExpressionException(string.Format(ErrorResource.CouldNotEvaluateDecisionData, typeOf)); } } // else we are in AND mode and all have passed ;) if (dds.Mode == Dev2DecisionMode.AND) { return(true); } //finally, it must be OR mode with no matches ;( return(false); } throw new InvalidExpressionException(ErrorResource.InvalidModelDataSent); } catch { // all hell has broken loose... ;) throw new InvalidExpressionException(ErrorResource.NoModelDataSent); } } throw new InvalidExpressionException(ErrorResource.NoDataListIDsent); } throw new InvalidExpressionException(ErrorResource.DataListErrors); }
public override IDev2Activity Execute(IDSFDataObject dataObject, int update) { ErrorResultTO allErrors = new ErrorResultTO(); try { InitializeDebug(dataObject); if (dataObject.IsDebugMode()) { _debugInputs = CreateDebugInputs(dataObject.Environment); DispatchDebugState(dataObject, StateType.Before, 0); } var stack = Conditions.TheStack.Select(a => ParseDecision(dataObject.Environment, a)); var factory = Dev2DecisionFactory.Instance(); var res = stack.SelectMany(a => { if (a.EvaluationFn == enDecisionType.IsError) { return(new[] { dataObject.Environment.AllErrors.Count > 0 }); } if (a.EvaluationFn == enDecisionType.IsNotError) { return(new[] { dataObject.Environment.AllErrors.Count == 0 }); } IList <bool> ret = new List <bool>(); var iter = new WarewolfListIterator(); var c1 = new WarewolfAtomIterator(a.Cols1); var c2 = new WarewolfAtomIterator(a.Cols2); var c3 = new WarewolfAtomIterator(a.Cols3); iter.AddVariableToIterateOn(c1); iter.AddVariableToIterateOn(c2); iter.AddVariableToIterateOn(c3); while (iter.HasMoreData()) { ret.Add(factory.FetchDecisionFunction(a.EvaluationFn).Invoke(new[] { iter.FetchNextValue(c1), iter.FetchNextValue(c2), iter.FetchNextValue(c3) })); } return(ret); }); var resultval = And ? res.Aggregate(true, (a, b) => a && b) : res.Any(a => a); if (dataObject.IsDebugMode()) { _debugOutputs = GetDebugOutputs(resultval.ToString()); } if (resultval) { if (TrueArm != null) { var activity = TrueArm.FirstOrDefault(); return(activity); } } else { if (FalseArm != null) { var activity = FalseArm.FirstOrDefault(); return(activity); } } } catch (Exception e) { allErrors.AddError(e.Message); } finally { // Handle Errors var hasErrors = allErrors.HasErrors(); if (hasErrors) { DisplayAndWriteError("DsfDeleteRecordsActivity", allErrors); var errorString = allErrors.MakeDisplayReady(); dataObject.Environment.AddError(errorString); } } if (dataObject.IsDebugMode()) { _debugOutputs = new List <DebugItem>(); _debugOutputs = new List <DebugItem>(); DispatchDebugState(dataObject, StateType.Duration, update); } return(null); }
#pragma warning disable S1541 // Methods and properties should not be too complex #pragma warning disable S3776 // Cognitive Complexity of methods should not be too high IDev2Activity ExecuteDecision(IDSFDataObject dataObject) #pragma warning restore S3776 // Cognitive Complexity of methods should not be too high #pragma warning restore S1541 // Methods and properties should not be too complex { InitializeDebug(dataObject); if (dataObject.IsDebugMode()) { _debugInputs = CreateDebugInputs(dataObject.Environment); DispatchDebugState(dataObject, StateType.Before, 0); } var errorIfNull = !Conditions.TheStack.Any(decision => decision.EvaluationFn == enDecisionType.IsNull || decision.EvaluationFn == enDecisionType.IsNotNull); var stack = Conditions.TheStack.Select(a => ParseDecision(dataObject.Environment, a, errorIfNull)); var factory = Dev2DecisionFactory.Instance(); var res = stack.SelectMany(a => { if (a.EvaluationFn == enDecisionType.IsError) { return(new[] { dataObject.Environment.AllErrors.Count > 0 }); } if (a.EvaluationFn == enDecisionType.IsNotError) { return(new[] { dataObject.Environment.AllErrors.Count == 0 }); } IList <bool> ret = new List <bool>(); var iter = new WarewolfListIterator(); var c1 = new WarewolfAtomIterator(a.Cols1); var c2 = new WarewolfAtomIterator(a.Cols2); var c3 = new WarewolfAtomIterator(a.Cols3); iter.AddVariableToIterateOn(c1); iter.AddVariableToIterateOn(c2); iter.AddVariableToIterateOn(c3); while (iter.HasMoreData()) { try { ret.Add(factory.FetchDecisionFunction(a.EvaluationFn).Invoke(new[] { iter.FetchNextValue(c1), iter.FetchNextValue(c2), iter.FetchNextValue(c3) })); } catch (Exception) { if (errorIfNull) { throw; } ret.Add(false); } } return(ret); }); var results = res as IList <bool> ?? res.ToList(); var resultval = true; if (results.Any()) { if (And) { if (results.Any(b => !b)) { resultval = false; } } else { resultval = results.Any(b => b); } } Result = GetResultString(resultval.ToString(), Conditions); if (dataObject.IsDebugMode()) { _debugOutputs = GetDebugOutputs(resultval.ToString()); } if (resultval) { if (TrueArm != null) { var activity = TrueArm.FirstOrDefault(); return(activity); } } else { if (FalseArm != null) { var activity = FalseArm.FirstOrDefault(); return(activity); } } return(null); }
// Guid dlID /// <summary> /// Executes the decision stack. /// </summary> /// <param name="decisionDataPayload">The decision data payload.</param> /// <param name="oldAmbientData">The old ambient data.</param> /// <returns></returns> /// <exception cref="System.Data.InvalidExpressionException">Could not evaluate decision data - No decision function found for [ + typeOf + ]</exception> public bool ExecuteDecisionStack(string decisionDataPayload, IList <string> oldAmbientData) { Guid dlId = FetchDataListID(oldAmbientData); // if(dlId == GlobalConstants.NullDataListID) throw new InvalidExpressionException("Could not evaluate decision data - no DataList ID sent!"); string newDecisionData = Dev2DecisionStack.FromVBPersitableModelToJSON(decisionDataPayload); var dds = EvaluateRegion(newDecisionData, dlId); var env = _environments[dlId]; if (dds != null) { if (dlId != GlobalConstants.NullDataListID) { try { if (dds.TheStack != null) { for (int i = 0; i < dds.TotalDecisions; i++) { Dev2Decision dd = dds.GetModelItem(i); enDecisionType typeOf = dd.EvaluationFn; // Treat Errors special if (typeOf == enDecisionType.IsError || typeOf == enDecisionType.IsNotError) { dd.Col1 = String.Join("", env.Errors); } IDecisionOperation op = Dev2DecisionFactory.Instance().FetchDecisionFunction(typeOf); if (op != null) { try { bool result = op.Invoke(dds.GetModelItem(i).FetchColsAsArray()); if (!result && dds.Mode == Dev2DecisionMode.AND) { // Naughty stuff, we have a false in AND mode... break return(false); } if (result && dds.Mode == Dev2DecisionMode.OR) { return(true); } } catch (Exception e) { // An error, push into the DL env.AddError(e.Message); return(false); } } else { throw new InvalidExpressionException("Could not evaluate decision data - No decision function found for [ " + typeOf + " ]"); } } // else we are in AND mode and all have passed ;) if (dds.Mode == Dev2DecisionMode.AND) { return(true); } //finally, it must be OR mode with no matches ;( return(false); } throw new InvalidExpressionException("Could not evaluate decision data - Invalid model data sent!"); } catch { // all hell has broken loose... ;) throw new InvalidExpressionException("Could not evaluate decision data - No model data sent!"); } } throw new InvalidExpressionException("Could not evaluate decision data - no DataList ID sent!"); } throw new InvalidExpressionException("Could not populate decision model - DataList Errors!"); }
// Guid dlID /// <summary> /// Executes the decision stack. /// </summary> /// <param name="decisionDataPayload">The decision data payload.</param> /// <param name="oldAmbientData">The old ambient data.</param> /// <returns></returns> /// <exception cref="System.Data.InvalidExpressionException">Could not evaluate decision data - No decision function found for [ + typeOf + ]</exception> public bool ExecuteDecisionStack(string decisionDataPayload, IList <string> oldAmbientData) { // Evaluate decisionDataPayload through the EvaluateFunction ;) Guid dlId = FetchDataListID(oldAmbientData); if (dlId == GlobalConstants.NullDataListID) { throw new InvalidExpressionException("Could not evaluate decision data - no DataList ID sent!"); } // Swap out ! with a new internal token to avoid nasty issues with string newDecisionData = Dev2DecisionStack.FromVBPersitableModelToJSON(decisionDataPayload); var dds = EvaluateRegion(newDecisionData, dlId); ErrorResultTO errors = new ErrorResultTO(); if (dds != null) { if (dlId != GlobalConstants.NullDataListID) { try { if (dds.TheStack != null) { for (int i = 0; i < dds.TotalDecisions; i++) { Dev2Decision dd = dds.GetModelItem(i); enDecisionType typeOf = dd.EvaluationFn; // Treat Errors special if (typeOf == enDecisionType.IsError || typeOf == enDecisionType.IsNotError) { dd.Col1 = Compiler.EvaluateSystemEntry(dlId, enSystemTag.Dev2Error, out errors); } IDecisionOperation op = Dev2DecisionFactory.Instance().FetchDecisionFunction(typeOf); if (op != null) { try { bool result = op.Invoke(dds.GetModelItem(i).FetchColsAsArray()); if (!result && dds.Mode == Dev2DecisionMode.AND) { // Naughty stuff, we have a false in AND mode... break return(false); } if (result && dds.Mode == Dev2DecisionMode.OR) { return(true); } } catch (Exception e) { // An error, push into the DL ErrorResultTO errorErrors; errors.AddError(e.Message); Compiler.UpsertSystemTag(dlId, enSystemTag.Dev2Error, errors.MakeDataListReady(), out errorErrors); return(false); } } else { throw new InvalidExpressionException("Could not evaluate decision data - No decision function found for [ " + typeOf + " ]"); } } // else we are in AND mode and all have passed ;) if (dds.Mode == Dev2DecisionMode.AND) { return(true); } //finally, it must be OR mode with no matches ;( return(false); } throw new InvalidExpressionException("Could not evaluate decision data - Invalid model data sent!"); } catch { // all hell has broken loose... ;) throw new InvalidExpressionException("Could not evaluate decision data - No model data sent!"); } } throw new InvalidExpressionException("Could not evaluate decision data - no DataList ID sent!"); } throw new InvalidExpressionException("Could not populate decision model - DataList Errors!"); }
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); }
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); }