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