public void ExecutionEnvironmentUtils_GetSwaggerOutputForService_ScalarInputsNoOutputs_ValidSwaggerDefinition()
{
//------------Setup for test--------------------------
var mockResource = new Mock <IResource>();
mockResource.Setup(resource => resource.ResourceName).Returns("resourceName");
var versionInfo = new VersionInfo {
VersionNumber = "1.0"
};
mockResource.Setup(resource => resource.VersionInfo).Returns(versionInfo);
const string expectedSwaggerVersion = "\"swagger\":2";
const string expectedParameters = "\"parameters\":[" +
"{" +
"\"name\":\"Name\"," +
"\"in\":\"query\"," +
"\"required\":true," +
"\"type\":\"string\"" +
"}]";
const string expectedEmptyResponse = "\"200\":{\"schema\":{\"$ref\":\"#/definition/Output\"}}";
//------------Execute Test---------------------------
var swaggerOutputForService = ExecutionEnvironmentUtils.GetSwaggerOutputForService(mockResource.Object, "<DataList><Name Description=\"\" IsEditable=\"True\" ColumnIODirection=\"Input\" /></DataList>").Replace(Environment.NewLine, "").Replace(" ", "");
//------------Assert Results-------------------------
StringAssert.Contains(swaggerOutputForService, expectedSwaggerVersion);
StringAssert.Contains(swaggerOutputForService, expectedParameters);
StringAssert.Contains(swaggerOutputForService, expectedEmptyResponse);
}
public void ThenIHaveTheFollowingData(Table table)
{
var dataObject = ScenarioContext.Current.Get <IDSFDataObject>("DataObject");
var resultXml = XElement.Parse(ExecutionEnvironmentUtils.GetXmlOutputFromEnvironment(dataObject, Guid.Empty, "", 0));
var dataElements = resultXml.Elements().Where(element => !element.Name.LocalName.StartsWith("Dev2System") && element.Name.LocalName == "results");
using (var dataSet = new DataSet())
{
using (var reader = dataElements.ToList()[0].CreateReader())
{
dataSet.ReadXml(reader, XmlReadMode.Auto);
var dataListTable = dataSet.Tables[0];
var rowID = 0;
foreach (var tableRow in table.Rows)
{
var dataRow = dataListTable.Rows[rowID];
foreach (var header in table.Header)
{
Assert.AreEqual(dataRow[header], tableRow[header]);
}
rowID++;
}
}
}
}
public void ExecutionEnvironmentUtils_GetJsonOutputFromEnvironment_WhenDataList_WithRecordsetOutputVariable_ShouldReturnStringWithCorrectDatatype()
{
//------------Setup for test--------------------------
var dataObj = new DsfDataObject(string.Empty, Guid.NewGuid());
const string dataList = "<DataList>" +
"<User Description=\"\" IsEditable=\"True\" ColumnIODirection=\"Output\">" +
"<Name Description=\"\" IsEditable=\"True\" ColumnIODirection=\"Output\" />" +
"<Surname Description=\"\" IsEditable=\"True\" ColumnIODirection=\"Output\" />" +
"<FullName Description=\"\" IsEditable=\"True\" ColumnIODirection=\"Output\" />" +
"<Age Description=\"\" IsEditable=\"True\" ColumnIODirection=\"Output\" />" +
"<Salary Description=\"\" IsEditable=\"True\" ColumnIODirection=\"Output\" />" +
"</User>" +
"</DataList>";
dataObj.Environment.Assign("[[User().Name]]", "Bob", 0);
dataObj.Environment.Assign("[[User().Surname]]", "Mary", 0);
dataObj.Environment.Assign("[[User().FullName]]", "Bob Mary", 0);
dataObj.Environment.Assign("[[User().Age]]", "15", 0);
dataObj.Environment.Assign("[[User().Salary]]", "1550.55", 0);
//------------Execute Test---------------------------
var actual = ExecutionEnvironmentUtils.GetJsonOutputFromEnvironment(dataObj, dataList, 0);
//------------Assert Results-------------------------
StringAssert.Contains(actual, "\"Name\": \"Bob\""); //String datatype
StringAssert.Contains(actual, "\"Surname\": \"Mary\"");
StringAssert.Contains(actual, "\"FullName\": \"Bob Mary\"");
StringAssert.Contains(actual, "\"Age\": 15"); //Int datatype
StringAssert.Contains(actual, "\"Salary\": 1550.55"); //Float datatype
}
static string GetExecutePayload(IDSFDataObject dataObject, IResource resource, WebRequestTO webRequest, ref DataListFormat formatter)
{
var notDebug = !dataObject.IsDebug || dataObject.RemoteInvoke || dataObject.RemoteNonDebugInvoke;
if (notDebug && resource?.DataList != null)
{
switch (dataObject.ReturnType)
{
case EmitionTypes.XML:
{
return(ExecutionEnvironmentUtils.GetXmlOutputFromEnvironment(dataObject,
resource.DataList.ToString(), 0));
}
case EmitionTypes.SWAGGER:
{
formatter = DataListFormat.CreateFormat("SWAGGER", EmitionTypes.SWAGGER, "application/json");
return(ExecutionEnvironmentUtils.GetSwaggerOutputForService(resource,
resource.DataList.ToString(), webRequest.WebServerUrl));
}
default:
case EmitionTypes.JSON:
{
formatter = DataListFormat.CreateFormat("JSON", EmitionTypes.JSON, "application/json");
return(ExecutionEnvironmentUtils.GetJsonOutputFromEnvironment(dataObject,
resource.DataList.ToString(), 0));
}
}
}
return(string.Empty);
}
public void ExecutionEnvironmentUtils_GetJsonOutputFromEnvironment_WhenDataList_ShouldOnlyHaveVariablesMarkedAsOutputInString()
{
//------------Setup for test--------------------------
var dataObj = new DsfDataObject(string.Empty, Guid.NewGuid());
const string dataList = "<DataList>" +
"<Name Description=\"\" IsEditable=\"True\" ColumnIODirection=\"Input\"/>" +
"<Surname Description=\"\" IsEditable=\"True\" ColumnIODirection=\"None\"/>" +
"<FullName Description=\"\" IsEditable=\"True\" ColumnIODirection=\"Output\"/>" +
"<rec Description=\"\" IsEditable=\"True\" ColumnIODirection=\"Output\">" +
"<a Description=\"\" IsEditable=\"True\" ColumnIODirection=\"Output\" />" +
"<b Description=\"\" IsEditable=\"True\" ColumnIODirection=\"None\" />" +
"<c Description=\"\" IsEditable=\"True\" ColumnIODirection=\"Input\" />" +
"</rec>" +
"</DataList>";
dataObj.Environment.Assign("[[rec().a]]", "1", 0);
dataObj.Environment.Assign("[[rec().b]]", "2", 0);
dataObj.Environment.Assign("[[rec().c]]", "3", 0);
dataObj.Environment.Assign("[[Name]]", "Bob", 0);
dataObj.Environment.Assign("[[Surname]]", "Mary", 0);
dataObj.Environment.Assign("[[FullName]]", "Bob Mary", 0);
//------------Execute Test---------------------------
var actual = ExecutionEnvironmentUtils.GetJsonOutputFromEnvironment(dataObj, dataList, 0);
//------------Assert Results-------------------------
StringAssert.Contains(actual, "rec");
StringAssert.Contains(actual, "\"a\": \"1\"");
StringAssert.Contains(actual, "\"a\": \"\"");
StringAssert.Contains(actual, "\"a\": \"\"");
StringAssert.Contains(actual, "\"FullName\": \"Bob Mary\"");
Assert.IsFalse(actual.Contains("\"Name\": \"Bob\""));
Assert.IsFalse(actual.Contains("\"Surname\": \"Mary\""));
Assert.IsFalse(actual.Contains("\"b\": \"2\""));
Assert.IsFalse(actual.Contains("\"c\": \"3\""));
}
public void ExecutionEnvironmentUtils_GetOpenAPIOutputForServiceList_GivenPublicUrl_And_NonEmptyResourceList_ShouldReturnApiInfomation()
{
//------------Setup for test--------------------------
const string dataList = "<DataList>" +
"<input Description=\"\" IsEditable=\"True\" ColumnIODirection=\"Input\"/>" +
"</DataList>";
var inputPayload = new StringBuilder(dataList);
var mockWarewolfResource = new Mock <IWarewolfResource>();
mockWarewolfResource.Setup(o => o.FilePath)
.Returns(@"C:\special_folder\\Wolf\Resources_folder\workflow-one.bite");
mockWarewolfResource.Setup(o => o.DataList)
.Returns(inputPayload);
var resources = new List <IWarewolfResource>
{
mockWarewolfResource.Object
};
//------------Execute Test---------------------------
var result = ExecutionEnvironmentUtils.GetOpenAPIOutputForServiceList(resources, "http://localhost/SECURe/Wolf/Resources_folder/workflow-one.api");
//------------Assert Results-------------------------
Assert.AreEqual("{\r\n \"openapi\": \"3.0.1\",\r\n \"info\": {\r\n \"title\": \"http://localhost/SECURe/Wolf/Resources_folder/workflow-one.api\",\r\n \"description\": \"http://localhost/SECURe/Wolf/Resources_folder/workflow-one.api\",\r\n \"version\": \"1\"\r\n },\r\n \"servers\": [\r\n {\r\n \"url\": \"http://localhost\"\r\n }\r\n ],\r\n \"paths\": \r\n {\r\n \"/SECURe/Wolf/Resources_folder/workflow-one\": {\r\n \"get\": {\r\n \"tags\": [\r\n \"\"\r\n ],\r\n \"description\": \"\",\r\n \"parameters\": [\r\n {\r\n \"name\": \"input\",\r\n \"in\": \"query\",\r\n \"required\": true,\r\n \"schema\": {\r\n \"type\": \"string\"\r\n }\r\n }\r\n ],\r\n \"responses\": {\r\n \"200\": {\r\n \"description\": \"Success\",\r\n \"content\": {\r\n \"application/json\": {\r\n \"schema\": {\r\n \"type\": \"object\",\r\n \"properties\": {}\r\n }\r\n }\r\n }\r\n }\r\n }\r\n }\r\n }\r\n }\r\n \r\n}", result);
}
public void ExecutionEnvironmentUtils_GetScalarOutputFromEnvironment_ScalarInput_ShouldReturnScalarOutput()
{
var mockResource = new Mock <IWarewolfResource>();
mockResource.Setup(resource => resource.ResourceName).Returns("resourceName");
var versionInfo = new VersionInfo {
VersionNumber = "1.0"
};
mockResource.Setup(resource => resource.VersionInfo).Returns(versionInfo);
const string expectedOpenapi = "\"openapi\":\"3.0.1\"";
const string expectedInfo = "\"info\":{\"title\":\"resourceName\",\"description\":\"resourceName\",\"version\":\"1.0\"}";
const string expectedServers = "\"servers\":[{\"url\":\"http://servername\"}]";
const string expectedParameters = "\"parameters\":[{\"name\":\"Name\",\"in\":\"query\",\"required\":true,\"schema\":{\"type\":\"string\"}}]";
const string expectedRecordsetResponse = "\"responses\":{\"200\":{\"description\":\"Success\",\"content\":{\"application/json\":{\"schema\":{\"type\":\"object\",\"properties\":{\"Surname\":{\"type\":\"string\"}}}}}}}}}}}";
var swaggerOutputForService = ExecutionEnvironmentUtils.GetSwaggerOutputForService(mockResource.Object, "<DataList> <Name Description=\"\" IsEditable=\"True\" ColumnIODirection=\"Input\" /> <Surname Description=\"\" IsEditable=\"True\" ColumnIODirection=\"Output\" /></DataList>", "http://serverName:3142/public/resourceName.api").Replace(Environment.NewLine, "").Replace(" ", "");
StringAssert.Contains(swaggerOutputForService, expectedOpenapi);
StringAssert.Contains(swaggerOutputForService, expectedInfo);
StringAssert.Contains(swaggerOutputForService, expectedServers);
StringAssert.Contains(swaggerOutputForService, expectedParameters);
StringAssert.Contains(swaggerOutputForService, expectedRecordsetResponse);
}
public void ExecutionEnvironmentUtils_GetOpenAPIOutputForService_ScalarInputsNoOutputs_ValidOpenAPIDefinition()
{
//------------Setup for test--------------------------
var mockResource = new Mock <IWarewolfResource>();
mockResource.Setup(resource => resource.ResourceName).Returns("resourceName");
var versionInfo = new VersionInfo {
VersionNumber = "1.0"
};
mockResource.Setup(resource => resource.VersionInfo).Returns(versionInfo);
const string expectedOpenapi = "\"openapi\":\"3.0.1\"";
const string expectedInfo = "\"info\":{\"title\":\"resourceName\",\"description\":\"resourceName\",\"version\":\"1.0\"}";
const string expectedServers = "\"servers\":[{\"url\":\"https://servername\"}]";
const string expectedParameters = "\"parameters\":[{\"name\":\"Name\",\"in\":\"query\",\"required\":true,\"schema\":{\"type\":\"string\"}}]";
const string expectedEmptyResponse = "\"responses\":{\"200\":{\"description\":\"Success\",\"content\":{\"application/json\":{\"schema\":{\"type\":\"object\",\"properties\":{}}}}}}}}}}";
//------------Execute Test---------------------------
var openAPIOutputForService = ExecutionEnvironmentUtils.GetOpenAPIOutputForService(mockResource.Object, "<DataList><Name Description=\"\" IsEditable=\"True\" ColumnIODirection=\"Input\" /></DataList>", "https://serverName:3142/public/resourceName.api").Replace(Environment.NewLine, "").Replace(" ", "");
//------------Assert Results-------------------------
StringAssert.Contains(openAPIOutputForService, expectedOpenapi);
StringAssert.Contains(openAPIOutputForService, expectedInfo);
StringAssert.Contains(openAPIOutputForService, expectedServers);
StringAssert.Contains(openAPIOutputForService, expectedParameters);
StringAssert.Contains(openAPIOutputForService, expectedEmptyResponse);
}
public void ExecutionEnvironmentUtils_GetOpenAPIOutputForServiceList_EmptyURL_ExpectedUriFormatException()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
//------------Assert Results-------------------------
Assert.ThrowsException <UriFormatException>(() => ExecutionEnvironmentUtils.GetOpenAPIOutputForServiceList(new List <IWarewolfResource>(), string.Empty), "Invalid URI: The URI is empty.");
}
public void ExecutionEnvironmentUtils_GetSwaggerOutputForService_NullServiceName_ExpectedException()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
ExecutionEnvironmentUtils.GetSwaggerOutputForService(null, "");
//------------Assert Results-------------------------
}
public void ExecutionEnvironmentUtils_GetOpenAPIOutputForService_EmptyDataList_ExpectedException()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
ExecutionEnvironmentUtils.GetOpenAPIOutputForService(new Mock <IResource>().Object, "", "");
//------------Assert Results-------------------------
}
public void ExecutionEnvironmentUtils_GetSwaggerOutputForService_NullDataList_ExpectedException()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
ExecutionEnvironmentUtils.GetSwaggerOutputForService(new Mock <IResource>().Object, null);
//------------Assert Results-------------------------
}
public void ExecutionEnvironmentUtils_GetOpenAPIOutputForServiceList_GivenPublicUrl_And_EmptyResourceList_ShouldReturnSuccess()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
var result = ExecutionEnvironmentUtils.GetOpenAPIOutputForServiceList(new List <IWarewolfResource>(), "http://localhost/public/workflow-one.api");
//------------Assert Results-------------------------
Assert.AreEqual("{\r\n \"openapi\": \"3.0.1\",\r\n \"info\": {\r\n \"title\": \"http://localhost/public/workflow-one.api\",\r\n \"description\": \"http://localhost/public/workflow-one.api\",\r\n \"version\": \"1\"\r\n },\r\n \"servers\": [\r\n {\r\n \"url\": \"http://localhost\"\r\n }\r\n ],\r\n \"paths\": \r\n}", result);
}
/// <summary>
/// Executes the request.
/// </summary>
/// <param name="dataObject">The data object.</param>
/// <param name="request"></param>
/// <param name="workspaceId">The workspace ID.</param>
/// <param name="errors">The errors.</param>
/// <returns></returns>
public Guid ExecuteRequest(IDSFDataObject dataObject, EsbExecuteRequest request, Guid workspaceId, out ErrorResultTO errors)
{
var resultID = GlobalConstants.NullDataListID;
errors = new ErrorResultTO();
IWorkspace theWorkspace = null;
Common.Utilities.PerformActionInsideImpersonatedContext(Common.Utilities.ServerUser, () =>
{
theWorkspace = wRepository.Get(workspaceId);
});
// If no DLID, we need to make it based upon the request ;)
if (dataObject.DataListID == GlobalConstants.NullDataListID)
{
IResource resource;
try
{
resource = dataObject.ResourceID == Guid.Empty ? GetResource(workspaceId, dataObject.ServiceName) : GetResource(workspaceId, dataObject.ResourceID);
}
catch (Exception ex)
{
Dev2Logger.Error(ex);
errors.AddError(string.Format(ErrorResource.ServiceNotFound, dataObject.ServiceName));
return(resultID);
}
if (resource?.DataList != null)
{
Dev2Logger.Debug("Mapping Inputs from Environment");
ExecutionEnvironmentUtils.UpdateEnvironmentFromInputPayload(dataObject, dataObject.RawPayload, resource.DataList.ToString());
}
dataObject.RawPayload = new StringBuilder();
// We need to create the parentID around the system ;)
dataObject.ParentThreadID = Thread.CurrentThread.ManagedThreadId;
}
try
{
// Setup the invoker endpoint ;)
Dev2Logger.Debug("Creating Invoker");
using (var invoker = new EsbServiceInvoker(this, theWorkspace, request))
{
// Should return the top level DLID
ErrorResultTO invokeErrors;
resultID = invoker.Invoke(dataObject, out invokeErrors);
errors.MergeErrors(invokeErrors);
}
}
catch (Exception ex)
{
errors.AddError(ex.Message);
}
return(resultID);
}
public void ExecutionEnvironmentUtils_GetXmlOutputFromEnvironment_WhenEmptyDataList_ShouldReturnEmptyXml()
{
//------------Setup for test--------------------------
var dataObj = new DsfDataObject(string.Empty, Guid.NewGuid());
const string dataList = "<DataList></DataList>";
//------------Execute Test---------------------------
var outPutJson = ExecutionEnvironmentUtils.GetXmlOutputFromEnvironment(dataObj, dataList, 0);
//------------Assert Results-------------------------
Assert.AreEqual("<DataList />", outPutJson);
}
public void RecsetWithStarExpectedXPaths_InsideForEach_ShouldRespect_UpdateValueForRecordsetIndex()
{
_resultsCollection.Add(new XPathDTO("[[recset1(*).field1]]", "//type/method/@signature", 1));
const string dataSplitPreDataList = "<ADL><xmlData/><recset1><field1/></recset1><recset2><field2/></recset2><OutVar1/><OutVar2/><OutVar3/><OutVar4/><OutVar5/></ADL>";
var act = new DsfXPathActivity {
SourceString = Source, ResultsCollection = _resultsCollection
};
CurrentDl = dataSplitPreDataList;
TestData = "<root>" + dataSplitPreDataList + "</root>";
if (CurrentDl == null)
{
CurrentDl = TestData;
}
var dataObject = new DsfDataObject(CurrentDl, ExecutionId)
{
ServerID = Guid.NewGuid(),
ExecutingUser = User,
IsDebug = false,
EnvironmentID = new Guid(),
IsRemoteInvokeOverridden = false,
DataList = new StringBuilder(CurrentDl)
};
if (!string.IsNullOrEmpty(TestData))
{
ExecutionEnvironmentUtils.UpdateEnvironmentFromXmlPayload(dataObject, new StringBuilder(TestData), CurrentDl, 0);
}
List <string> expected = new List <string> {
"void(object)", "void(object)",
"void(Dev2.DynamicServices.IDynamicServiceObject, object)", "void(CommandLine.Text.HelpText)",
"string()", "Unlimited.Applications.WebServer.Responses.CommunicationResponseWriter(object, string, string)"
};
string error;
for (int i = 1; i < 4; i++)
{
act.Execute(dataObject, i);
}
List <string> actual = RetrieveAllRecordSetFieldValues(dataObject.Environment, "recset1", "field1", out error);
Assert.IsNotNull(actual);
Assert.AreEqual(3, actual.Count);
Assert.AreEqual("Unlimited.Applications.WebServer.Responses.CommunicationResponseWriter(object, string, string)", actual[0]);
Assert.AreEqual("Unlimited.Applications.WebServer.Responses.CommunicationResponseWriter(object, string, string)", actual[1]);
Assert.AreEqual("Unlimited.Applications.WebServer.Responses.CommunicationResponseWriter(object, string, string)", actual[2]);
}
public T FetchServerModel <T>(IDSFDataObject dataObject, Guid workspaceId, out ErrorResultTO errors, int update)
{
var serviceID = dataObject.ResourceID;
var theWorkspace = WorkspaceRepository.Instance.Get(workspaceId);
var invoker = new EsbServiceInvoker(this, this, theWorkspace);
var generateInvokeContainer = invoker.GenerateInvokeContainer(dataObject, serviceID, true);
generateInvokeContainer.Execute(out errors, update);
var convertFrom = ExecutionEnvironmentUtils.GetXmlOutputFromEnvironment(dataObject, "", update);
var jsonSerializerSettings = new JsonSerializerSettings();
var deserializeObject = JsonConvert.DeserializeObject <T>(convertFrom, jsonSerializerSettings);
return(deserializeObject);
}
private void WriteDebug(IDSFDataObject dataObject, string dataObjectExecutionId)
{
var resource = _lazyCat.GetResource(GlobalConstants.ServerWorkspaceID, dataObject.ResourceID);
var executePayload = ExecutionEnvironmentUtils.GetJsonOutputFromEnvironment(dataObject, resource.DataList.ToString(), 0);
var executionLogginResultString = GlobalConstants.ExecutionLoggingResultStartTag + (executePayload ?? "").Replace(Environment.NewLine, string.Empty) + GlobalConstants.ExecutionLoggingResultEndTag;
if (dataObject.Environment.HasErrors())
{
Dev2Logger.Error(executionLogginResultString, dataObjectExecutionId);
}
else
{
Dev2Logger.Debug(executionLogginResultString, dataObjectExecutionId);
}
}
private static RemoteWorkflowExecutionContainerMock CreateExecutionContainer(IResourceCatalog resourceCatalog, string dataListShape, string dataListData, string webResponse, IWebRequestFactory webRequestFactory, IDSFDataObject dataObj)
{
ExecutionEnvironmentUtils.UpdateEnvironmentFromXmlPayload(dataObj, new StringBuilder(dataListData), dataListShape, 0);
var sa = new ServiceAction();
var workspace = new Mock <IWorkspace>();
var esbChannel = new Mock <IEsbChannel>();
var container = new RemoteWorkflowExecutionContainerMock(sa, dataObj, workspace.Object, esbChannel.Object,
resourceCatalog, webRequestFactory)
{
GetRequestRespsonse = webResponse
};
return(container);
}
void WriteReponses(string basePath, bool isPublic, ICommunicationContext ctx)
{
var webPath = basePath.Replace("\\", "/");
var searchPath = basePath.Replace("/", "\\").Replace(".api", "");
var resourceList = ResourceCatalog.Instance.GetResourceList(GlobalConstants.ServerWorkspaceID).Where(
resource =>
resource.GetResourcePath(GlobalConstants.ServerWorkspaceID).Contains(searchPath) &&
resource.ResourceType == "WorkflowService").ToList();
var builder = new StringBuilder();
var val = ExecutionEnvironmentUtils.GetOpenAPIOutputForServiceList(new List <IWarewolfResource>(resourceList), ctx.Request.Uri.ToString());
builder.AppendLine(val);
ctx.Send(new StringResponseWriter(builder.ToString(), "application/json"));
}
public void ExecutionEnvironmentUtils_UpdateEnvironmentFromInputPayload_WithXmlChar_ShouldStillMapWhenInputAsJson()
{
var dataObj = new DsfDataObject(string.Empty, Guid.NewGuid());
const string dataList = "<DataList>" +
"<input Description=\"\" IsEditable=\"True\" ColumnIODirection=\"Input\"/>" +
"</DataList>";
var inputPayload = new StringBuilder("{\"input\":\"123<1234\"}");
ExecutionEnvironmentUtils.UpdateEnvironmentFromInputPayload(dataObj, inputPayload, dataList);
Assert.IsNotNull(dataObj.Environment);
var values = dataObj.Environment.EvalAsListOfStrings("[[input]]", 0);
Assert.IsNotNull(values);
Assert.AreEqual(1, values.Count);
Assert.AreEqual("123<1234", values[0]);
}
private static bool EnsureDataListIdIsSet(IDSFDataObject dataObject, Guid workspaceId, ErrorResultTO errors)
{
if (dataObject.DataListID == GlobalConstants.NullDataListID)
{
var resource = GetResource(dataObject, workspaceId, errors);
if (resource?.HasDataList ?? false)
{
Dev2Logger.Debug("Remote Invoke", dataObject.ExecutionID.ToString());
Dev2Logger.Debug("Mapping Inputs from Environment", dataObject.ExecutionID.ToString());
ExecutionEnvironmentUtils.UpdateEnvironmentFromInputPayload(dataObject, dataObject.RawPayload, resource.DataList.ToString());
}
dataObject.RawPayload = new StringBuilder();
// We need to create the parentID around the system
dataObject.ParentThreadID = Thread.CurrentThread.ManagedThreadId;
}
return(true);
}
public override Guid Execute(out ErrorResultTO errors, int update)
{
#pragma warning disable CC0021
Dev2Logger.Info($"Starting Remote Execution. Service Name:{DataObject.ServiceName} Resource Id:{DataObject.ResourceID} Mode:{(DataObject.IsDebug ? "Debug" : "Execute")}", GlobalConstants.WarewolfInfo);
#pragma warning restore CC0021
var serviceName = DataObject.ServiceName;
errors = new ErrorResultTO();
Dev2Logger.Debug("Creating DataList fragment for remote execute", GlobalConstants.WarewolfDebug);
var dataListFragment = ExecutionEnvironmentUtils.GetXmlInputFromEnvironment(DataObject, DataObject.RemoteInvokeResultShape.ToString(), update);
var result = string.Empty;
var connection = GetConnection(DataObject.EnvironmentID);
if (connection == null)
{
errors.AddError(ErrorResource.ServiceNotFound);
return(DataObject.DataListID);
}
try
{
result = ExecutePostRequest(connection, serviceName, dataListFragment);
var msg = DataObject.IsDebug ? FetchRemoteDebugItems(connection) : new List <IDebugState>();
DataObject.RemoteDebugItems = msg; // set them so they can be acted upon
}
catch (Exception e)
{
var errorMessage = e.Message.Contains("Forbidden") ? "Executing a service requires Execute permissions" : e.Message;
DataObject.Environment.Errors.Add(errorMessage);
Dev2Logger.Error(e, GlobalConstants.WarewolfError);
}
// Create tmpDL
ExecutionEnvironmentUtils.UpdateEnvironmentFromOutputPayload(DataObject, result.ToStringBuilder(), DataObject.RemoteInvokeResultShape.ToString());
#pragma warning disable CC0021
Dev2Logger.Info($"Completed Remote Execution. Service Name:{DataObject.ServiceName} Resource Id:{DataObject.ResourceID} Mode:{(DataObject.IsDebug ? "Debug" : "Execute")}", GlobalConstants.WarewolfInfo);
#pragma warning restore CC0021
return(Guid.Empty);
}
public override Guid Execute(out ErrorResultTO errors, int update)
{
Dev2Logger.Log.Info(String.Format("Starting Remote Execution. Service Name:{0} Resource Id:{1} Mode:{2}", DataObject.ServiceName, DataObject.ResourceID, DataObject.IsDebug ? "Debug" : "Execute"));
var serviceName = DataObject.ServiceName;
errors = new ErrorResultTO();
// get data in a format we can send ;)
Dev2Logger.Log.Debug("Creating DataList fragment for remote execute");
var dataListFragment = ExecutionEnvironmentUtils.GetXmlInputFromEnvironment(DataObject, DataObject.WorkspaceID, DataObject.RemoteInvokeResultShape.ToString(), update);
string result = string.Empty;
var connection = GetConnection(DataObject.EnvironmentID);
if (connection == null)
{
errors.AddError("Server source not found.");
return(DataObject.DataListID);
}
try
{
// Invoke Remote WF Here ;)
result = ExecuteGetRequest(connection, serviceName, dataListFragment);
IList <IDebugState> msg = FetchRemoteDebugItems(connection);
DataObject.RemoteDebugItems = msg; // set them so they can be acted upon
}
catch (Exception e)
{
var errorMessage = e.Message.Contains("Forbidden") ? "Executing a service requires Execute permissions" : e.Message;
DataObject.Environment.Errors.Add(errorMessage);
Dev2Logger.Log.Error(e);
}
// Create tmpDL
ExecutionEnvironmentUtils.UpdateEnvironmentFromOutputPayload(DataObject, result.ToStringBuilder(), DataObject.RemoteInvokeResultShape.ToString(), update);
Dev2Logger.Log.Info(String.Format("Completed Remote Execution. Service Name:{0} Resource Id:{1} Mode:{2}", DataObject.ServiceName, DataObject.ResourceID, DataObject.IsDebug ? "Debug" : "Execute"));
return(Guid.Empty);
}
static RemoteWorkflowExecutionContainerMock CreateExecutionContainer(IResourceCatalog resourceCatalog, string dataListShape = "<DataList></DataList>", string dataListData = "")
{
var dataObj = new Mock <IDSFDataObject>();
dataObj.Setup(d => d.EnvironmentID).Returns(_connection.ResourceID);
dataObj.Setup(d => d.ServiceName).Returns("Test");
dataObj.Setup(d => d.RemoteInvokeResultShape).Returns(new StringBuilder("<ADL><NumericGUID></NumericGUID></ADL>"));
dataObj.Setup(d => d.Environment).Returns(new ExecutionEnvironment());
ExecutionEnvironmentUtils.UpdateEnvironmentFromXmlPayload(dataObj.Object, new StringBuilder(dataListData), dataListShape, 0);
var sa = new ServiceAction();
var workspace = new Mock <IWorkspace>();
var esbChannel = new Mock <IEsbChannel>();
var container = new RemoteWorkflowExecutionContainerMock(sa, dataObj.Object, workspace.Object, esbChannel.Object, resourceCatalog)
{
GetRequestRespsonse = "<DataList><NumericGUID>74272317-2264-4564-3988-700350008298</NumericGUID></DataList>"
};
return(container);
}
public void ExecutionEnvironmentUtils_GetXmlOutputFromEnvironment_WhenHasRecordset_ShouldNotError()
{
//------------Setup for test--------------------------
var dataObj = new DsfDataObject(string.Empty, Guid.NewGuid());
const string dataList = "<DataList>" +
"<rec Description=\"\" IsEditable=\"True\" ColumnIODirection=\"Output\">" +
"<a Description=\"\" IsEditable=\"True\" ColumnIODirection=\"Output\" />" +
"</rec>" +
"</DataList>";
dataObj.Environment.Assign("[[rec().a]]", "1", 0);
dataObj.Environment.Assign("[[rec().a]]", "2", 0);
//------------Execute Test---------------------------
var actual = ExecutionEnvironmentUtils.GetXmlOutputFromEnvironment(dataObj, dataList, 0);
//------------Assert Results-------------------------
StringAssert.Contains(actual, "<DataList>");
StringAssert.Contains(actual, "<rec>");
StringAssert.Contains(actual, "<a>1</a>");
StringAssert.Contains(actual, "<a>2</a>");
StringAssert.Contains(actual, "</rec>");
StringAssert.Contains(actual, "</DataList>");
}
public void ExecutionEnvironmentUtils_GetSwaggerOutputForService_NoInputsNoOutputs_ValidSwaggerDefinition()
{
//------------Setup for test--------------------------
var mockResource = new Mock <IResource>();
mockResource.Setup(resource => resource.ResourceName).Returns("resourceName");
var versionInfo = new VersionInfo {
VersionNumber = "1.0"
};
mockResource.Setup(resource => resource.VersionInfo).Returns(versionInfo);
const string expectedSwaggerVersion = "\"swagger\":2";
const string expectedEmptyParameters = "\"parameters\":[]";
const string expectedEmptyResponse = "\"200\":{\"schema\":{\"$ref\":\"#/definition/Output\"}}";
//------------Execute Test---------------------------
var swaggerOutputForService = ExecutionEnvironmentUtils.GetSwaggerOutputForService(mockResource.Object, "<DataList></DataList>").Replace(Environment.NewLine, "").Replace(" ", "");
//------------Assert Results-------------------------
StringAssert.Contains(swaggerOutputForService, expectedSwaggerVersion);
StringAssert.Contains(swaggerOutputForService, expectedEmptyParameters);
StringAssert.Contains(swaggerOutputForService, expectedEmptyResponse);
}
public void ExecutionEnvironmentUtils_GetOpenAPIOutputForServiceList_GivenBadServerUrl_ShouldReturnUriFormatException()
{
//------------Setup for test--------------------------
const string dataList = "<DataList>" +
"<input Description=\"\" IsEditable=\"True\" ColumnIODirection=\"Input\"/>" +
"</DataList>";
var inputPayload = new StringBuilder(dataList);
var mockWarewolfResource = new Mock <IWarewolfResource>();
mockWarewolfResource.Setup(o => o.FilePath)
.Returns(@"C:\special_folder\Warewolf\workflow-one.xml");
mockWarewolfResource.Setup(o => o.DataList)
.Returns(inputPayload);
var resources = new List <IWarewolfResource>
{
mockWarewolfResource.Object
};
//------------Execute Test---------------------------
Assert.ThrowsException <UriFormatException>(() => ExecutionEnvironmentUtils.GetOpenAPIOutputForServiceList(resources, "localhost/SECURe/workflow-one.api"), "Invalid URI: The format of the URI could not be determined.");
//------------Assert Results-------------------------
}
protected static IResponseWriter CreateForm(WebRequestTO webRequest, string serviceName, string workspaceId, NameValueCollection headers, IPrincipal user = null)
{
//lock(ExecutionObject)
{
string executePayload = "";
Guid workspaceGuid;
if (workspaceId != null)
{
if (!Guid.TryParse(workspaceId, out workspaceGuid))
{
workspaceGuid = WorkspaceRepository.Instance.ServerWorkspace.ID;
}
}
else
{
workspaceGuid = WorkspaceRepository.Instance.ServerWorkspace.ID;
}
var allErrors = new ErrorResultTO();
var dataObject = new DsfDataObject(webRequest.RawRequestPayload, GlobalConstants.NullDataListID, webRequest.RawRequestPayload)
{
IsFromWebServer = true, ExecutingUser = user, ServiceName = serviceName, WorkspaceID = workspaceGuid
};
// now bind any variables that are part of the path arguments ;)
BindRequestVariablesToDataObject(webRequest, ref dataObject);
// now process headers ;)
if (headers != null)
{
Dev2Logger.Log.Debug("Remote Invoke");
var isRemote = headers.Get(HttpRequestHeader.Cookie.ToString());
var remoteId = headers.Get(HttpRequestHeader.From.ToString());
if (isRemote != null && remoteId != null)
{
if (isRemote.Equals(GlobalConstants.RemoteServerInvoke))
{
// we have a remote invoke ;)
dataObject.RemoteInvoke = true;
}
if (isRemote.Equals(GlobalConstants.RemoteDebugServerInvoke))
{
// we have a remote invoke ;)
dataObject.RemoteNonDebugInvoke = true;
}
dataObject.RemoteInvokerID = remoteId;
}
}
// now set the emition type ;)
int loc;
if (!String.IsNullOrEmpty(serviceName) && (loc = serviceName.LastIndexOf(".", StringComparison.Ordinal)) > 0)
{
// default it to xml
dataObject.ReturnType = EmitionTypes.XML;
if (loc > 0)
{
var typeOf = serviceName.Substring((loc + 1)).ToUpper();
EmitionTypes myType;
if (Enum.TryParse(typeOf, out myType))
{
dataObject.ReturnType = myType;
}
// adjust the service name to drop the type ;)
// avoid .wiz amendments ;)
if (!typeOf.ToLower().Equals(GlobalConstants.WizardExt))
{
serviceName = serviceName.Substring(0, loc);
dataObject.ServiceName = serviceName;
}
if (typeOf.Equals("api", StringComparison.OrdinalIgnoreCase))
{
dataObject.ReturnType = EmitionTypes.SWAGGER;
}
}
}
else
{
// default it to xml
dataObject.ReturnType = EmitionTypes.XML;
}
// ensure service gets set ;)
if (dataObject.ServiceName == null)
{
dataObject.ServiceName = serviceName;
}
IResource resource = null;
if (!String.IsNullOrEmpty(dataObject.ServiceName))
{
resource = ResourceCatalog.Instance.GetResource(dataObject.WorkspaceID, dataObject.ServiceName);
if (resource != null)
{
dataObject.ResourceID = resource.ResourceID;
}
}
var esbEndpoint = new EsbServicesEndpoint();
dataObject.EsbChannel = esbEndpoint;
var canExecute = true;
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) || ((dataObject.RemoteInvoke || dataObject.RemoteNonDebugInvoke) && hasExecute) || (resource != null && resource.ResourceType == ResourceType.ReservedService);
}
// Build EsbExecutionRequest - Internal Services Require This ;)
EsbExecuteRequest esbExecuteRequest = new EsbExecuteRequest {
ServiceName = serviceName
};
foreach (string key in webRequest.Variables)
{
esbExecuteRequest.AddArgument(key, new StringBuilder(webRequest.Variables[key]));
}
Dev2Logger.Log.Debug("About to execute web request [ " + serviceName + " ] DataObject Payload [ " + dataObject.RawPayload + " ]");
var executionDlid = GlobalConstants.NullDataListID;
if (canExecute && dataObject.ReturnType != EmitionTypes.SWAGGER)
{
ErrorResultTO errors;
executionDlid = esbEndpoint.ExecuteRequest(dataObject, esbExecuteRequest, workspaceGuid, out errors);
allErrors.MergeErrors(errors);
}
else if (!canExecute)
{
allErrors.AddError("Executing a service externally requires View and Execute permissions");
}
foreach (var error in dataObject.Environment.Errors)
{
allErrors.AddError(error, true);
}
// Fetch return type ;)
var formatter = DataListFormat.CreateFormat("XML", EmitionTypes.XML, "text/xml");
// force it to XML if need be ;)
// Fetch and convert DL ;)
if (!dataObject.Environment.HasErrors())
{
// a normal service request
if (!esbExecuteRequest.WasInternalService)
{
dataObject.DataListID = executionDlid;
dataObject.WorkspaceID = workspaceGuid;
dataObject.ServiceName = serviceName;
if (!dataObject.IsDebug || dataObject.RemoteInvoke || dataObject.RemoteNonDebugInvoke)
{
if (dataObject.ReturnType == EmitionTypes.JSON)
{
formatter = DataListFormat.CreateFormat("JSON", EmitionTypes.JSON, "application/json");
executePayload = ExecutionEnvironmentUtils.GetJsonOutputFromEnvironment(dataObject, resource.DataList.ToString(), 0);
}
else if (dataObject.ReturnType == EmitionTypes.XML)
{
executePayload = ExecutionEnvironmentUtils.GetXmlOutputFromEnvironment(dataObject, Guid.Empty, resource.DataList.ToString(), 0);
}
else if (dataObject.ReturnType == EmitionTypes.SWAGGER)
{
formatter = DataListFormat.CreateFormat("SWAGGER", EmitionTypes.SWAGGER, "application/json");
executePayload = ExecutionEnvironmentUtils.GetSwaggerOutputForService(resource, resource.DataList.ToString());
}
}
else
{
executePayload = string.Empty;
}
}
else
{
// internal service request we need to return data for it from the request object ;)
var serializer = new Dev2JsonSerializer();
executePayload = string.Empty;
var msg = serializer.Deserialize <ExecuteMessage>(esbExecuteRequest.ExecuteResult);
if (msg != null)
{
executePayload = msg.Message.ToString();
}
// out fail safe to return different types of data from services ;)
if (string.IsNullOrEmpty(executePayload))
{
executePayload = esbExecuteRequest.ExecuteResult.ToString();
}
}
}
else
{
if (dataObject.ReturnType == EmitionTypes.XML)
{
executePayload =
"<FatalError> <Message> An internal error occurred while executing the service request </Message>";
executePayload += allErrors.MakeDataListReady();
executePayload += "</FatalError>";
}
else
{
// convert output to JSON ;)
executePayload =
"{ \"FatalError\": \"An internal error occurred while executing the service request\",";
executePayload += allErrors.MakeDataListReady(false);
executePayload += "}";
}
}
Dev2Logger.Log.Debug("Execution Result [ " + executePayload + " ]");
// JSON Data ;)
if (executePayload.IndexOf("</JSON>", StringComparison.Ordinal) >= 0)
{
int start = executePayload.IndexOf(GlobalConstants.OpenJSON, StringComparison.Ordinal);
if (start >= 0)
{
int end = executePayload.IndexOf(GlobalConstants.CloseJSON, StringComparison.Ordinal);
start += GlobalConstants.OpenJSON.Length;
executePayload = CleanupHtml(executePayload.Substring(start, (end - start)));
if (!String.IsNullOrEmpty(executePayload))
{
return(new StringResponseWriter(executePayload, ContentTypes.Json));
}
}
}
Dev2DataListDecisionHandler.Instance.RemoveEnvironment(dataObject.DataListID);
dataObject.Environment = null;
return(new StringResponseWriter(executePayload, formatter.ContentType));
}
}
protected IDSFDataObject ExecuteProcess(IDSFDataObject dataObject = null, bool isDebug = false, IEsbChannel channel = null, bool isRemoteInvoke = false, bool throwException = true, bool isDebugMode = false, Guid currentEnvironmentId = default(Guid), bool overrideRemote = false)
{
using (ServiceAction svc = new ServiceAction {
Name = "TestAction", ServiceName = "UnitTestService"
})
{
svc.SetActivity(FlowchartProcess);
var mockChannel = new Mock <IEsbChannel>();
if (CurrentDl == null)
{
CurrentDl = TestData;
}
var errors = new ErrorResultTO();
if (ExecutionId == Guid.Empty)
{
if (dataObject != null)
{
dataObject.ExecutingUser = User;
dataObject.DataList = new StringBuilder(CurrentDl);
}
}
if (errors.HasErrors())
{
var errorString = errors.FetchErrors().Aggregate(string.Empty, (current, item) => current + item);
if (throwException)
{
throw new Exception(errorString);
}
}
if (dataObject == null)
{
dataObject = new DsfDataObject(CurrentDl, ExecutionId)
{
// NOTE: WorkflowApplicationFactory.InvokeWorkflowImpl() will use HostSecurityProvider.Instance.ServerID
// if this is NOT provided which will cause the tests to fail!
ServerID = Guid.NewGuid(),
ExecutingUser = User,
IsDebug = isDebugMode,
EnvironmentID = currentEnvironmentId,
IsRemoteInvokeOverridden = overrideRemote,
DataList = new StringBuilder(CurrentDl)
};
}
if (!string.IsNullOrEmpty(TestData))
{
ExecutionEnvironmentUtils.UpdateEnvironmentFromXmlPayload(DataObject, new StringBuilder(TestData), CurrentDl, 0);
}
dataObject.IsDebug = isDebug;
// we now need to set a thread ID ;)
dataObject.ParentThreadID = 1;
if (isRemoteInvoke)
{
dataObject.RemoteInvoke = true;
dataObject.RemoteInvokerID = Guid.NewGuid().ToString();
}
var esbChannel = mockChannel.Object;
if (channel != null)
{
esbChannel = channel;
}
dataObject.ExecutionToken = new ExecutionToken();
var wfec = new WfExecutionContainer(svc, dataObject, WorkspaceRepository.Instance.ServerWorkspace, esbChannel);
errors.ClearErrors();
CustomContainer.Register <IActivityParser>(new ActivityParser());
if (dataObject.ResourceID == Guid.Empty)
{
dataObject.ResourceID = Guid.NewGuid();
}
dataObject.Environment = DataObject.Environment;
wfec.Eval(FlowchartProcess, dataObject, 0);
DataObject = dataObject;
return(dataObject);
}
}
