public Guid Execute(out ErrorResultTO errors, int update) { var start = _stopwatch.ElapsedTicks; var errorsInstanceCounter = _locater.GetCounter(GetDataObject().ResourceID, WarewolfPerfCounterType.ExecutionErrors); var concurrentInstanceCounter = _locater.GetCounter(GetDataObject().ResourceID, WarewolfPerfCounterType.ConcurrentRequests); var avgExecutionsInstance = _locater.GetCounter(GetDataObject().ResourceID, WarewolfPerfCounterType.AverageExecutionTime); var reqPerSecond = _locater.GetCounter(GetDataObject().ResourceID, WarewolfPerfCounterType.RequestsPerSecond); var outErrors = new ErrorResultTO(); try { _recPerSecondCounter.Increment(); _currentConnections.Increment(); reqPerSecond.Increment(); concurrentInstanceCounter.Increment(); var ret = Container.Execute(out outErrors, update); errors = outErrors; return(ret); } finally { _currentConnections.Decrement(); concurrentInstanceCounter.Decrement(); var time = _stopwatch.ElapsedTicks - start; _avgTime.IncrementBy(time); avgExecutionsInstance.IncrementBy(time); if (outErrors != null) { _totalErrors.IncrementBy(outErrors.FetchErrors().Count); errorsInstanceCounter.IncrementBy(outErrors.FetchErrors().Count); } } }
public void DsfWebPutActivity_ExecutionImpl_ErrorResultTO_ReturnErrors_ToActivity_Success() { //-----------------------Arrange------------------------- const string response = "{\"Message\":\"TEST Error\"}"; var environment = new ExecutionEnvironment(); var mockEsbChannel = new Mock<IEsbChannel>(); var mockDSFDataObject = new Mock<IDSFDataObject>(); var mockExecutionEnvironment = new Mock<IExecutionEnvironment>(); var errorResultTO = new ErrorResultTO(); using (var service = new WebService(XmlResource.Fetch("WebService")) { RequestResponse = response }) { mockDSFDataObject.Setup(o => o.Environment).Returns(environment); mockDSFDataObject.Setup(o => o.EsbChannel).Returns(new Mock<IEsbChannel>().Object); var dsfWebGetActivity = new TestDsfWebPutActivity { OutputDescription = service.GetOutputDescription(), ResourceID = InArgument<Guid>.FromValue(Guid.Empty), QueryString = "test Query", Headers = new List<INameValue>(), ResponseFromWeb = response, HasErrorMessage = "Some error" }; //-----------------------Act----------------------------- dsfWebGetActivity.TestExecutionImpl(mockEsbChannel.Object, mockDSFDataObject.Object, "Test Inputs", "Test Outputs", out errorResultTO, 0); //-----------------------Assert-------------------------- Assert.AreEqual(1, errorResultTO.FetchErrors().Count); Assert.AreEqual("Some error", errorResultTO.FetchErrors()[0]); } }
public void ErrorResultsTOMakeErrorResultFromDataListStringWithMultipleErrorsExpectedCorrectErrorResultTO() { ErrorResultTO makeErrorResultFromDataListString = ErrorResultTO.MakeErrorResultFromDataListString("<InnerError>First Error</InnerError><InnerError>Second Error</InnerError>"); Assert.IsTrue(makeErrorResultFromDataListString.HasErrors()); Assert.AreEqual(2, makeErrorResultFromDataListString.FetchErrors().Count); Assert.AreEqual("First Error", makeErrorResultFromDataListString.FetchErrors()[0]); Assert.AreEqual("Second Error", makeErrorResultFromDataListString.FetchErrors()[1]); }
public void ErrorResultTO_AddError_CheckForDuplicates_True_AddSameError_ExpectLstToBeSame() { var resultTo = new ErrorResultTO(); resultTo.AddError("some message", true); resultTo.AddError("some message", true); Assert.IsTrue(resultTo.HasErrors()); Assert.AreEqual(1, resultTo.FetchErrors().Count); Assert.AreEqual("some message", resultTo.FetchErrors()[0]); Assert.AreEqual("<InnerError>some message</InnerError>", resultTo.MakeDataListReady()); }
public void ErrorResultTO_Remove_ShouldJustRemoveTheErrorInTheCollection() { var errorResultTo = new ErrorResultTO(); Assert.AreEqual(0, errorResultTo.FetchErrors().Count); errorResultTo.AddError("SomeError"); Assert.AreEqual(1, errorResultTo.FetchErrors().Count); errorResultTo.RemoveError("SomeError"); Assert.AreEqual(0, errorResultTo.FetchErrors().Count); }
public void ErrorResultTO_MergeErrors_NullOtherDoesNotThrow() { var errorResultTo = new ErrorResultTO(); Assert.AreEqual(0, errorResultTo.FetchErrors().Count); errorResultTo.AddError("SomeError"); Assert.AreEqual(1, errorResultTo.FetchErrors().Count); errorResultTo.MergeErrors(null); Assert.AreEqual(1, errorResultTo.FetchErrors().Count); }
public void ErrorResultTO_Clear_ShouldEmptyTheErrorCollection() { var errorResultTo = new ErrorResultTO(); errorResultTo.AddError("SomeError"); errorResultTo.AddError("AnotherError"); Assert.AreEqual(2, errorResultTo.FetchErrors().Count); errorResultTo.ClearErrors(); Assert.AreEqual(0, errorResultTo.FetchErrors().Count); }
public void ErrorResultTO_MergeErrors_EmptyOther() { var errorResultTo = new ErrorResultTO(); Assert.AreEqual(0, errorResultTo.FetchErrors().Count); errorResultTo.AddError("SomeError"); Assert.AreEqual(1, errorResultTo.FetchErrors().Count); var merge = new ErrorResultTO(); errorResultTo.MergeErrors(merge); Assert.AreEqual(1, errorResultTo.FetchErrors().Count); }
public void ErrorResultTO_AddError_CheckForDuplicates_False_AddSameError_ExpectAdd() { var resultTo = new ErrorResultTO(); resultTo.AddError("some message", false); resultTo.AddError("some message", false); resultTo.AddError("some message", true); resultTo.AddError("deferent message", false); Assert.IsTrue(resultTo.HasErrors()); Assert.AreEqual(2, resultTo.FetchErrors().Count); Assert.AreEqual("some message", resultTo.FetchErrors()[0]); Assert.AreEqual("deferent message", resultTo.FetchErrors()[1]); Assert.AreEqual("<InnerError>some message</InnerError><InnerError>deferent message</InnerError>", resultTo.MakeDataListReady()); }
public void ErrorResultTO_MakeDataListReady_AsXmlFalseShouldReturnAllErrorsAsOne() { var result = "\"errors\": [ \"SomeError\",\"AnotherError\"]"; var errorResultTo = new ErrorResultTO(); Assert.AreEqual(0, errorResultTo.FetchErrors().Count); errorResultTo.AddError("SomeError"); errorResultTo.AddError("AnotherError"); Assert.AreEqual(2, errorResultTo.FetchErrors().Count); var makeDisplayReady = errorResultTo.MakeDataListReady(false); Assert.AreEqual(result, makeDisplayReady); }
public void ErrorResultTO_MakeDataListReady_ShouldReturnAllErrorsAsOne() { var result = "<InnerError>SomeError</InnerError><InnerError>AnotherError</InnerError>"; var errorResultTo = new ErrorResultTO(); Assert.AreEqual(0, errorResultTo.FetchErrors().Count); errorResultTo.AddError("SomeError"); errorResultTo.AddError("AnotherError"); Assert.AreEqual(2, errorResultTo.FetchErrors().Count); var makeDisplayReady = errorResultTo.MakeDataListReady(); Assert.AreEqual(result, makeDisplayReady); }
public void ErrorResultTO_MergeErrors_ShouldJustRemoveTheErrorInTheCollection() { var errorResultTo = new ErrorResultTO(); Assert.AreEqual(0, errorResultTo.FetchErrors().Count); errorResultTo.AddError("SomeError"); Assert.AreEqual(1, errorResultTo.FetchErrors().Count); var merge = new ErrorResultTO(); merge.AddError("Error to merge"); errorResultTo.MergeErrors(merge); Assert.AreEqual(2, errorResultTo.FetchErrors().Count); }
public void ErrorResultTO_MakeDataListReady_AsXmlFalseShouldReturnAllErrorsAsOne() { var result = "[ \"SomeError\",\"AnotherError\"]"; var errorResultTo = new ErrorResultTO(); Assert.AreEqual(0, errorResultTo.FetchErrors().Count); errorResultTo.AddError("SomeError"); errorResultTo.AddError("AnotherError"); Assert.AreEqual(2, errorResultTo.FetchErrors().Count); var makeDisplayReady = errorResultTo.MakeDataListReady(false); Assert.AreEqual(result, makeDisplayReady, "\"errors\": prefix have been removed to keep with the xml add error of this method as it seems to be the most used"); }
/// <summary> /// Creates the list of data list item view model to bind to. /// </summary> /// <param name="errorString">The error string.</param> /// <returns></returns> public void CreateListsOfIDataListItemModelToBindTo(out string errorString) { errorString = string.Empty; IDataListCompiler compiler = DataListFactory.CreateDataListCompiler(); if (!string.IsNullOrEmpty(Resource.DataList)) { ErrorResultTO errors = new ErrorResultTO(); try { IBinaryDataList binarnyDl = CreateBinaryDataListFromXmlData(Resource.DataList, out errors); if (!errors.HasErrors()) { ConvertBinaryDataListToListOfIDataListItemModels(binarnyDl, out errorString); } else { string errorMessage = errors.FetchErrors().Aggregate(string.Empty, (current, error) => current + error); throw new Exception(errorMessage); } if (binarnyDl != null) { compiler.ForceDeleteDataListByID(binarnyDl.UID); } } catch (Exception) { errors.AddError("Invalid variable list. Please insure that your variable list has valid entries"); } } else { RecsetCollection.Clear(); AddRecordSet(); ScalarCollection.Clear(); } BaseCollection = new OptomizedObservableCollection <DataListHeaderItemModel>(); DataListHeaderItemModel varNode = DataListItemModelFactory.CreateDataListHeaderItem("Variable"); if (ScalarCollection.Count == 0) { var dataListItemModel = DataListItemModelFactory.CreateDataListModel(string.Empty); ScalarCollection.Add(dataListItemModel); } varNode.Children = ScalarCollection; BaseCollection.Add(varNode); //AddRecordsetNamesIfMissing(); DataListHeaderItemModel recordsetsNode = DataListItemModelFactory.CreateDataListHeaderItem("Recordset"); if (RecsetCollection.Count == 0) { AddRecordSet(); } recordsetsNode.Children = RecsetCollection; BaseCollection.Add(recordsetsNode); }
public void ErrorResultTO_MakeDataListReady_CannotSetUnknownMember_RemapsErrorMessage() { var result = "\"errors\": [ \"SomeError\",\"Resource has unrecognized formatting, this Warewolf Server may be to outdated to read this resource.\",\"Another Error\"]"; var errorResultTo = new ErrorResultTO(); Assert.AreEqual(0, errorResultTo.FetchErrors().Count); errorResultTo.AddError("SomeError"); errorResultTo.AddError("Cannot set unknown member"); errorResultTo.AddError("Another Error"); Assert.AreEqual(3, errorResultTo.FetchErrors().Count); var makeDisplayReady = errorResultTo.MakeDataListReady(false); Assert.AreEqual(result, makeDisplayReady); }
protected override Guid ExecutionImpl(IEsbChannel esbChannel, IDSFDataObject dataObject, string inputs, string outputs, out ErrorResultTO errors) { var execErrors = new ErrorResultTO(); var compiler = DataListFactory.CreateDataListCompiler(); var oldID = dataObject.DataListID; errors = new ErrorResultTO(); errors.MergeErrors(execErrors); var databaseServiceExecution = ServiceExecution as DatabaseServiceExecution; if (databaseServiceExecution != null) { databaseServiceExecution.InstanceInputDefinitions = inputs; // set the output mapping for the instance ;) databaseServiceExecution.InstanceOutputDefintions = outputs; // set the output mapping for the instance ;) } //ServiceExecution.DataObj = dataObject; var result = ServiceExecution.Execute(out execErrors); var fetchErrors = execErrors.FetchErrors(); foreach (var error in fetchErrors) { dataObject.Environment.Errors.Add(error); } errors.MergeErrors(execErrors); // Adjust the remaining output mappings ;) compiler.SetParentID(dataObject.DataListID, oldID); return(result); }
protected override void ExecutionImpl(IEsbChannel esbChannel, IDSFDataObject dataObject, string inputs, string outputs, out ErrorResultTO tmpErrors, int update) { tmpErrors = new ErrorResultTO(); try { if (Method == null) { throw new Exception(ErrorResource.NoMethodSelected); } ExecuteService(update, out tmpErrors, Method, dataObject, OutputFormatterFactory.CreateOutputFormatter(OutputDescription)); } catch (Exception err) { tmpErrors.AddError(err.Message); } finally { if (tmpErrors.HasErrors()) { foreach (var error in tmpErrors.FetchErrors()) { dataObject.Environment.AddError(error); } } } }
protected override void ExecutionImpl(IEsbChannel esbChannel, IDSFDataObject dataObject, string inputs, string outputs, out ErrorResultTO tmpErrors, int update) { var execErrors = new ErrorResultTO(); tmpErrors = new ErrorResultTO(); tmpErrors.MergeErrors(execErrors); if (string.IsNullOrEmpty(ProcedureName)) { tmpErrors.AddError(ErrorResource.NoActionsInSelectedDB); return; } if (ServiceExecution is DatabaseServiceExecution databaseServiceExecution) { if (databaseServiceExecution.SourceIsNull()) { databaseServiceExecution.GetSource(SourceId); } databaseServiceExecution.Inputs = Inputs.Select(a => new ServiceInput { EmptyIsNull = a.EmptyIsNull, Name = a.Name, RequiredField = a.RequiredField, Value = a.Value, TypeName = a.TypeName } as IServiceInput).ToList(); databaseServiceExecution.Outputs = Outputs; } ServiceExecution.Execute(out execErrors, update); var fetchErrors = execErrors.FetchErrors(); foreach (var error in fetchErrors) { dataObject.Environment.Errors.Add(error); } tmpErrors.MergeErrors(execErrors); }
protected override void ExecutionImpl(IEsbChannel esbChannel, IDSFDataObject dataObject, string inputs, string outputs, out ErrorResultTO errors, int update) { var execErrors = new ErrorResultTO(); errors = new ErrorResultTO(); errors.MergeErrors(execErrors); if (string.IsNullOrEmpty(CommandText)) { errors.AddError(ErrorResource.NoActionsInSelectedDB); return; } var databaseServiceExecution = ServiceExecution as DatabaseServiceExecution; if (databaseServiceExecution != null) { databaseServiceExecution.Inputs = Inputs.Select(a => new ServiceInput { EmptyIsNull = a.EmptyIsNull, Name = a.Name, RequiredField = a.RequiredField, Value = a.Value, TypeName = a.TypeName } as IServiceInput).ToList(); databaseServiceExecution.Outputs = Outputs; } ServiceExecution.Execute(out execErrors, update); var fetchErrors = execErrors.FetchErrors(); foreach (var error in fetchErrors) { dataObject.Environment.Errors.Add(error); } errors.MergeErrors(execErrors); }
public void ErrorResultTO_MakeDataListReady_CannotSetUnknownMember_RemapsErrorMessage() { var result = "[ \"SomeError\",\"Resource has unrecognized formatting, this Warewolf Server may be to outdated to read this resource.\",\"Another Error\"]"; var errorResultTo = new ErrorResultTO(); Assert.AreEqual(0, errorResultTo.FetchErrors().Count); errorResultTo.AddError("SomeError"); errorResultTo.AddError("Cannot set unknown member"); errorResultTo.AddError("Another Error"); Assert.AreEqual(3, errorResultTo.FetchErrors().Count); var makeDisplayReady = errorResultTo.MakeDataListReady(false); Assert.AreEqual(result, makeDisplayReady, "\"errors\": prefix have been removed to keep with the xml add error of this method as it seems to be the most used"); }
void HandleErrors(IDSFDataObject dataObject, int update, ErrorResultTO allErrors) { var hasErrors = allErrors.HasErrors(); if (hasErrors) { DisplayAndWriteError("DsfExecuteCommandLineActivity", allErrors); foreach (var error in allErrors.FetchErrors()) { dataObject.Environment.AddError(error); } } if (dataObject.IsDebugMode()) { if (hasErrors) { var innerCount = 1; foreach (GatherSystemInformationTO item in SystemInformationCollection) { var itemToAdd = new DebugItem(); AddDebugItem(new DebugItemStaticDataParams("", innerCount.ToString(CultureInfo.InvariantCulture)), itemToAdd); AddDebugItem(new DebugEvalResult(item.Result, "", dataObject.Environment, update), itemToAdd); _debugOutputs.Add(itemToAdd); innerCount++; } } DispatchDebugState(dataObject, StateType.Before, update); DispatchDebugState(dataObject, StateType.After, update); } }
public void ErrorResultTO_AddErrors_GivenCheckForDuplcity_ShouldNotAddTheErrorInTheCollection() { var errorResultTo = new ErrorResultTO(); Assert.AreEqual(0, errorResultTo.FetchErrors().Count); errorResultTo.AddError("SomeError", true); Assert.AreEqual(1, errorResultTo.FetchErrors().Count); errorResultTo.AddError("SomeError", true); Assert.AreEqual(1, errorResultTo.FetchErrors().Count); var merge = new ErrorResultTO(); merge.AddError("Error to merge"); errorResultTo.MergeErrors(merge); Assert.AreEqual(2, errorResultTo.FetchErrors().Count); }
public void ErrorResultTO_MakeDisplayReady_ShouldReturnAllErrorsAsOne() { var result = new StringBuilder(); result.AppendLine("SomeError"); result.Append("AnotherError"); var errorResultTo = new ErrorResultTO(); Assert.AreEqual(0, errorResultTo.FetchErrors().Count); errorResultTo.AddError("SomeError"); errorResultTo.AddError("AnotherError"); Assert.AreEqual(2, errorResultTo.FetchErrors().Count); var makeDisplayReady = errorResultTo.MakeDisplayReady(); Assert.AreEqual(result.ToString(), makeDisplayReady); }
protected override void ExecuteTool(IDSFDataObject dataObject, int update) { var allErrors = new ErrorResultTO(); InitializeDebug(dataObject); if (Result == null) { Result = string.Empty; } var toresultfields = Result.Split(','); var fromFields = InFields.Split(','); var fromResultFieldresultfields = ResultFields.Split(','); try { PreExecution(dataObject, fromFields, update); if (String.IsNullOrEmpty(InFields)) { throw new Exception(string.Format(ErrorResource.Invalid, "In fields")); } if (String.IsNullOrEmpty(ResultFields)) { throw new Exception(string.Format(ErrorResource.Invalid, "from fields")); } if (toresultfields.Any(ExecutionEnvironment.IsScalar)) { throw new Exception(string.Format(ErrorResource.ScalarsNotAllowed, "'Result'")); } dataObject.Environment.AssignUnique(fromFields, fromResultFieldresultfields, toresultfields, update); } catch (Exception e) { Dev2Logger.Error("DSFUnique", e, GlobalConstants.WarewolfError); allErrors.AddError(e.Message); } finally { PostExecute(dataObject, toresultfields, allErrors.HasErrors(), update); // Handle Errors var hasErrors = allErrors.HasErrors(); if (hasErrors) { DisplayAndWriteError("DsfUniqueActivity", allErrors); foreach (var error in allErrors.FetchErrors()) { dataObject.Environment.AddError(error); } } if (dataObject.IsDebugMode()) { DispatchDebugState(dataObject, StateType.Before, update); DispatchDebugState(dataObject, StateType.After, update); } } }
public void ErrorResultTO_MakeErrorResultFromDataListString_WhenErrorStringNotValidXML_ShouldJustAddTheError() { //------------Setup for test-------------------------- //------------Execute Test--------------------------- ErrorResultTO makeErrorResultFromDataListString = ErrorResultTO.MakeErrorResultFromDataListString("<InnerError>Could not insert <> into a field</InnerError>"); //------------Assert Results------------------------- Assert.AreEqual(1, makeErrorResultFromDataListString.FetchErrors().Count); Assert.AreEqual("<Error><InnerError>Could not insert <> into a field</InnerError></Error>", makeErrorResultFromDataListString.FetchErrors()[0]); }
protected static void DisplayAndWriteError(string serviceName, ErrorResultTO errors) { var errorBuilder = new StringBuilder(); foreach (var e in errors.FetchErrors()) { errorBuilder.AppendLine(string.Format("--[ Execution Exception ]--\r\nService Name = {0}\r\nError Message = {1} \r\n--[ End Execution Exception ]--", serviceName, e)); } Dev2Logger.Log.Error("DsfNativeActivity", new Exception(errorBuilder.ToString())); }
private void DebugOutput(IDSFDataObject dataObject, int update, ErrorResultTO allErrors, string parentServiceName, string serviceName, Guid oldResourceId) { if (!dataObject.WorkflowResumeable || !dataObject.IsDataListScoped) { // Handle Errors if (allErrors.HasErrors()) { var env = dataObject.Environment; foreach (var allError in allErrors.FetchErrors()) { env.AddError(allError); } // add to datalist in variable specified if (!String.IsNullOrEmpty(OnErrorVariable)) { var errorString = env.FetchErrors(); var errors = ErrorResultTO.MakeErrorResultFromDataListString(errorString, true); var upsertVariable = DataListUtil.AddBracketsToValueIfNotExist(OnErrorVariable); if (errors.HasErrors()) { foreach (var error in errors.FetchErrors()) { //TODO: duplicate check on the Recordset might hide the real issue, //of multiple execution calls passing here which seems not to be the same on F7 env.Assign(upsertVariable, error, update); } } else { env.Assign(upsertVariable, errorString, update); } } DisplayAndWriteError(dataObject, serviceName, allErrors); } } if (dataObject.IsDebugMode() || dataObject.RunWorkflowAsync && !dataObject.IsFromWebServer) { var dt = DateTime.Now; DispatchDebugState(dataObject, StateType.After, update, dt); ChildDebugStateDispatch(dataObject); _debugOutputs = new List <DebugItem>(); DispatchDebugState(dataObject, StateType.Duration, update, dt); } dataObject.ParentInstanceID = _previousInstanceId; dataObject.ParentServiceName = parentServiceName; dataObject.ServiceName = serviceName; dataObject.RemoteInvokeResultShape = new StringBuilder(); // reset targnet shape ;) dataObject.RunWorkflowAsync = false; dataObject.RemoteInvokerID = Guid.Empty.ToString(); dataObject.EnvironmentID = Guid.Empty; dataObject.ResourceID = oldResourceId; }
public void ErrorResultTO_AddError_NullMessage() { var resultTo = new ErrorResultTO(); resultTo.AddError(null, true); Assert.IsFalse(resultTo.HasErrors()); // Shouldn't this be passing? Assert.AreEqual(0, resultTo.FetchErrors().Count); Assert.AreEqual("", resultTo.MakeDataListReady()); }
protected override void ExecuteTool(IDSFDataObject dataObject, int update) { _dataObject = dataObject; var allErrors = new ErrorResultTO(); var indexToUpsertTo = 0; InitializeDebug(dataObject); try { IExchange runtimeSource = ResourceCatalog.GetResource <ExchangeSource>(dataObject.WorkspaceID, SavedSource.ResourceID); if (runtimeSource == null) { dataObject.Environment.Errors.Add(ErrorResource.InvalidEmailSource); return; } indexToUpsertTo = TryExecute(dataObject, update, allErrors, indexToUpsertTo, runtimeSource); } catch (Exception e) { Dev2Logger.Error("DSFEmail", e, GlobalConstants.WarewolfError); allErrors.AddError(e.Message); } finally { // Handle Errors if (allErrors.HasErrors()) { foreach (var err in allErrors.FetchErrors()) { dataObject.Environment.Errors.Add(err); } UpsertResult(indexToUpsertTo, dataObject.Environment, null, update); if (dataObject.IsDebugMode()) { AddDebugOutputItem(new DebugItemStaticDataParams("", Result, "")); } DisplayAndWriteError(dataObject, DisplayName, allErrors); } if (dataObject.IsDebugMode()) { DispatchDebugState(dataObject, StateType.Before, update); DispatchDebugState(dataObject, StateType.After, update); } } }
public void ErrorResultTO_MakeDataListReady_ExpectJson_ShouldEscapeQuotesInErrorMessages() { var errorResultTo = new ErrorResultTO(); Assert.AreEqual(0, errorResultTo.FetchErrors().Count); errorResultTo.AddError("this is some exception's \"message\" string"); errorResultTo.AddError("Another \"Error\""); errorResultTo.AddError("\"Error\" message"); var makeDisplayReady = errorResultTo.MakeDataListReady(false); var result = "[ \"this is some exception's \\\"message\\\" string\",\"Another \\\"Error\\\"\",\"\\\"Error\\\" message\"]"; Assert.AreEqual(result, makeDisplayReady, "\"errors\": prefix have been removed to keep with the xml add error of this method as it seems to be the most used"); }