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