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