public void Constructor_GivenArgs_ShouldPassThrough() { //---------------Set up test pack------------------- const string Datalist = "<DataList><scalar1 ColumnIODirection=\"Input\"/><persistantscalar ColumnIODirection=\"Input\"/><rs><f1 ColumnIODirection=\"Input\"/><f2 ColumnIODirection=\"Input\"/></rs><recset><field1/><field2/></recset></DataList>"; var serviceAction = new ServiceAction() { DataListSpecification = new StringBuilder(Datalist) }; var dsfObj = new Mock <IDSFDataObject>(); dsfObj.Setup(o => o.Environment).Returns(new ExecutionEnvironment()); dsfObj.Setup(o => o.Environment.Eval(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <bool>(), false)) .Returns(CommonFunctions.WarewolfEvalResult.NewWarewolfAtomResult(DataStorage.WarewolfAtom.NewDataString("Args"))); var workSpace = new Mock <IWorkspace>(); var channel = new Mock <IEsbChannel>(); var esbExecuteRequest = new EsbExecuteRequest(); var serviceTestExecutionContainer = new ServiceTestExecutionContainerMock(serviceAction, dsfObj.Object, workSpace.Object, channel.Object, esbExecuteRequest); //---------------Assert Precondition---------------- Assert.IsNotNull(serviceTestExecutionContainer); //---------------Execute Test ---------------------- //---------------Test Result ----------------------- Assert.IsNull(serviceTestExecutionContainer.InstanceOutputDefinition); Assert.IsNull(serviceTestExecutionContainer.InstanceInputDefinition); }
public static async Task GetTaskForTestExecution(string serviceName, IPrincipal userPrinciple, Guid workspaceGuid, Dev2JsonSerializer serializer, ICollection <IServiceTestModelTO> testResults, IDSFDataObject dataObjectClone) { var lastTask = Task.Run(() => { var interTestRequest = new EsbExecuteRequest { ServiceName = serviceName }; var dataObjectToUse = dataObjectClone; Common.Utilities.PerformActionInsideImpersonatedContext(userPrinciple, () => { var esbEndpointClone = new EsbServicesEndpoint(); ErrorResultTO errs; esbEndpointClone.ExecuteRequest(dataObjectToUse, interTestRequest, workspaceGuid, out errs); }); var result = serializer.Deserialize <ServiceTestModelTO>(interTestRequest.ExecuteResult); if (result == null) { if (interTestRequest.ExecuteResult != null) { var r = serializer.Deserialize <TestRunResult>(interTestRequest.ExecuteResult.ToString()) ?? new TestRunResult { TestName = dataObjectToUse.TestName }; result = new ServiceTestModelTO { Result = r, TestName = r.TestName }; } } Dev2DataListDecisionHandler.Instance.RemoveEnvironment(dataObjectToUse.DataListID); dataObjectToUse.Environment = null; testResults.Add(result); }); await lastTask; }
public void OnConstruction_GivenValidArgs_ShouldBuildCorrectly() { //---------------Set up test pack------------------- //InternalServiceContainer(ServiceAction sa, IDSFDataObject dataObj, IWorkspace theWorkspace, IEsbChannel esbChannel, EsbExecuteRequest request) const string datalist = "<DataList><scalar1 ColumnIODirection=\"Input\"/><persistantscalar ColumnIODirection=\"Input\"/><rs><f1 ColumnIODirection=\"Input\"/><f2 ColumnIODirection=\"Input\"/></rs><recset><field1/><field2/></recset></DataList>"; var serviceAction = new ServiceAction() { DataListSpecification = new StringBuilder(datalist) }; var dsfObj = new Mock <IDSFDataObject>(); dsfObj.Setup(o => o.Environment).Returns(new ExecutionEnvironment()); dsfObj.Setup(o => o.Environment.Eval(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <bool>(), false)) .Returns(CommonFunctions.WarewolfEvalResult.NewWarewolfAtomResult(DataStorage.WarewolfAtom.NewDataString("Args"))); var workSpace = new Mock <IWorkspace>(); var channel = new Mock <IEsbChannel>(); var esbExecuteRequest = new EsbExecuteRequest(); //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- var internalServiceContainer = new InternalServiceContainer(serviceAction, dsfObj.Object, workSpace.Object, channel.Object, esbExecuteRequest); //---------------Test Result ----------------------- Assert.AreEqual(4, esbExecuteRequest.Args.Count); Assert.IsNotNull(internalServiceContainer, "Cannot create new InternalServiceContainer object."); }
public void GenerateInvokeContainer_masterDataListId_GivenValidArgsAndIsLocalInvokeTrueCacheContainsRemoteService_ShouldCorrectServiceInContainer() { //---------------Set up test pack------------------- var serviceId = Guid.NewGuid(); var _cache = new ConcurrentDictionary <Guid, ServiceAction>(); //GenerateInvokeContainer(IDSFDataObject dataObject, String serviceName, bool isLocalInvoke, Guid masterDataListId = default(Guid)) var channel = new Mock <IEsbChannel>(); var workSpace = new Mock <IWorkspace>(); var obj = new Mock <IDSFDataObject>(); var locater = new Mock <IServiceLocator>(); obj.SetupGet(o => o.ResourceID).Returns(serviceId); var executeRequest = new EsbExecuteRequest { Args = new Dictionary <string, StringBuilder>(), ServiceName = "SomeService" }; locater.Setup(l => l.FindService(It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(new DynamicService { ID = serviceId, Actions = { new ServiceAction { Name = "Name" , ActionType = enActionType.InvokeManagementDynamicService , ServiceID = serviceId , SourceName = "SourceName" } } }); locater.Setup(lo => lo.FindSourceByName("SourceName", It.IsAny <Guid>())).Returns(new Source()); var invoker = new EsbServiceInvoker(channel.Object, workSpace.Object, executeRequest); var privateObject = new PrivateObject(invoker); privateObject.SetField("_serviceLocator", locater.Object); privateObject.SetField("_cache", _cache); //---------------Assert Precondition---------------- Assert.IsNotNull(invoker); //---------------Execute Test ---------------------- try { var executionContainer = invoker.GenerateInvokeContainer(obj.Object, "Name", true, serviceId); //---------------Test Result ----------------------- Assert.IsNotNull(executionContainer); obj.VerifyGet(o => o.ResourceID); var condition = executionContainer is InternalServiceContainer; Assert.AreEqual(1, _cache.Count); Assert.IsTrue(condition); locater.VerifyAll(); } catch (Exception e) { //Expected break for Web services, Assert.AreEqual("Root element is missing.", e.Message); } }
public static Task <IServiceTestModelTO> ExecuteTestAsync(string serviceName, IPrincipal userPrinciple, Guid workspaceGuid, Dev2JsonSerializer serializer, IDSFDataObject dataObjectClone) { var lastTask = Task <IServiceTestModelTO> .Factory.StartNew(() => { var interTestRequest = new EsbExecuteRequest { ServiceName = serviceName }; var dataObjectToUse = dataObjectClone; Common.Utilities.PerformActionInsideImpersonatedContext(userPrinciple, () => { var esbEndpointClone = new EsbServicesEndpoint(); esbEndpointClone.ExecuteRequest(dataObjectToUse, interTestRequest, workspaceGuid, out _); }); var result = serializer.Deserialize <ServiceTestModelTO>(interTestRequest.ExecuteResult); if (result == null && interTestRequest.ExecuteResult != null) { var r = serializer.Deserialize <TestRunResult>(interTestRequest.ExecuteResult.ToString()) ?? new TestRunResult { TestName = dataObjectToUse.TestName }; result = new ServiceTestModelTO { Result = r, TestName = r.TestName }; } Dev2DataListDecisionHandler.Instance.RemoveEnvironment(dataObjectToUse.DataListID); dataObjectToUse.Environment = null; return(result); }); lastTask.ConfigureAwait(true); return(lastTask); }
/// <summary> /// Executes the command. /// </summary> /// <param name="connection">The connection.</param> /// <param name="workspaceId">The workspace unique identifier.</param> /// <returns></returns> public async Task <T> ExecuteCommandAsync <T>(IEnvironmentConnection connection, Guid workspaceId) { // build the service request payload ;) var serializer = new Dev2JsonSerializer(); if (connection == null || !connection.IsConnected) { if (connection != null) { var popupController = CustomContainer.Get <IPopupController>(); if (popupController != null && connection.HubConnection.State == ConnectionStateWrapped.Disconnected) { popupController.Show(string.Format("Server: {0} has disconnected.", connection.DisplayName) + Environment.NewLine + "Please reconnect before performing any actions", "Disconnected Server", MessageBoxButton.OK, MessageBoxImage.Information, ""); } } } else { // now bundle it up into a nice string builder ;) if (ServicePayload == null) { ServicePayload = new EsbExecuteRequest(); } ServicePayload.ServiceName = ServiceName; StringBuilder toSend = serializer.SerializeToBuilder(ServicePayload); var payload = await connection.ExecuteCommandAsync(toSend, workspaceId); return(serializer.Deserialize <T>(payload)); } return(default(T)); }
public void Invoke_GivenServiceNameAndEmptyId_ShouldFindByName() { //---------------Set up test pack------------------- var channel = new Mock <IEsbChannel>(); var workSpace = new Mock <IWorkspace>(); var obj = new Mock <IDSFDataObject>(); obj.Setup(o => o.Environment.HasErrors()).Returns(false); obj.Setup(o => o.ServiceName).Returns("Hello World"); var locater = new Mock <IServiceLocator>(); var executeRequest = new EsbExecuteRequest { Args = new Dictionary <string, StringBuilder>(), ServiceName = "SomeService" }; locater.Setup(lo => lo.FindService("Hello World", It.IsAny <Guid>())).Returns(new DynamicService()); var invoker = new EsbServiceInvoker(channel.Object, workSpace.Object, executeRequest); var privateObject = new PrivateObject(invoker); privateObject.SetField("_serviceLocator", locater.Object); //---------------Assert Precondition---------------- Assert.IsNotNull(invoker); //---------------Execute Test ---------------------- invoker.Invoke(obj.Object, out ErrorResultTO errorResultTO); //---------------Test Result ----------------------- Assert.IsNotNull(errorResultTO); Assert.AreEqual(0, errorResultTO.FetchErrors().Count); locater.VerifyAll(); }
public void Execute_GivenService_ShouldAddBuildRequestArgs() { //---------------Set up test pack------------------- const string datalist = "<DataList><scalar1 ColumnIODirection=\"Input\"/><persistantscalar ColumnIODirection=\"Input\"/><rs><f1 ColumnIODirection=\"Input\"/><f2 ColumnIODirection=\"Input\"/></rs><recset><field1/><field2/></recset></DataList>"; var serviceAction = new ServiceAction() { DataListSpecification = new StringBuilder(datalist), ServiceName = "name", Name = "Name" }; var dsfObj = new Mock <IDSFDataObject>(); dsfObj.Setup(o => o.Environment).Returns(new ExecutionEnvironment()); dsfObj.Setup(o => o.Environment.Eval(It.IsAny <string>(), It.IsAny <int>())) .Returns(CommonFunctions.WarewolfEvalResult.NewWarewolfAtomResult(DataStorage.WarewolfAtom.NewDataString("Args"))); var workSpace = new Mock <IWorkspace>(); var channel = new Mock <IEsbChannel>(); var esbExecuteRequest = new EsbExecuteRequest(); var locater = new Mock <IEsbManagementServiceLocator>(); locater.Setup(loc => loc.LocateManagementService("Name")).Returns(new FetchPluginSources()); var internalServiceContainer = new InternalServiceContainer(serviceAction, dsfObj.Object, workSpace.Object, channel.Object, esbExecuteRequest, locater.Object); //---------------Assert Precondition---------------- Assert.AreEqual(4, esbExecuteRequest.Args.Count); //---------------Execute Test ---------------------- var execute = internalServiceContainer.Execute(out ErrorResultTO errorResultTO, 1); //---------------Test Result ----------------------- locater.VerifyAll(); }
public void JsonSerializer_SerializeToBuffer_WhenEsbExecuteRequest_ValidObjectStringBuffer() { //------------Setup for test-------------------------- Dev2JsonSerializer js = new Dev2JsonSerializer(); EsbExecuteRequest request = new EsbExecuteRequest { ServiceName = "Foobar" }; request.AddArgument("key1", new StringBuilder("value1")); request.AddArgument("key2", new StringBuilder("value2")); //------------Execute Test--------------------------- var result = js.SerializeToBuilder(request); //------------Assert Results------------------------- Assert.AreEqual(679, result.Length); var resultObj = js.Deserialize <EsbExecuteRequest>(result); // check service name hydration Assert.AreEqual(request.ServiceName, resultObj.ServiceName); // ensure args hydrate ;) Assert.AreEqual(request.Args["key1"].ToString(), resultObj.Args["key1"].ToString()); Assert.AreEqual(request.Args["key2"].ToString(), resultObj.Args["key2"].ToString()); }
private StringBuilder ProcessRequest(EsbExecuteRequest request, Guid workspaceId, EsbServicesEndpoint channel, IDSFDataObject dataObject, bool isManagementResource) { if (ExecutingUser == null) { throw new Exception(ErrorResource.NullExecutingUser); } try { var t = new Thread(() => { TryExecuteRequest(request, workspaceId, channel, dataObject, isManagementResource); }); t.Start(); t.Join(); } catch (Exception e) { Dev2Logger.Error(e.Message, e, GlobalConstants.WarewolfError); } if (request.ExecuteResult.Length > 0) { return(request.ExecuteResult); } return(new StringBuilder()); }
private static void CheckServerVersion(IHubProxy proxy) { Dev2JsonSerializer serializer = new Dev2JsonSerializer(); var esbExecuteRequest = new EsbExecuteRequest { ServiceName = "GetServerVersion" }; Envelope envelope = new Envelope { Content = serializer.Serialize(esbExecuteRequest), Type = typeof(Envelope) }; var messageId = Guid.NewGuid(); proxy.Invoke <Receipt>("ExecuteCommand", envelope, true, Guid.Empty, Guid.Empty, messageId).Wait(); Task <string> fragmentInvoke = proxy.Invoke <string>("FetchExecutePayloadFragment", new FutureReceipt { PartID = 0, RequestID = messageId }); var serverVersion = fragmentInvoke.Result; if (!string.IsNullOrEmpty(serverVersion)) { Version sourceVersionNumber; Version.TryParse(serverVersion, out sourceVersionNumber); Version destVersionNumber; Version.TryParse("0.0.0.6", out destVersionNumber); if (sourceVersionNumber != null && destVersionNumber != null) { if (sourceVersionNumber < destVersionNumber) { throw new VersionConflictException(sourceVersionNumber, destVersionNumber); } } } }
public void GenerateInvokeContainer_masterDataListId_GivenValidArgsAndIsNotLocalInvoke_ShouldReturnRemoteExecutionContainer() { //---------------Set up test pack------------------- var serviceId = Guid.NewGuid(); var channel = new Mock <IEsbChannel>(); var workSpace = new Mock <IWorkspace>(); var obj = new Mock <IDSFDataObject>(); var locater = new Mock <IServiceLocator>(); var executeRequest = new EsbExecuteRequest { Args = new Dictionary <string, StringBuilder>(), ServiceName = "SomeService" }; locater.Setup(lo => lo.FindSourceByName("SourceName", It.IsAny <Guid>())).Returns(new Source()); var invoker = new EsbServiceInvoker(channel.Object, workSpace.Object, executeRequest); var privateObject = new PrivateObject(invoker); privateObject.SetField("_serviceLocator", locater.Object); //---------------Assert Precondition---------------- Assert.IsNotNull(invoker); //---------------Execute Test ---------------------- var executionContainer = invoker.GenerateInvokeContainer(obj.Object, "Name", false, serviceId); //---------------Test Result ----------------------- Assert.IsNotNull(executionContainer); var isRemoteWorkFlowExecution = executionContainer is RemoteWorkflowExecutionContainer; Assert.IsTrue(isRemoteWorkFlowExecution); }
public void GenerateRequestDictionaryFromDataObject_GivenValidArgs_ShouldClearArgsAndErros() { const string datalist = "<DataList><scalar1 ColumnIODirection=\"Input\"/><persistantscalar ColumnIODirection=\"Input\"/><rs><f1 ColumnIODirection=\"Input\"/><f2 ColumnIODirection=\"Input\"/></rs><recset><field1/><field2/></recset></DataList>"; var serviceAction = new ServiceAction() { DataListSpecification = new StringBuilder(datalist) }; var dsfObj = new Mock <IDSFDataObject>(); dsfObj.Setup(o => o.Environment).Returns(new ExecutionEnvironment()); dsfObj.Setup(o => o.Environment.Eval(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <bool>(), false)) .Returns(CommonFunctions.WarewolfEvalResult.NewWarewolfAtomResult(DataStorage.WarewolfAtom.NewDataString("Args"))); var workSpace = new Mock <IWorkspace>(); var channel = new Mock <IEsbChannel>(); var esbExecuteRequest = new EsbExecuteRequest(); var internalServiceContainer = new InternalServiceContainer(serviceAction, dsfObj.Object, workSpace.Object, channel.Object, esbExecuteRequest); var privateObject = new PrivateObject(internalServiceContainer); //---------------Assert Precondition---------------- Assert.AreEqual(4, esbExecuteRequest.Args.Count); //---------------Execute Test ---------------------- var errorResultTO = new ErrorResultTO(); privateObject.Invoke("GenerateRequestDictionaryFromDataObject", errorResultTO); //---------------Test Result ----------------------- Assert.AreEqual(0, esbExecuteRequest.Args.Count); }
public void InternalServiceRequestHandler_ProcessRequestGivenUnAuthorizedPermission() { //------------Setup for test-------------------------- var args = new Dictionary <string, StringBuilder> { { "DebugPayload", new StringBuilder("<DataList>Value:SomeStringAsValue,IsDebug:true</DataList>") }, { "IsDebug", new StringBuilder("<DataList>true</DataList>") }, }; var eer = new EsbExecuteRequest { ServiceName = "Ping", Args = args, TestName = "Test1", ExecuteResult = new StringBuilder("Results") }; var executingUser = new Mock <IPrincipal>(); var resourceCatalog = new Mock <IResourceCatalog>(); var authorizationService = new Mock <IAuthorizationService>(); authorizationService.Setup(service => service.IsAuthorized(AuthorizationContext.Contribute, Guid.Empty)).Returns(false); var internalServiceRequestHandler = new InternalServiceRequestHandler(resourceCatalog.Object, authorizationService.Object) { ExecutingUser = executingUser.Object }; //------------Execute Test--------------------------- var processRequest = internalServiceRequestHandler.ProcessRequest(eer, Guid.Empty, Guid.Empty, Guid.NewGuid().ToString()); authorizationService.Verify(service => service.IsAuthorized(AuthorizationContext.Contribute, Guid.Empty), Times.Once); Assert.IsNotNull(processRequest); }
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 = WorkspaceRepository.Instance.Get(workspaceId); }); var dataListOkay = EnsureDataListIdIsSet(dataObject, workspaceId, errors); if (!dataListOkay) { return(resultID); } try { Dev2Logger.Debug("Creating Invoker", dataObject.ExecutionID.ToString()); using (var invoker = new EsbServiceInvoker(this, theWorkspace, request)) { resultID = invoker.Invoke(dataObject, out var invokeErrors); errors.MergeErrors(invokeErrors); } } catch (Exception ex) { errors.AddError(ex.Message); } return(resultID); }
public ServiceTestExecutionContainer(ServiceAction sa, IDSFDataObject dataObj, IWorkspace theWorkspace, IEsbChannel esbChannel, EsbExecuteRequest request) : base(sa, dataObj, theWorkspace, esbChannel) { _request = request; TstCatalog = TestCatalog.Instance; ResourceCat = ResourceCatalog.Instance; }
public void ClientScheduledResourceModel_SaveScheduledResource_CallsCommunicationsController() { //------------Setup for test-------------------------- var scheduledResourceForTest = new ScheduledResourceForTest(); Dev2JsonSerializer serializer = new Dev2JsonSerializer(); var serializeObject = serializer.SerializeToBuilder(scheduledResourceForTest); var esbPayLoad = new EsbExecuteRequest { ServiceName = "AddScheduledResourceService" }; esbPayLoad.AddArgument("Resource", serializeObject); var mockEnvironmentModel = new Mock <IEnvironmentModel>(); var mockConnection = new Mock <IEnvironmentConnection>(); mockConnection.Setup(connection => connection.IsConnected).Returns(true); mockConnection.Setup(connection => connection.ExecuteCommand(It.IsAny <StringBuilder>(), It.IsAny <Guid>(), It.IsAny <Guid>())).Verifiable(); mockConnection.Setup(connection => connection.WorkspaceID).Returns(Guid.NewGuid()); mockEnvironmentModel.Setup(model => model.Connection).Returns(mockConnection.Object); var clientScheduledResourceModel = new ClientScheduledResourceModel(mockEnvironmentModel.Object); //------------Execute Test--------------------------- string errorMessage; var saved = clientScheduledResourceModel.Save(scheduledResourceForTest, out errorMessage); //------------Assert Results------------------------- mockConnection.Verify(connection => connection.ExecuteCommand(It.IsAny <StringBuilder>(), It.IsAny <Guid>(), It.IsAny <Guid>()), Times.Once()); Assert.IsTrue(saved); }
public void WhenAWorkflowRequestIsReceived(string wfName) { var workflow = _scenarioContext.Get <IResourceModel>(wfName); var dataObject = _scenarioContext.Get <DsfDataObject>("dataObject"); var mockStateNotifier = SetupMockStateNotifier(); var mockExecutionManager = new Mock <IExecutionManager>(); var executionManager = mockExecutionManager.Object; var esbServicesEndpoint = new EsbServicesEndpoint(); CustomContainer.Register <IWarewolfPerformanceCounterLocater>(_performanceCounterLocater); CustomContainer.Register <IExecutionManager>(executionManager); var mockLogManager = new Mock <IStateNotifierFactory>(); mockLogManager.Setup(o => o.New(dataObject)).Returns(mockStateNotifier.Object); CustomContainer.Register <IStateNotifierFactory>(mockLogManager.Object); var workspaceId = Guid.NewGuid(); var request = new EsbExecuteRequest(); var resultId = esbServicesEndpoint.ExecuteRequest(dataObject, request, workspaceId, out var errors); Assert.IsNotNull(resultId); _scenarioContext.Add(nameof(mockExecutionManager), mockExecutionManager); }
public void GenerateInvokeContainer_GivenValidArgsAndIsLocalInvokeTrueEmptyCacheNullService_ShouldReturnNull() { //---------------Set up test pack------------------- //GenerateInvokeContainer(IDSFDataObject dataObject, String serviceName, bool isLocalInvoke, Guid masterDataListId = default(Guid)) var channel = new Mock <IEsbChannel>(); var workSpace = new Mock <IWorkspace>(); var obj = new Mock <IDSFDataObject>(); var locater = new Mock <IServiceLocator>(); EsbExecuteRequest executeRequest = null; locater.Setup(l => l.FindService(It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(default(DynamicService)); var invoker = new EsbServiceInvoker(channel.Object, workSpace.Object, executeRequest); var privateObject = new PrivateObject(invoker); privateObject.SetField("_serviceLocator", locater.Object); //---------------Assert Precondition---------------- Assert.IsNotNull(invoker); //---------------Execute Test ---------------------- var executionContainer = invoker.GenerateInvokeContainer(obj.Object, Guid.NewGuid(), true); //---------------Test Result ----------------------- Assert.IsNull(executionContainer); }
public void Execute_GivenNullService_ShouldAddValidError() { //---------------Set up test pack------------------- const string datalist = "<DataList><scalar1 ColumnIODirection=\"Input\"/><persistantscalar ColumnIODirection=\"Input\"/><rs><f1 ColumnIODirection=\"Input\"/><f2 ColumnIODirection=\"Input\"/></rs><recset><field1/><field2/></recset></DataList>"; var serviceAction = new ServiceAction() { DataListSpecification = new StringBuilder(datalist), ServiceName = "name", Name = "Name" }; var dsfObj = new Mock <IDSFDataObject>(); dsfObj.Setup(o => o.Environment).Returns(new ExecutionEnvironment()); dsfObj.Setup(o => o.Environment.Eval(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <bool>(), false)) .Returns(CommonFunctions.WarewolfEvalResult.NewWarewolfAtomResult(DataStorage.WarewolfAtom.NewDataString("Args"))); var workSpace = new Mock <IWorkspace>(); var channel = new Mock <IEsbChannel>(); var esbExecuteRequest = new EsbExecuteRequest(); var internalServiceContainer = new InternalServiceContainer(serviceAction, dsfObj.Object, workSpace.Object, channel.Object, esbExecuteRequest); //---------------Assert Precondition---------------- Assert.AreEqual(4, esbExecuteRequest.Args.Count); //---------------Execute Test ---------------------- ErrorResultTO errorResultTO; internalServiceContainer.Execute(out errorResultTO, 1); //---------------Test Result ----------------------- Assert.AreEqual(1, errorResultTO.FetchErrors().Count); Assert.AreEqual(string.Format(ErrorResource.CouldNotLocateManagementService, "name"), errorResultTO.FetchErrors().Single()); }
public void EsbServicesEndpoint_ExecuteWorkflow_ResourceIsNull_ExpectNothing() { var esbServicesEndpoint = new EsbServicesEndpoint(); var mockPrincipal = new Mock <IPrincipal>(); mockPrincipal.Setup(o => o.Identity).Returns(WindowsIdentity.GetCurrent()); var dataObject = new DsfDataObject("", Guid.NewGuid()) { ResourceID = Guid.Parse("2311e5fb-3eaa-4986-b946-5a687f33fd51"), ExecutingUser = mockPrincipal.Object, IsDebug = true, RunWorkflowAsync = true, }; dataObject.Environment.Assign("[[Name]]", "somename", 0); var request = new EsbExecuteRequest(); var workspaceId = Guid.NewGuid(); var resultId = esbServicesEndpoint.ExecuteRequest(dataObject, request, workspaceId, out var errors); Assert.AreEqual(Guid.Empty, resultId); }
protected EsbExecutionContainer(ServiceAction sa, IDSFDataObject dataObject, IWorkspace theWorkspace, IEsbChannel esbChannel, EsbExecuteRequest request) { ServiceAction = sa; DataObject = dataObject; TheWorkspace = theWorkspace; Request = request; DataObject.EsbChannel = esbChannel; }
public void Invoke_GivenHasErrors_ShouldReturnResult() { //---------------Set up test pack------------------- //Invoke(IDSFDataObject dataObject, out ErrorResultTO errors) var serviceId = Guid.NewGuid(); var newGuid = Guid.NewGuid(); var obj = new Mock<IDSFDataObject>(); var channel = new Mock<IEsbChannel>(); var workSpace = new Mock<IWorkspace>(); var env = new Mock<IExecutionEnvironment>(); obj.Setup(o => o.Environment).Returns(env.Object); obj.Setup(o => o.ResourceID).Returns(serviceId).Verifiable(); obj.Setup(o => o.Environment.AllErrors).Returns(new HashSet<string>()).Verifiable(); obj.Setup(o => o.Environment.AllErrors).Returns(new HashSet<string>()).Verifiable(); env.Setup(o => o.Errors).Returns(new HashSet<string>()).Verifiable(); env.Setup(o => o.Errors).Returns(new HashSet<string>()).Verifiable(); var executeRequest = new EsbExecuteRequest { Args = new Dictionary<string, StringBuilder>(), ServiceName = "SomeService" }; var invoker = new EsbServiceInvoker(channel.Object, workSpace.Object, executeRequest); var locater = new Mock<IServiceLocator>(); locater.Setup(l => l.FindService(It.IsAny<string>(), It.IsAny<Guid>())).Returns(new DynamicService { Actions = new List<ServiceAction> { new ServiceAction { ActionType = enActionType.Workflow } }, }); locater.Setup(l => l.FindService(It.IsAny<Guid>(), It.IsAny<Guid>())).Returns(new DynamicService { Actions = new List<ServiceAction> { new ServiceAction { ActionType = enActionType.Workflow } }, }); var privateObject = new PrivateObject(invoker); obj.SetupGet(o => o.ResourceID).Returns(newGuid); privateObject.SetField("_serviceLocator", locater.Object); //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- try { obj.Setup(o => o.Environment.HasErrors()).Returns(true).Verifiable(); ; obj.Setup(o => o.RemoteInvoke).Verifiable(); obj.Setup(o => o.Environment.FetchErrors()).Returns("Error").Verifiable(); invoker.Invoke(obj.Object, out ErrorResultTO errors); //weird expetion on execution when getting errors Assert.AreEqual("Object reference not set to an instance of an object.", errors.FetchErrors().Single()); //---------------Test Result ----------------------- obj.Verify(o => o.Environment.FetchErrors()); obj.VerifyGet(o => o.ResourceID); } catch (Exception exception) { Assert.Fail(exception.Message); } }
public EsbServiceInvoker(IEsbChannel esbChannel, IWorkspace workspace, EsbExecuteRequest request) : this(new ServiceLocator()) { _esbChannel = esbChannel; _workspace = workspace; _request = request; }
/// <summary> /// Adds the payload argument. /// </summary> /// <param name="key">The key.</param> /// <param name="value">The value.</param> public void AddPayloadArgument(string key, StringBuilder value) { if (ServicePayload == null) { ServicePayload = new EsbExecuteRequest(); } ServicePayload.AddArgument(key, value); }
/// <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); }
// 2012.10.17 - 5782: TWR - Changed to work off the workspace host and made read only #region Constructors public EsbServiceInvoker(IEsbChannel esbChannel, IWorkspace workspace, EsbExecuteRequest request = null) : this(new ServiceLocator()) { _esbChannel = esbChannel; // 2012.10.17 - 5782: TWR - Added workspace parameter _workspace = workspace; _request = request; }
public void ExecuteWf_GivenRecordSetsInputs_Should_AssignAllRecordSetItems() { //------------Setup for test------------------------- var resourceId = Guid.NewGuid(); const string Datalist = "<DataList><scalar1 ColumnIODirection=\"Input\"/><persistantscalar ColumnIODirection=\"Input\"/><rs><f1 ColumnIODirection=\"Input\"/><f2 ColumnIODirection=\"Input\"/></rs><recset><field1/><field2/></recset></DataList>"; var serviceAction = new ServiceAction { DataListSpecification = new StringBuilder(Datalist), Service = new DynamicService { ID = resourceId } }; var dsfObj = new Mock <IDSFDataObject>(); dsfObj.SetupProperty(o => o.ResourceID); const string TestName = "test2"; dsfObj.Setup(o => o.TestName).Returns(TestName); dsfObj.Setup(o => o.Environment).Returns(new ExecutionEnvironment()); dsfObj.Setup(o => o.Environment.Eval(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <bool>(), false)) .Returns(CommonFunctions.WarewolfEvalResult.NewWarewolfAtomResult(DataStorage.WarewolfAtom.NewDataString("Args"))); dsfObj.Setup(o => o.Environment.AllErrors).Returns(new HashSet <string>()); var fetch = JsonResource.Fetch("AssignWithRecSet"); var s = new Dev2JsonSerializer(); var testModelTO = s.Deserialize <ServiceTestModelTO>(fetch); var testCataLog = new Mock <ITestCatalog>(); testCataLog.Setup(cat => cat.SaveTest(It.IsAny <Guid>(), It.IsAny <IServiceTestModelTO>())).Verifiable(); testCataLog.Setup(cat => cat.FetchTest(resourceId, TestName)).Returns(testModelTO); var resourceCat = new Mock <IResourceCatalog>(); var activity = new Mock <IDev2Activity>(); resourceCat.Setup(catalog => catalog.Parse(It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(activity.Object); var workSpace = new Mock <IWorkspace>(); var channel = new Mock <IEsbChannel>(); var esbExecuteRequest = new EsbExecuteRequest(); var serviceTestExecutionContainer = new ServiceTestExecutionContainerMock(serviceAction, dsfObj.Object, workSpace.Object, channel.Object, esbExecuteRequest, testCataLog.Object, resourceCat.Object); //---------------Assert Precondition---------------- Assert.IsNotNull(serviceTestExecutionContainer, "ServiceTestExecutionContainer is Null."); Assert.IsNull(serviceTestExecutionContainer.InstanceOutputDefinition); Assert.IsNull(serviceTestExecutionContainer.InstanceInputDefinition); //---------------Execute Test ---------------------- Thread.CurrentPrincipal = GlobalConstants.GenericPrincipal; Common.Utilities.PerformActionInsideImpersonatedContext(GlobalConstants.GenericPrincipal, () => { var execute = serviceTestExecutionContainer.Execute(out ErrorResultTO errors, 1); Assert.IsNotNull(execute, "serviceTestExecutionContainer execute results is Null."); }); //---------------Test Result ----------------------- dsfObj.Verify(o => o.Environment.Assign("[[Person(1).Name]]", "Marry", 0), Times.AtLeastOnce); }
private bool ProcessDsfDataObject(EsbExecuteRequest request, Guid workspaceId, Guid dataListId, string connectionId, EsbServicesEndpoint channel) { var(xmlData, queryString) = FormatXmlData(request); DsfDataObject = new DsfDataObject(xmlData, dataListId); if (!DsfDataObject.ExecutionID.HasValue) { DsfDataObject.ExecutionID = Guid.NewGuid(); } DsfDataObject.QueryString = queryString; if (IsDebugRequest(request)) { DsfDataObject.IsDebug = true; } DsfDataObject.StartTime = DateTime.Now; DsfDataObject.EsbChannel = channel; DsfDataObject.ServiceName = request.ServiceName; DsfDataObject.Settings = new Dev2WorkflowSettingsTO { ExecutionLogLevel = Config.Server.ExecutionLogLevel, EnableDetailedLogging = Config.Server.EnableDetailedLogging, LoggerType = LoggerType.JSON, KeepLogsForDays = 2, CompressOldLogFiles = true }; var resource = request.ResourceID != Guid.Empty ? _catalog.GetResource(workspaceId, request.ResourceID) : _catalog.GetResource(workspaceId, request.ServiceName); var isManagementResource = false; if (!string.IsNullOrEmpty(request.TestName)) { DsfDataObject.TestName = request.TestName; DsfDataObject.IsServiceTestExecution = true; } if (resource != null) { DsfDataObject.ResourceID = resource.ResourceID; DsfDataObject.SourceResourceID = resource.ResourceID; isManagementResource = _catalog.ManagementServices.ContainsKey(resource.ResourceID); } else { if (request.ResourceID != Guid.Empty) { DsfDataObject.ResourceID = request.ResourceID; } } DsfDataObject.ClientID = Guid.Parse(connectionId); Common.Utilities.OrginalExecutingUser = ExecutingUser; DsfDataObject.ExecutingUser = ExecutingUser; return(isManagementResource); }
public void Invoke_GivenIsTestExecutionServiceNameAndEmptyId_ShouldFindByNameInLocalhost() { //---------------Set up test pack------------------- var channel = new Mock <IEsbChannel>(); var workSpace = new Mock <IWorkspace>(); var valueFunction = Guid.NewGuid(); workSpace.SetupGet(p => p.ID).Returns(valueFunction); var obj = new Mock <IDSFDataObject>(); obj.Setup(o => o.Environment.HasErrors()).Returns(false); obj.Setup(o => o.ServiceName).Returns("Hello World"); obj.Setup(o => o.IsServiceTestExecution).Returns(true); var locater = new Mock <IServiceLocator>(); var executeRequest = new EsbExecuteRequest { Args = new Dictionary <string, StringBuilder>(), ServiceName = "SomeService" }; locater.Setup(lo => lo.FindService("Hello World", valueFunction)).Returns((DynamicService)null); var invoker = new EsbServiceInvoker(channel.Object, workSpace.Object, executeRequest); var privateObject = new PrivateObject(invoker); privateObject.SetField("_serviceLocator", locater.Object); //---------------Assert Precondition---------------- Assert.IsNotNull(invoker); //---------------Execute Test ---------------------- invoker.Invoke(obj.Object, out ErrorResultTO errorResultTO); //---------------Test Result ----------------------- Assert.IsNotNull(errorResultTO); Assert.AreEqual(1, errorResultTO.FetchErrors().Count); StringAssert.Contains(errorResultTO.FetchErrors().Single(), ErrorResource.ServiceNotFound); locater.VerifyAll(); var toTypes = typeof(Dev2.Data.ServiceTestModelTO); var common = typeof(Dev2.Common.Interfaces.TestRunResult); var enumerable = toTypes.Assembly.ExportedTypes.Where(type => !type.IsInterface); var types = enumerable as Type[] ?? enumerable.ToArray(); var allTypes = types.Union(common.Assembly.ExportedTypes.Where(type => !type.IsInterface)); var serviceTestModelTO = (ServiceTestModelTO)executeRequest.ExecuteResult.ToString().DeserializeToObject(toTypes, new KnownTypesBinder() { KnownTypes = allTypes.ToList() }); Assert.AreEqual(false, serviceTestModelTO.TestPassed); Assert.AreEqual(true, serviceTestModelTO.TestInvalid); Assert.AreEqual("Resource has been deleted", serviceTestModelTO.FailureMessage); Assert.IsTrue(serviceTestModelTO.Result.RunTestResult == RunResult.TestResourceDeleted); Assert.AreEqual("Resource has been deleted", serviceTestModelTO.Result.Message); Assert.AreEqual(0, serviceTestModelTO.Result.DebugForTest.Count); }