private void UpdateTestStep(IDSFDataObject dataObject, IServiceTestStep serviceTestStep)
{
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)
{
AddDebugItem(testRunResult, debugState);
}
}
}
}
private void RunTestStep(IServiceTestModel selectedServiceTest, IServiceTestStep resTestStep)
{
var serviceTestSteps = selectedServiceTest.TestSteps.Where(testStep => testStep.UniqueId == resTestStep.UniqueId).ToList();
foreach (var serviceTestStep in serviceTestSteps)
{
var resServiceTestStep = serviceTestStep as ServiceTestStep;
if (resServiceTestStep == null)
{
continue;
}
UpdateTestStepResult(resServiceTestStep, resTestStep);
var serviceTestOutputs = resTestStep.StepOutputs;
if (serviceTestOutputs.Count > 0)
{
resServiceTestStep.StepOutputs = CreateServiceTestOutputFromResult(resTestStep.StepOutputs, resServiceTestStep);
}
var children = resTestStep.Children;
if (children.Count > 0)
{
SetChildrenTestResult(children, resServiceTestStep.Children);
}
}
}
private static void UpdateStepOutputsForTest(IServiceTestStep serviceTestStep)
{
if (serviceTestStep.Children != null)
{
var childs = serviceTestStep.Children.Flatten(step => step.Children);
foreach (var child in childs)
{
child.Result = new TestRunResult {
RunTestResult = RunResult.TestInvalid
};
foreach (var serviceTestOutput in child.StepOutputs)
{
serviceTestOutput.Result = new TestRunResult {
RunTestResult = RunResult.TestInvalid
};
}
}
}
serviceTestStep.Result = new TestRunResult {
RunTestResult = RunResult.TestInvalid
};
foreach (var serviceTestOutput in serviceTestStep.StepOutputs)
{
serviceTestOutput.Result = new TestRunResult {
RunTestResult = RunResult.TestInvalid
};
}
}
static IDev2Activity ReplaceActivityWithMock(IDev2Activity resource, IServiceTestStep foundTestStep)
{
IDev2Activity overriddenActivity = null;
if (foundTestStep.ActivityType == typeof(DsfDecision).Name)
{
var serviceTestOutput = foundTestStep.StepOutputs.FirstOrDefault(output => output.Variable == GlobalConstants.ArmResultText);
if (serviceTestOutput != null)
{
overriddenActivity = new TestMockDecisionStep(resource.As <DsfDecision>())
{
NameOfArmToReturn = serviceTestOutput.Value
};
}
}
else if (foundTestStep.ActivityType == typeof(DsfSwitch).Name)
{
var serviceTestOutput = foundTestStep.StepOutputs.FirstOrDefault(output => output.Variable == GlobalConstants.ArmResultText);
if (serviceTestOutput != null)
{
overriddenActivity = new TestMockSwitchStep(resource.As <DsfSwitch>())
{
ConditionToUse = serviceTestOutput.Value
};
}
}
else
{
overriddenActivity = new TestMockStep(resource, foundTestStep.StepOutputs.ToList());
}
return(overriddenActivity);
}
static void GetStepOutputResults(IDSFDataObject dataObject, IServiceTestStep stepToBeAsserted)
{
if (stepToBeAsserted?.StepOutputs != null && stepToBeAsserted.StepOutputs.Count > 0)
{
if (stepToBeAsserted.Result != null)
{
stepToBeAsserted.Result.RunTestResult = RunResult.TestInvalid;
}
else
{
stepToBeAsserted.Result = new TestRunResult {
RunTestResult = RunResult.TestInvalid
};
}
var states = TestDebugMessageRepo.Instance.GetDebugItems(dataObject.ResourceID, dataObject.TestName);
if (states != null)
{
states = states.Where(state =>
{
var idToUse = state.ID;
if (state?.ActualType == "DsfActivity")
{
idToUse = state.WorkSurfaceMappingId;
}
return(idToUse == stepToBeAsserted.ActivityID);
}
).ToList();
var debugState = states.LastOrDefault();
UpdateDebugStateWithAssertion(dataObject, stepToBeAsserted, debugState);
}
}
}
private void MockMethodExecution(IDSFDataObject dataObject, IServiceTestStep serviceTestStep, IDev2MethodInfo dev2MethodInfo, int index)
{
if (serviceTestStep.StepOutputs != null)
{
foreach (var serviceTestOutput in serviceTestStep.StepOutputs)
{
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);
}
}
}
void MockMethodExecution(IDSFDataObject dataObject, IServiceTestStep serviceTestStep, IDev2MethodInfo dev2MethodInfo, int index)
{
if (serviceTestStep.StepOutputs != null)
{
foreach (var serviceTestOutput in serviceTestStep.StepOutputs)
{
DispatchDebugState(dataObject, dev2MethodInfo, index, serviceTestOutput);
}
}
}
public static IWorkflowNode ToWorkflowNode(this IServiceTestStep step)
{
return(new WorkflowNode
{
ActivityID = step.ActivityID != Guid.Empty ? step.ActivityID : step.UniqueID,
UniqueID = step.UniqueID,
StepDescription = step.StepDescription,
MockSelected = step.MockSelected,
ChildNodes = step.Children?.Select(o => ToWorkflowNode(o)).ToList() ?? new List <IWorkflowNode>()
});
}
static void UpdateTestStepResult(ServiceTestStep resServiceTestStep, IServiceTestStep resTestStep)
{
resServiceTestStep.Result = resTestStep.Result;
if (resServiceTestStep.MockSelected)
{
resServiceTestStep.TestPending = false;
resServiceTestStep.TestPassed = false;
resServiceTestStep.TestFailing = false;
resServiceTestStep.TestInvalid = false;
}
}
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 RecursivelyMockRecursiveActivities(IDev2Activity activity, IServiceTestStep foundTestStep)
{
if (foundTestStep.ActivityType == typeof(DsfSequenceActivity).Name)
{
if (activity is DsfSequenceActivity sequenceActivity)
{
RecursivelyMockChildrenOfASequence(foundTestStep, sequenceActivity);
}
}
else if (foundTestStep.ActivityType == typeof(DsfForEachActivity).Name && activity is DsfForEachActivity forEach && foundTestStep.Children != null)
{
var replacement = MockActivityIfNecessary(forEach.DataFunc.Handler as IDev2Activity, foundTestStep.Children.ToList()) as Activity;
forEach.DataFunc.Handler = replacement;
}
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);
}
}
private static void GetFinalTestRunResult(IServiceTestStep serviceTestStep, TestRunResult testRunResult)
{
var nonPassingSteps = serviceTestStep.Children?.Where(step => step.Type != StepType.Mock && step.Result?.RunTestResult != RunResult.TestPassed).ToList();
if (nonPassingSteps != null && nonPassingSteps.Count == 0)
{
testRunResult.Message = Messages.Test_PassedResult;
testRunResult.RunTestResult = RunResult.TestPassed;
}
else
{
if (nonPassingSteps != null)
{
var failMessage = string.Join(Environment.NewLine, nonPassingSteps.Select(step => step.Result.Message));
testRunResult.Message = failMessage;
}
testRunResult.RunTestResult = RunResult.TestFailed;
}
}
static void GetFinalTestRunResult(IServiceTestStep serviceTestStep, TestRunResult testRunResult)
{
var resultList = new ObservableCollection <TestRunResult>();
foreach (var testStep in serviceTestStep.Children)
{
if (testStep.Result != null)
{
resultList.Add(testStep.Result);
}
}
if (resultList.Count == 0)
{
testRunResult.RunTestResult = RunResult.TestPassed;
}
else
{
testRunResult.RunTestResult = RunResult.TestInvalid;
var testRunResults = resultList.Where(runResult => runResult.RunTestResult == RunResult.TestInvalid).ToList();
if (testRunResults.Count > 0)
{
testRunResult.Message = string.Join(Environment.NewLine, testRunResults.Select(result => result.Message));
testRunResult.RunTestResult = RunResult.TestInvalid;
}
else
{
var failed = resultList.Any(runResult => runResult.RunTestResult == RunResult.TestFailed);
if (failed)
{
testRunResult.Message = string.Join(Environment.NewLine, testRunResults.Select(result => result.Message));
testRunResult.RunTestResult = RunResult.TestFailed;
}
else
{
testRunResult.Message = Messages.Test_PassedResult;
testRunResult.RunTestResult = RunResult.TestPassed;
}
}
}
}
static void MockConstructorExecution(IDSFDataObject dataObject, IServiceTestStep serviceTestStep, ref PluginExecutionDto pluginExecutionDto)
{
if (!string.IsNullOrEmpty(serviceTestStep.StepOutputs?[0].Variable))
{
try
{
var languageExpression = EvaluationFunctions.parseLanguageExpression(serviceTestStep.StepOutputs?[0].Variable, 0);
if (languageExpression.IsJsonIdentifierExpression)
{
var jToken = JToken.Parse(serviceTestStep.StepOutputs?[0].Value) as JContainer ?? serviceTestStep.StepOutputs?[0].Value.DeserializeToObject();
dataObject.Environment.AddToJsonObjects(serviceTestStep.StepOutputs[0].Variable, jToken);
pluginExecutionDto.ObjectString = serviceTestStep.StepOutputs[0].Value;
}
}
catch (Exception e)
{
dataObject.Environment.Errors.Add(e.Message);
}
}
}
void GetFinalTestRunResult(IServiceTestStep serviceTestStep, TestRunResult testRunResult, IDSFDataObject dataObject)
{
RegularActivityAssertion(dataObject, serviceTestStep);
var nonPassingSteps = serviceTestStep.Children?.Where(step => step.Result?.RunTestResult != RunResult.TestPassed).ToList();
if (nonPassingSteps != null && nonPassingSteps.Count == 0)
{
testRunResult.Message = Messages.Test_PassedResult;
testRunResult.RunTestResult = RunResult.TestPassed;
}
else
{
if (nonPassingSteps != null)
{
var failMessage = string.Join(Environment.NewLine, nonPassingSteps.Select(step => step.Result.Message));
testRunResult.Message = failMessage;
}
testRunResult.RunTestResult = RunResult.TestFailed;
}
}
public static void UpdateBasedOnFinalResult(IDSFDataObject dataObject, IServiceTestStep stepToBeAsserted, bool testPassed, IList <TestRunResult> testRunResults, string serviceTestFailureMessage)
{
var finalResult = new TestRunResult();
if (testPassed)
{
finalResult.RunTestResult = RunResult.TestPassed;
}
if (testRunResults.Any(result => result.RunTestResult == RunResult.TestFailed))
{
finalResult.RunTestResult = RunResult.TestFailed;
finalResult.Message = serviceTestFailureMessage;
}
if (testRunResults.Any(result => result.RunTestResult == RunResult.TestInvalid))
{
finalResult.RunTestResult = RunResult.TestInvalid;
finalResult.Message = serviceTestFailureMessage;
}
stepToBeAsserted.Result = finalResult;
dataObject.StopExecution = !testPassed;
}
void UpdateToPending(IServiceTestStep serviceTestStep)
{
if (serviceTestStep is null)
{
return;
}
if (serviceTestStep.Result != null)
{
serviceTestStep.Result.RunTestResult = RunResult.TestPending;
}
else
{
serviceTestStep.Result = new TestRunResult {
RunTestResult = RunResult.TestPending
};
}
UpdateToPending(serviceTestStep.StepOutputs);
if (serviceTestStep.Children != null && serviceTestStep.Children.Count > 0)
{
UpdateToPending(serviceTestStep.Children);
}
}
private static void GetStepOutputResults(IDSFDataObject dataObject, IServiceTestStep stepToBeAsserted)
{
if (stepToBeAsserted?.StepOutputs != null && stepToBeAsserted.StepOutputs.Count > 0)
{
if (stepToBeAsserted.Result != null)
{
stepToBeAsserted.Result.RunTestResult = RunResult.TestInvalid;
}
else
{
stepToBeAsserted.Result = new TestRunResult {
RunTestResult = RunResult.TestInvalid
};
}
var states = TestDebugMessageRepo.Instance.GetDebugItems(dataObject.ResourceID, dataObject.TestName);
if (states != null)
{
states = states.Where(state => state.ID == stepToBeAsserted.UniqueId).ToList();
var debugState = states.LastOrDefault();
UpdateDebugStateWithAssertion(dataObject, stepToBeAsserted, debugState);
}
}
}
private void RunTestStep(IServiceTestModel selectedServiceTest, IServiceTestStep resTestStep)
{
var serviceTestSteps = selectedServiceTest
.TestSteps
.Select(o => o.As <ServiceTestStep>())
.Where(testStep => testStep != null && testStep.ActivityID == resTestStep.ActivityID)
.ToList();
foreach (var resServiceTestStep in serviceTestSteps)
{
UpdateTestStepResult(resServiceTestStep, resTestStep);
var serviceTestOutputs = resTestStep.StepOutputs;
if (serviceTestOutputs.Count > 0)
{
resServiceTestStep.StepOutputs = CreateServiceTestOutputFromResult(resTestStep.StepOutputs, resServiceTestStep);
}
var children = resTestStep.Children;
if (children.Count > 0)
{
SetChildrenTestResult(children, resServiceTestStep.Children);
}
}
}
private void MethodExecution(int update, IDSFDataObject dataObject, PluginExecutionDto pluginExecutionDto, Isolated <PluginRuntimeHandler> appDomain, int index, IDev2MethodInfo dev2MethodInfo, IServiceTestStep serviceTestStep)
{
if (serviceTestStep != null)
{
if (serviceTestStep.Type == StepType.Mock)
{
MockMethodExecution(dataObject, serviceTestStep, dev2MethodInfo, index);
}
else
{
RegularMethodExecution(appDomain, pluginExecutionDto, dev2MethodInfo, index, update, dataObject);
}
}
else
{
RegularMethodExecution(appDomain, pluginExecutionDto, dev2MethodInfo, index, update, dataObject);
}
}
