static void AddDebugItem(TestRunResult testRunResult, IDebugState debugState)
{
var msg = testRunResult.Message;
if (testRunResult.RunTestResult == RunResult.TestPassed)
{
msg = Messages.Test_PassedResult;
}
var hasError = testRunResult.RunTestResult == RunResult.TestFailed;
var debugItemStaticDataParams = new DebugItemServiceTestStaticDataParams(msg, hasError);
var itemToAdd = new DebugItem();
itemToAdd.AddRange(debugItemStaticDataParams.GetDebugItemResult());
if (debugState.AssertResultList != null)
{
var addItem = debugState.AssertResultList.Select(debugItem => debugItem.ResultsList.Where(debugItemResult => debugItemResult.Value == Messages.Test_PassedResult)).All(debugItemResults => !debugItemResults.Any());
if (addItem)
{
debugState.AssertResultList.Add(itemToAdd);
}
}
}
private void HandleDebug(IDSFDataObject dataObject, IServiceTestStep serviceTestStep)
{
if (dataObject.IsDebugMode())
{
if (dataObject.IsServiceTestExecution && serviceTestStep != null)
{
var debugItems = TestDebugMessageRepo.Instance.GetDebugItems(dataObject.ResourceID, dataObject.TestName);
debugItems = debugItems.Where(state => state.WorkSurfaceMappingId == serviceTestStep.ActivityID).ToList();
var debugStates = debugItems.LastOrDefault();
var debugItemStaticDataParams = new DebugItemServiceTestStaticDataParams(serviceTestStep.Result.Message, serviceTestStep.Result.RunTestResult == RunResult.TestFailed);
var itemToAdd = new DebugItem();
itemToAdd.AddRange(debugItemStaticDataParams.GetDebugItemResult());
debugStates?.AssertResultList?.Add(itemToAdd);
}
DispatchDebugState(dataObject, StateType.Duration, 0);
}
}
void GetTestOurputResultForDebug(IDSFDataObject dataObject)
{
var serviceTestStep = dataObject.ServiceTest?.TestSteps?.Flatten(step => step.Children)?.FirstOrDefault(step => step.ActivityID == _originalUniqueID);
var serviceTestSteps = serviceTestStep?.Children;
UpdateDebugStateWithAssertions(dataObject, serviceTestSteps?.ToList());
if (serviceTestStep != null)
{
var testRunResult = new TestRunResult();
GetFinalTestRunResult(serviceTestStep, testRunResult, dataObject);
serviceTestStep.Result = testRunResult;
var debugItems = TestDebugMessageRepo.Instance.GetDebugItems(dataObject.ResourceID, dataObject.TestName);
debugItems = debugItems.Where(state => state.WorkSurfaceMappingId == serviceTestStep.ActivityID).ToList();
var debugStates = debugItems.LastOrDefault();
var debugItemStaticDataParams = new DebugItemServiceTestStaticDataParams(serviceTestStep.Result.Message, serviceTestStep.Result.RunTestResult == RunResult.TestFailed);
var itemToAdd = new DebugItem();
itemToAdd.AddRange(debugItemStaticDataParams.GetDebugItemResult());
debugStates?.AssertResultList?.Add(itemToAdd);
}
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
_previousParentId = dataObject.ParentInstanceID;
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
ErrorResultTO allErrors = new ErrorResultTO();
IIndexIterator itr = null;
InitializeDebug(dataObject);
dataObject.ForEachNestingLevel++;
try
{
ErrorResultTO errors;
ForEachBootstrapTO exePayload = FetchExecutionType(dataObject, dataObject.Environment, out errors, update);
foreach (var err in errors.FetchErrors())
{
dataObject.Environment.AddError(err);
}
itr = exePayload.IndexIterator;
string error;
ForEachInnerActivityTO innerA = GetInnerActivity(out error);
var exeAct = innerA?.InnerActivity;
allErrors.AddError(error);
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before, update);
}
dataObject.ParentInstanceID = UniqueID;
dataObject.IsDebugNested = true;
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.After, update);
}
exePayload.InnerActivity = innerA;
while (itr?.HasMore() ?? false)
{
operationalData = exePayload;
int idx = exePayload.IndexIterator.FetchNextIndex();
int innerupdate = 0;
if (exePayload.ForEachType != enForEachType.NumOfExecution)
{
innerupdate = idx;
}
_childUniqueID = exeAct?.UniqueID;
exeAct?.Execute(dataObject, innerupdate);
operationalData.IncIterationCount();
}
if (errors.HasErrors())
{
allErrors.MergeErrors(errors);
}
}
catch (Exception e)
{
Dev2Logger.Error("DSFForEach", e);
allErrors.AddError(e.Message);
}
finally
{
if (itr != null)
{
if (ForEachType != enForEachType.NumOfExecution)
{
RestoreHandlerFn();
}
}
var serviceTestStep = dataObject.ServiceTest?.TestSteps?.Flatten(step => step.Children)?.FirstOrDefault(step => step.UniqueId == _originalUniqueID);
if (dataObject.IsServiceTestExecution)
{
var serviceTestSteps = serviceTestStep?.Children;
UpdateDebugStateWithAssertions(dataObject, serviceTestSteps?.ToList());
if (serviceTestStep != null)
{
var testRunResult = new TestRunResult();
GetFinalTestRunResult(serviceTestStep, testRunResult);
serviceTestStep.Result = testRunResult;
}
}
dataObject.ParentInstanceID = _previousParentId;
dataObject.ForEachNestingLevel--;
dataObject.IsDebugNested = false;
if (dataObject.IsDebugMode())
{
if (dataObject.IsServiceTestExecution && serviceTestStep != null)
{
var debugItems = TestDebugMessageRepo.Instance.GetDebugItems(dataObject.ResourceID, dataObject.TestName);
debugItems = debugItems.Where(state => state.WorkSurfaceMappingId == serviceTestStep.UniqueId).ToList();
var debugStates = debugItems.LastOrDefault();
var debugItemStaticDataParams = new DebugItemServiceTestStaticDataParams(serviceTestStep.Result.Message, serviceTestStep.Result.RunTestResult == RunResult.TestFailed);
DebugItem itemToAdd = new DebugItem();
itemToAdd.AddRange(debugItemStaticDataParams.GetDebugItemResult());
debugStates?.AssertResultList?.Add(itemToAdd);
}
DispatchDebugState(dataObject, StateType.Duration, 0);
}
// Handle Errors
if (allErrors.HasErrors())
{
dataObject.ParentInstanceID = _previousParentId;
dataObject.ForEachNestingLevel--;
dataObject.IsDebugNested = false;
// Handle Errors
if (allErrors.HasErrors())
{
DisplayAndWriteError("DsfForEachActivity", allErrors);
foreach (var fetchError in allErrors.FetchErrors())
{
dataObject.Environment.AddError(fetchError);
}
dataObject.ParentInstanceID = _previousParentId;
}
}
}
}
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);
}
protected override void ChildDebugStateDispatch(IDSFDataObject dataObject)
{
if (dataObject.IsDebugMode())
{
foreach (var debugState in _childStatesToDispatch)
{
DispatchDebugState(debugState, dataObject);
if (dataObject.IsServiceTestExecution)
{
var serviceTestStep = dataObject.ServiceTest?.TestSteps?.Flatten(step => step.Children)?.FirstOrDefault(step => step.UniqueId == Guid.Parse(UniqueID));
var serviceTestSteps = serviceTestStep?.Children;
dataObject.ResourceID = debugState.SourceResourceID;
UpdateDebugWithAssertions(dataObject, serviceTestSteps?.ToList(), debugState.ID);
}
}
}
if (dataObject.IsServiceTestExecution)
{
var serviceTestStep = dataObject.ServiceTest?.TestSteps?.Flatten(step => step.Children)?.FirstOrDefault(step => step.UniqueId == Guid.Parse(UniqueID));
if (serviceTestStep != null)
{
if (!dataObject.IsDebugMode())
{
var serviceTestSteps = serviceTestStep.Children;
foreach (var serviceTestTestStep in serviceTestSteps)
{
UpdateForRegularActivity(dataObject, serviceTestTestStep);
}
}
var testRunResult = new TestRunResult();
GetFinalTestRunResult(serviceTestStep, testRunResult);
serviceTestStep.Result = testRunResult;
if (dataObject.IsDebugMode())
{
var states = TestDebugMessageRepo.Instance.GetDebugItems(dataObject.ResourceID, dataObject.TestName);
if (states != null)
{
states = states.Where(state => state.ID == Guid.Parse(UniqueID)).ToList();
var debugState = states.FirstOrDefault();
if (debugState != null)
{
var msg = testRunResult.Message;
if (testRunResult.RunTestResult == RunResult.TestPassed)
{
msg = Messages.Test_PassedResult;
}
var hasError = testRunResult.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);
}
}
}
}
}
}
}
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
ErrorResultTO allErrors = new ErrorResultTO();
InitializeDebug(dataObject);
if (string.IsNullOrEmpty(DataSource))
{
allErrors.AddError(ErrorResource.DataSourceEmpty);
}
if (string.IsNullOrEmpty(Alias))
{
allErrors.AddError(string.Format(ErrorResource.CanNotBeEmpty, "Alias"));
}
if (allErrors.HasErrors())
{
DisplayAndWriteError("DsfSelectAndApplyActivity", allErrors);
foreach (var fetchError in allErrors.FetchErrors())
{
dataObject.Environment.AddError(fetchError);
}
}
var startTime = DateTime.Now;
_previousParentId = dataObject.ParentInstanceID;
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
dataObject.ForEachNestingLevel++;
List <string> expressions = new List <string>();
try
{
string ds;
try
{
ds = dataObject.Environment.ToStar(DataSource);
expressions = dataObject.Environment.GetIndexes(ds);
if (expressions.Count == 0)
{
expressions.Add(ds);
}
}
catch (NullReferenceException)
{
//Do nothing exception aleady added to errors
throw new NullDataSource();
}
if (dataObject.IsDebugMode())
{
AddDebugInputItem(new DebugItemStaticDataParams(Alias, "As", DataSource));
}
var scopedEnvironment = new ScopedEnvironment(dataObject.Environment, ds, Alias);
//Push the new environment
dataObject.PushEnvironment(scopedEnvironment);
dataObject.ForEachNestingLevel++;
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before, update);
}
dataObject.ParentInstanceID = UniqueID;
dataObject.IsDebugNested = true;
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.After, update);
}
foreach (var exp in expressions)
{
//Assign the warewolfAtom to Alias using new environment
scopedEnvironment.SetDataSource(exp);
var exeAct = ApplyActivityFunc.Handler as IDev2Activity;
if (exeAct != null)
{
_childUniqueID = exeAct.UniqueID;
exeAct.Execute(dataObject, 0);
}
}
}
catch (NullDataSource e)
{
Dev2Logger.Error("DSFSelectAndApply", e);
}
catch (Exception e)
{
Dev2Logger.Error("DSFSelectAndApply", e);
allErrors.AddError(e.Message);
}
finally
{
if (dataObject.IsDebugMode())
{
if (dataObject.IsServiceTestExecution)
{
var serviceTestStep = dataObject.ServiceTest?.TestSteps?.Flatten(step => step.Children)?.FirstOrDefault(step => step.UniqueId == _originalUniqueID);
var serviceTestSteps = serviceTestStep?.Children;
UpdateDebugStateWithAssertions(dataObject, serviceTestSteps?.ToList());
if (serviceTestStep != null)
{
var testRunResult = new TestRunResult();
GetFinalTestRunResult(serviceTestStep, testRunResult, dataObject);
serviceTestStep.Result = testRunResult;
var debugItems = TestDebugMessageRepo.Instance.GetDebugItems(dataObject.ResourceID, dataObject.TestName);
debugItems = debugItems.Where(state => state.WorkSurfaceMappingId == serviceTestStep.UniqueId).ToList();
var debugStates = debugItems.LastOrDefault();
var debugItemStaticDataParams = new DebugItemServiceTestStaticDataParams(serviceTestStep.Result.Message, serviceTestStep.Result.RunTestResult == RunResult.TestFailed);
DebugItem itemToAdd = new DebugItem();
itemToAdd.AddRange(debugItemStaticDataParams.GetDebugItemResult());
debugStates?.AssertResultList?.Add(itemToAdd);
}
}
}
dataObject.PopEnvironment();
dataObject.ForEachNestingLevel--;
if (allErrors.HasErrors())
{
if (allErrors.HasErrors())
{
DisplayAndWriteError("DsfSelectAndApplyActivity", allErrors);
foreach (var fetchError in allErrors.FetchErrors())
{
dataObject.Environment.AddError(fetchError);
}
}
}
if (dataObject.IsDebugMode())
{
foreach (var expression in expressions)
{
var data = dataObject.Environment.Eval(expression, update);
if (data.IsWarewolfAtomListresult)
{
var lst = data as CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult;
AddDebugOutputItem(new DebugItemWarewolfAtomListResult(lst, "", "", expression, "", "", "="));
}
else
{
if (data.IsWarewolfAtomResult)
{
var atom = data as CommonFunctions.WarewolfEvalResult.WarewolfAtomResult;
if (atom != null)
{
AddDebugOutputItem(new DebugItemWarewolfAtomResult(atom.Item.ToString(), expression, ""));
}
}
}
}
DispatchDebugState(dataObject, StateType.End, update, startTime, DateTime.Now);
}
OnCompleted(dataObject);
}
}
