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); }