static void UpdateOutputsForTest(IServiceTestModelTO serviceTestModelTO, IList <IDev2Definition> outputDefs)
{
if (outputDefs.Count == 0)
{
serviceTestModelTO.Outputs = new List <IServiceTestOutput>();
}
else
{
if (serviceTestModelTO.Outputs == null)
{
serviceTestModelTO.Outputs = new List <IServiceTestOutput>();
}
foreach (var dev2Definition in outputDefs)
{
serviceTestModelTO = UpdateOutputsForTest(serviceTestModelTO, dev2Definition);
}
for (int i = serviceTestModelTO.Outputs.Count - 1; i >= 0; i--)
{
serviceTestModelTO = UpdateOutputsForTest(serviceTestModelTO, outputDefs, i);
}
foreach (var serviceTestOutput in serviceTestModelTO.Outputs)
{
serviceTestOutput.Result = new TestRunResult {
RunTestResult = RunResult.TestInvalid
};
}
serviceTestModelTO.Outputs.Sort((output, testOutput) => string.Compare(output.Variable, testOutput.Variable, StringComparison.InvariantCultureIgnoreCase));
}
}
public static void Execute(GetTestStepsAndOutputs getTestStepsAndOutputs, IServiceTestModelTO test, out StringBuilder failureMessage)
{
_testStatus = getTestStepsAndOutputs;
failureMessage = new StringBuilder();
if (HasFailingSteps)
{
foreach (var serviceTestStep in _testStatus.FailingTestSteps)
{
failureMessage.AppendLine("Failed Step: " + serviceTestStep.StepDescription + " ");
failureMessage.AppendLine("Message: " + serviceTestStep.Result?.Message);
}
}
if (HasInvalidSteps)
{
foreach (var serviceTestStep in _testStatus.InvalidTestSteps)
{
failureMessage.AppendLine("Invalid Step: " + serviceTestStep.StepDescription + " ");
failureMessage.AppendLine("Message: " + serviceTestStep.Result?.Message);
}
}
if (HasPendingSteps)
{
foreach (var serviceTestStep in _testStatus.PendingTestSteps)
{
failureMessage.AppendLine("Pending Step: " + serviceTestStep.StepDescription);
}
}
if (HasFailingOutputs)
{
foreach (var serviceTestStep in _testStatus.FailingTestOutputs)
{
failureMessage.AppendLine("Failed Output For Variable: " + serviceTestStep.Variable + " ");
failureMessage.AppendLine("Message: " + serviceTestStep.Result?.Message);
}
}
if (HasInvalidOutputs)
{
foreach (var serviceTestStep in _testStatus.InvalidTestOutputs)
{
failureMessage.AppendLine("Invalid Output for Variable: " + serviceTestStep.Variable);
failureMessage.AppendLine("Message: " + serviceTestStep.Result?.Message);
}
}
if (HasPendingOutputs)
{
foreach (var serviceTestStep in _testStatus.PendingTestOutputs)
{
failureMessage.AppendLine("Pending Output for Variable: " + serviceTestStep.Variable);
}
}
var serviceTestSteps = test.TestSteps;
if (serviceTestSteps != null)
{
failureMessage.AppendLine(string.Join("", serviceTestSteps.Where(step => !string.IsNullOrEmpty(step.Result?.Message)).Select(step => step.Result?.Message)));
}
}
static void ProcessRecordsetInputs(IServiceTestModelTO serviceTestModelTO, IDev2Definition dev2Definition)
{
var rec = DataListUtil.CreateRecordsetDisplayValue(dev2Definition.RecordSetName, dev2Definition.Name, "");
var indexes = serviceTestModelTO.Inputs.Where(input => DataListUtil.ExtractRecordsetNameFromValue(input.Variable) == dev2Definition.RecordSetName).Select(input => DataListUtil.ExtractIndexRegionFromRecordset(input.Variable)).Distinct(StringComparer.OrdinalIgnoreCase).ToList();
if (serviceTestModelTO.Inputs.FirstOrDefault(input => DataListUtil.ReplaceRecordsetIndexWithBlank(input.Variable) == rec) == null)
{
if (indexes.Count == 0)
{
serviceTestModelTO.Inputs.Add(new ServiceTestInputTO
{
Variable = DataListUtil.CreateRecordsetDisplayValue(dev2Definition.RecordSetName, dev2Definition.Name, "1"),
Value = "",
EmptyIsNull = false
});
}
else
{
foreach (var index in indexes)
{
serviceTestModelTO.Inputs.Add(new ServiceTestInputTO
{
Variable = DataListUtil.CreateRecordsetDisplayValue(dev2Definition.RecordSetName, dev2Definition.Name, index),
Value = "",
EmptyIsNull = false
});
}
}
}
}
private void ValidateError(IServiceTestModelTO test, bool testPassed, StringBuilder failureMessage)
{
var fetchErrors = DataObject.Environment.FetchErrors();
var hasErrors = DataObject.Environment.HasErrors();
if (test.ErrorExpected)
{
var testErrorContainsText = test.ErrorContainsText ?? "";
testPassed = hasErrors && testPassed && fetchErrors.ToLower().Contains(testErrorContainsText.ToLower());
if (!testPassed)
{
failureMessage.Append(string.Format(Warewolf.Resource.Messages.Messages.Test_FailureMessage_Error, testErrorContainsText, fetchErrors));
}
}
else if (test.NoErrorExpected)
{
testPassed = !hasErrors && testPassed;
if (hasErrors)
{
failureMessage.AppendLine(fetchErrors);
}
}
test.TestPassed = testPassed;
test.TestFailing = !testPassed;
}
private void UpdateStepOutputsForTest(IServiceTestModelTO serviceTestModelTo)
{
if (serviceTestModelTo.TestSteps != null)
{
foreach (var serviceTestStep in serviceTestModelTo.TestSteps)
{
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
};
}
}
}
}
void ValidateError(IServiceTestModelTO test, bool testPassed, StringBuilder failureMessage)
{
var fetchErrors = _dataObject.Environment.FetchErrors();
var hasErrors = _dataObject.Environment.HasErrors();
var result = testPassed;
if (test.ErrorExpected)
{
var testErrorContainsText = test.ErrorContainsText ?? "";
result = hasErrors && result && fetchErrors.ToLower(CultureInfo.InvariantCulture).Contains(testErrorContainsText.ToLower(CultureInfo.InvariantCulture));
if (!result)
{
failureMessage.Append(string.Format(Messages.Test_FailureMessage_Error, testErrorContainsText, fetchErrors));
}
}
else
{
if (test.NoErrorExpected)
{
result = !hasErrors && result;
if (hasErrors)
{
failureMessage.AppendLine(fetchErrors);
}
}
}
test.TestPassed = result;
test.TestFailing = !result;
}
private void SetTestRunResultAfterInvalidWorkflowException(IServiceTestModelTO test, Guid resourceId, Dev2JsonSerializer serializer, string failureMessage)
{
test.TestFailing = false;
test.TestPassed = false;
test.TestPending = false;
test.TestInvalid = true;
test.LastRunDate = DateTime.Now;
Common.Utilities.PerformActionInsideImpersonatedContext(Common.Utilities.ServerUser, () => { TestCatalog.Instance.SaveTest(resourceId, test); });
var testRunResult = new TestRunResult {
TestName = test.TestName
};
if (test.TestInvalid)
{
testRunResult.RunTestResult = RunResult.TestInvalid;
testRunResult.Message = failureMessage;
Dev2Logger.Error($"Test {DataObject.TestName} for Resource {DataObject.ServiceName} ID {DataObject.ResourceID} marked invalid in exception for no start node", DataObject.ExecutionID.ToString());
}
testRunResult.DebugForTest = TestDebugMessageRepo.Instance.FetchDebugItems(resourceId, test.TestName);
if (_request != null)
{
_request.ExecuteResult = serializer.SerializeToBuilder(testRunResult);
}
}
private void AddTestInputsToJsonOrRecordset(IServiceTestModelTO test)
{
AddRecordsetsInputs(test.Inputs.Where(input => DataListUtil.IsValueRecordset(input.Variable) && !input.Variable.Contains("@")), DataObject.Environment);
foreach (var input in test.Inputs)
{
var variable = DataListUtil.AddBracketsToValueIfNotExist(input.Variable);
var value = input.Value;
if (variable.StartsWith("[[@"))
{
try
{
var jContainer = JsonConvert.DeserializeObject(value) as JObject;
DataObject.Environment.AddToJsonObjects(variable, jContainer);
}
catch (Exception e)
{
Dev2Logger.Error($"Test {DataObject.TestName} for Resource {DataObject.ServiceName} ID {DataObject.ResourceID} marked invalid in exception: " + e.Message, DataObject.ExecutionID.ToString());
}
}
else
{
AddToRecordsetObjects(input, variable, value);
}
}
}
private void UpdateOutputsForTest(IServiceTestModelTO serviceTestModelTO, IList <IDev2Definition> outputDefs)
{
if (outputDefs.Count == 0)
{
serviceTestModelTO.Outputs = new List <IServiceTestOutput>();
}
else
{
if (serviceTestModelTO.Outputs == null)
{
serviceTestModelTO.Outputs = new List <IServiceTestOutput>();
}
foreach (var dev2Definition in outputDefs)
{
if (dev2Definition.IsRecordSet)
{
ProcessRecordsetOutputs(serviceTestModelTO, dev2Definition);
}
else
{
if (serviceTestModelTO.Outputs.FirstOrDefault(output => output.Variable == dev2Definition.Name) == null)
{
serviceTestModelTO.Outputs.Add(new ServiceTestOutputTO
{
Variable = dev2Definition.Name,
AssertOp = "=",
Value = ""
});
}
}
}
for (int i = serviceTestModelTO.Outputs.Count - 1; i >= 0; i--)
{
var output = serviceTestModelTO.Outputs[i];
if (outputDefs.FirstOrDefault(definition =>
{
if (definition.IsRecordSet)
{
var rec = DataListUtil.CreateRecordsetDisplayValue(definition.RecordSetName, definition.Name, "");
var inRec = DataListUtil.ReplaceRecordsetIndexWithBlank(output.Variable);
return(rec == inRec);
}
return(definition.Name == output.Variable);
}) == null)
{
serviceTestModelTO.Outputs.Remove(output);
}
}
foreach (var serviceTestOutput in serviceTestModelTO.Outputs)
{
serviceTestOutput.Result = new TestRunResult {
RunTestResult = RunResult.TestInvalid
};
}
serviceTestModelTO.Outputs.Sort((output, testOutput) => string.Compare(output.Variable, testOutput.Variable, StringComparison.InvariantCultureIgnoreCase));
}
}
private static List <IServiceTestStep> GetStepValues(IServiceTestModelTO test, out IEnumerable <IServiceTestStep> pendingSteps, out IEnumerable <IServiceTestStep> invalidSteps, out IEnumerable <IServiceTestStep> failingSteps)
{
var serviceTestSteps = test.TestSteps;
pendingSteps = serviceTestSteps?.Where(step => step.Type != StepType.Mock && step.Result?.RunTestResult == RunResult.TestPending);
invalidSteps = serviceTestSteps?.Where(step => step.Type != StepType.Mock && step.Result?.RunTestResult == RunResult.TestInvalid);
failingSteps = serviceTestSteps?.Where(step => step.Type != StepType.Mock && step.Result?.RunTestResult == RunResult.TestFailed);
return(serviceTestSteps);
}
static void UpdateStepOutputsForTest(IServiceTestModelTO serviceTestModelTo)
{
if (serviceTestModelTo.TestSteps != null)
{
foreach (var serviceTestStep in serviceTestModelTo.TestSteps)
{
UpdateStepOutputsForTest(serviceTestStep);
}
}
}
static void UpdateTestStatus(IServiceTestModel selectedServiceTest, IServiceTestModelTO res)
{
selectedServiceTest.TestFailing = res.Result.RunTestResult == RunResult.TestFailed;
selectedServiceTest.TestPassed = res.Result.RunTestResult == RunResult.TestPassed;
selectedServiceTest.TestInvalid = res.Result.RunTestResult == RunResult.TestInvalid ||
res.Result.RunTestResult == RunResult.TestResourceDeleted;
selectedServiceTest.TestPending = res.Result.RunTestResult != RunResult.TestFailed &&
res.Result.RunTestResult != RunResult.TestPassed &&
res.Result.RunTestResult != RunResult.TestInvalid &&
res.Result.RunTestResult != RunResult.TestResourceDeleted &&
res.Result.RunTestResult != RunResult.TestResourcePathUpdated;
}
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 void UpdateInputsForTest(IServiceTestModelTO serviceTestModelTO, IList <IDev2Definition> inputDefs)
{
if (inputDefs.Count == 0)
{
serviceTestModelTO.Inputs = new List <IServiceTestInput>();
}
else
{
if (serviceTestModelTO.Inputs == null)
{
serviceTestModelTO.Inputs = new List <IServiceTestInput>();
}
foreach (var dev2Definition in inputDefs)
{
if (dev2Definition.IsRecordSet)
{
ProcessRecordsetInputs(serviceTestModelTO, dev2Definition);
}
else
{
if (serviceTestModelTO.Inputs.FirstOrDefault(input => input.Variable == dev2Definition.Name) == null)
{
serviceTestModelTO.Inputs.Add(new ServiceTestInputTO
{
Variable = dev2Definition.Name,
Value = "",
EmptyIsNull = false
});
}
}
}
for (int i = serviceTestModelTO.Inputs.Count - 1; i >= 0; i--)
{
var input = serviceTestModelTO.Inputs[i];
if (inputDefs.FirstOrDefault(definition =>
{
if (definition.IsRecordSet)
{
var rec = DataListUtil.CreateRecordsetDisplayValue(definition.RecordSetName, definition.Name, "");
var inRec = DataListUtil.ReplaceRecordsetIndexWithBlank(input.Variable);
return(rec == inRec);
}
return(definition.Name == input.Variable);
}) == null)
{
serviceTestModelTO.Inputs.Remove(input);
}
}
serviceTestModelTO.Inputs.Sort((input, testInput) => string.Compare(input.Variable, testInput.Variable, StringComparison.InvariantCultureIgnoreCase));
}
}
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()));
}
}
IServiceTestCoverageModelTo SaveSingleTestCoverageToDisk(Guid resourceId, IServiceTestModelTO serviceTestModelTo)
{
var serviceTestModelTos = new List <IServiceTestModelTO>
{
serviceTestModelTo
};
var coverageArgs = new CoverageArgs {
OldReportName = serviceTestModelTo.OldTestName, ReportName = serviceTestModelTo.TestName
};
var serviceTestCoverageModelTo = _serviceAllTestsCoverageModelToFactory.New(resourceId, coverageArgs, serviceTestModelTos);
SaveCoverageReport(resourceId, serviceTestCoverageModelTo);
UpdateTestCoverageReports(resourceId, serviceTestCoverageModelTo);
return(serviceTestCoverageModelTo);
}
public void SaveTest(Guid resourceID, IServiceTestModelTO test)
{
SaveTestToDisk(resourceID, test);
var existingTests = Tests.GetOrAdd(resourceID, new List <IServiceTestModelTO>());
var found = existingTests.FirstOrDefault(to => to.TestName.Equals(test.TestName, StringComparison.CurrentCultureIgnoreCase));
if (found == null)
{
existingTests.Add(test);
}
else
{
existingTests.Remove(found);
existingTests.Add(test);
}
}
void SaveTestToDisk(Guid resourceId, IServiceTestModelTO serviceTestModelTo)
{
var dirPath = GetTestPathForResourceId(resourceId);
_directoryWrapper.CreateIfNotExists(dirPath);
if (!string.Equals(serviceTestModelTo.OldTestName, serviceTestModelTo.TestName, StringComparison.InvariantCultureIgnoreCase))
{
var oldFilePath = Path.Combine(dirPath, $"{serviceTestModelTo.OldTestName}.test");
_fileWrapper.Delete(oldFilePath);
}
var filePath = Path.Combine(dirPath, $"{serviceTestModelTo.TestName}.test");
serviceTestModelTo.Password = DpapiWrapper.EncryptIfDecrypted(serviceTestModelTo.Password);
var sw = new StreamWriter(filePath, false);
_serializer.Serialize(sw, serviceTestModelTo);
}
public void SaveTest(Guid resourceId, IServiceTestModelTO serviceTestModelTo)
{
SaveTestToDisk(resourceId, serviceTestModelTo);
Tests.AddOrUpdate(resourceId, new List <IServiceTestModelTO> {
serviceTestModelTo
}, (id, list) =>
{
var serviceTestModelTos = Fetch(id);
var found = serviceTestModelTos.FirstOrDefault(to => to.TestName.Equals(serviceTestModelTo.TestName, StringComparison.CurrentCultureIgnoreCase));
if (found != null)
{
serviceTestModelTos.Remove(found);
}
serviceTestModelTos.Add(serviceTestModelTo);
return(serviceTestModelTos);
});
}
private static IEnumerable <IServiceTestOutput> GetOutputValues(IServiceTestModelTO test, out IEnumerable <IServiceTestOutput> pendingOutputs, out IEnumerable <IServiceTestOutput> invalidOutputs)
{
var failingOutputs = test.Outputs?.Where(output => output.Result?.RunTestResult == RunResult.TestFailed);
pendingOutputs = test.Outputs?.Where(output => output.Result?.RunTestResult == RunResult.TestPending);
invalidOutputs = test.Outputs?.Where(output => output.Result?.RunTestResult == RunResult.TestInvalid);
var serviceTestOutputs = failingOutputs as IServiceTestOutput[] ?? failingOutputs?.ToArray();
if (serviceTestOutputs?.Any() ?? false)
{
foreach (var serviceTestOutput in serviceTestOutputs)
{
serviceTestOutput.Result.Message = DataListUtil.StripBracketsFromValue(serviceTestOutput.Result.Message);
}
}
return(serviceTestOutputs);
}
public void Add(IServiceTestModelTO result)
{
Results.Add(new ServiceTestModelTO
{
OldTestName = result.OldTestName,
TestName = result.TestName,
TestInvalid = IsTestInValid(result),
TestPassed = IsTestPassed(result),
TestFailing = IsTestFailing(result),
Result = new TestRunResult
{
TestName = result.TestName,
Message = result.TestInvalid ? "Test has no selected nodes" : result.FailureMessage,
RunTestResult = result.TestInvalid ? RunResult.TestInvalid : result.TestFailing ? RunResult.TestFailed : RunResult.TestPassed,
}
});
}
Guid TryExecuteWf(ErrorResultTO to, IServiceTestModelTO test)
{
var result = new Guid();
var wfappUtils = new WfApplicationUtils();
var invokeErrors = new ErrorResultTO();
var resourceId = DataObject.ResourceID;
if (test?.Inputs != null)
{
AddTestInputsToJsonOrRecordset(test);
}
var serializer = new Dev2JsonSerializer();
try
{
result = _inner.ExecuteWf(new TestExecutionContext {
_test = test,
_wfappUtils = wfappUtils,
_invokeErrors = invokeErrors,
_serializer = serializer,
});
}
catch (InvalidWorkflowException iwe)
{
Dev2Logger.Error(iwe, DataObject.ExecutionID.ToString());
var msg = iwe.Message;
var start = msg.IndexOf("Flowchart ", StringComparison.Ordinal);
to?.AddError(start > 0 ? GlobalConstants.NoStartNodeError : iwe.Message);
var failureMessage = DataObject.Environment.FetchErrors();
wfappUtils.DispatchDebugState(DataObject, StateType.End, out invokeErrors);
SetTestRunResultAfterInvalidWorkflowException(test, resourceId, serializer, failureMessage);
}
catch (Exception ex)
{
Dev2Logger.Error(ex, GlobalConstants.WarewolfError);
to.AddError(ex.Message);
wfappUtils.DispatchDebugState(DataObject, StateType.End, out invokeErrors);
SetTestRunResultAfterException(test, resourceId, serializer, ex);
}
return(result);
}
private void CheckAuthentication(IServiceTestModelTO serviceTestModelTo)
{
if (serviceTestModelTo.AuthenticationType == AuthenticationType.User)
{
var resource = ResourceCat.GetResource(GlobalConstants.ServerWorkspaceID, DataObject.ResourceID);
var testNotauthorizedmsg = string.Format(Messages.Test_NotAuthorizedMsg, resource?.ResourceName);
DataObject.Environment.AllErrors.Add(testNotauthorizedmsg);
DataObject.StopExecution = true;
}
else
{
if (serviceTestModelTo.AuthenticationType == AuthenticationType.Public)
{
Thread.CurrentPrincipal = GlobalConstants.GenericPrincipal;
DataObject.ExecutingUser = GlobalConstants.GenericPrincipal;
}
}
}
private static void UpdateTestToInvalid(IServiceTestModelTO serviceTestModelTO)
{
serviceTestModelTO.TestFailing = false;
serviceTestModelTO.TestPassed = false;
serviceTestModelTO.TestPending = false;
serviceTestModelTO.TestInvalid = true;
UpdateStepOutputsForTest(serviceTestModelTO);
if (serviceTestModelTO.Outputs != null)
{
foreach (var serviceTestOutput in serviceTestModelTO.Outputs)
{
if (serviceTestOutput.Result != null)
{
serviceTestOutput.Result.RunTestResult = RunResult.TestInvalid;
}
}
}
}
static void UpdateInputsForTest(IServiceTestModelTO serviceTestModelTO, IList <IDev2Definition> inputDefs, int i)
{
var input = serviceTestModelTO.Inputs[i];
if (inputDefs.FirstOrDefault(definition =>
{
if (definition.IsRecordSet)
{
var rec = DataListUtil.CreateRecordsetDisplayValue(definition.RecordSetName, definition.Name, "");
var inRec = DataListUtil.ReplaceRecordsetIndexWithBlank(input.Variable);
return(rec == inRec);
}
return(definition.Name == input.Variable);
}) == null)
{
serviceTestModelTO.Inputs.Remove(input);
}
}
private void AddTestInputsToJsonOrRecordset(IServiceTestModelTO test)
{
AddRecordsetsInputs(test.Inputs.Where(input => DataListUtil.IsValueRecordset(input.Variable) && !input.Variable.Contains("@")), DataObject.Environment);
foreach (var input in test.Inputs)
{
var variable = DataListUtil.AddBracketsToValueIfNotExist(input.Variable);
var value = input.Value;
if (variable.StartsWith("[[@"))
{
var jContainer = JsonConvert.DeserializeObject(value) as JObject;
DataObject.Environment.AddToJsonObjects(variable, jContainer);
}
else
{
AddToRecordsetObjects(input, variable, value);
}
}
}
static void UpdateInputsForTest(IServiceTestModelTO serviceTestModelTO, IDev2Definition dev2Definition)
{
if (dev2Definition.IsRecordSet)
{
ProcessRecordsetInputs(serviceTestModelTO, dev2Definition);
}
else
{
if (serviceTestModelTO.Inputs.FirstOrDefault(input => input.Variable == dev2Definition.Name) == null)
{
serviceTestModelTO.Inputs.Add(new ServiceTestInputTO
{
Variable = dev2Definition.Name,
Value = "",
EmptyIsNull = false
});
}
}
}
static IServiceTestModelTO UpdateOutputsForTest(IServiceTestModelTO serviceTestModelTO, IDev2Definition dev2Definition)
{
if (dev2Definition.IsRecordSet)
{
ProcessRecordsetOutputs(serviceTestModelTO, dev2Definition);
}
else
{
if (serviceTestModelTO.Outputs.FirstOrDefault(output => output.Variable == dev2Definition.Name) == null)
{
serviceTestModelTO.Outputs.Add(new ServiceTestOutputTO
{
Variable = dev2Definition.Name,
AssertOp = "=",
Value = ""
});
}
}
return(serviceTestModelTO);
}
public static JObject BuildTestResultJSONForWebRequest(this IServiceTestModelTO result)
{
var resObj = new JObject {
{ "Test Name", result.TestName }
};
if (result.Result.RunTestResult == RunResult.TestPassed)
{
resObj.Add("Result", Warewolf.Resource.Messages.Messages.Test_PassedResult);
}
else if (result.Result.RunTestResult == RunResult.TestFailed)
{
resObj.Add("Result", Warewolf.Resource.Messages.Messages.Test_FailureResult);
var message = result.Result.Message ?? result.FailureMessage;
resObj.Add("Message", message.Replace(Environment.NewLine, ""));
}
else if (result.Result.RunTestResult == RunResult.TestInvalid)
{
resObj.Add("Result", Warewolf.Resource.Messages.Messages.Test_InvalidResult);
resObj.Add("Message", result.Result.Message.Replace(Environment.NewLine, ""));
}
else if (result.Result.RunTestResult == RunResult.TestResourceDeleted)
{
resObj.Add("Result", Warewolf.Resource.Messages.Messages.Test_ResourceDeleteResult);
resObj.Add("Message", result.Result.Message.Replace(Environment.NewLine, ""));
}
else if (result.Result.RunTestResult == RunResult.TestResourcePathUpdated)
{
resObj.Add("Result", Warewolf.Resource.Messages.Messages.Test_ResourcpathUpdatedResult);
resObj.Add("Message", result.Result.Message.Replace(Environment.NewLine, ""));
}
else
{
if (result.Result.RunTestResult == RunResult.TestPending)
{
resObj.Add("Result", Warewolf.Resource.Messages.Messages.Test_PendingResult);
resObj.Add("Message", result.Result.Message);
}
}
return(resObj);
}
private void SetTestRunResultAfterException(IServiceTestModelTO test, Guid resourceId, Dev2JsonSerializer serializer, Exception ex)
{
test.TestFailing = false;
test.TestPassed = false;
test.TestPending = false;
test.TestInvalid = true;
test.LastRunDate = DateTime.Now;
Common.Utilities.PerformActionInsideImpersonatedContext(Common.Utilities.ServerUser, () => { TestCatalog.Instance.SaveTest(resourceId, test); });
var testRunResult = new TestRunResult {
TestName = test.TestName
};
if (test.TestInvalid)
{
testRunResult.RunTestResult = RunResult.TestInvalid;
testRunResult.Message = ex.Message;
Dev2Logger.Error($"Test {DataObject.TestName} for Resource {DataObject.ServiceName} ID {DataObject.ResourceID} marked invalid in general exception", GlobalConstants.WarewolfError);
}
testRunResult.DebugForTest = TestDebugMessageRepo.Instance.FetchDebugItems(resourceId, test.TestName);
_request.ExecuteResult = serializer.SerializeToBuilder(testRunResult);
}
