public void DsfActivity_OnExecute_WhenIsTestExecutionShouldUpdateDataObject_SetBackToTrue() { //------------Setup for test-------------------------- var environmentID = Guid.Empty; var dataObject = new DsfDataObject(CurrentDl, ExecutionId) { ServerID = Guid.NewGuid(), ExecutingUser = User, IsDebug = true, EnvironmentID = environmentID, IsRemoteInvokeOverridden = false, DataList = new StringBuilder(CurrentDl), IsServiceTestExecution = true }; var resourceID = Guid.NewGuid(); var act = new DsfActivity { ResourceID = new InArgument <Guid>(resourceID), EnvironmentID = Guid.Empty }; var mockAutorizationService = new Mock <IAuthorizationService>(); mockAutorizationService.Setup(service => service.IsAuthorized(It.IsAny <IPrincipal>(), AuthorizationContext.Execute, resourceID.ToString())).Returns(true); var p = new PrivateObject(act); p.SetProperty("AuthorizationService", mockAutorizationService.Object); //------------Execute Test--------------------------- TestStartNode = new FlowStep { Action = act }; TestData = "<DataList></DataList>"; CurrentDl = "<DataList></DataList>"; User = new Mock <IPrincipal>().Object; ExecuteProcess(dataObject, true, null, false, true, false, environmentID); //------------Assert Results------------------------- Assert.IsTrue(dataObject.IsServiceTestExecution); }
public void SharepointSource_Exists_OnResourceCatalog_BlankRecordSet() { //------------Setup for test-------------------------- const string activityName = "SharepointCopyFile"; var resourceId = Guid.NewGuid(); var sharepointCopyFileActivity = new SharepointCopyFileActivity { DisplayName = activityName, SharepointServerResourceId = resourceId, Result = "[[Files().Name]]", ServerInputPathFrom = @"C:\ProgramData\Warewolf\Resources\Hello World.bite", ServerInputPathTo = "Hello World.bite", Overwrite = true }; var dataObj = new DsfDataObject("", Guid.NewGuid(), ""); var resourceCatalog = new Mock <IResourceCatalog>(); var mockSharepointHelper = new Mock <ISharepointHelper>(); mockSharepointHelper.Setup(helper => helper.CopyFile(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>())).Returns("Success"); var mockSharepointSource = new MockSharepointSource { MockSharepointHelper = mockSharepointHelper.Object }; resourceCatalog.Setup(r => r.GetResource <SharepointSource>(It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(mockSharepointSource); var privateObject = new PrivateObject(sharepointCopyFileActivity); privateObject.SetProperty("ResourceCatalog", resourceCatalog.Object); sharepointCopyFileActivity.SharepointSource = mockSharepointSource; //------------Execute Test--------------------------- privateObject.Invoke("ExecuteTool", dataObj, 0); //------------Assert Result-------------------------- GetRecordSetFieldValueFromDataList(dataObj.Environment, "Files", "Name", out IList <string> result, out string error); Assert.IsNotNull(result); Assert.AreEqual("Success", result[0]); }
public void DsfWebGetRequestWithTimeoutActivity_ExecuteRequest_WithError_ExpectTimeOut_IsTrue() { //------------Setup for test-------------------------- const string Message = "This is a forced exception"; var mock = new Mock <IWebRequestInvoker>(); var dsfDataObject = new DsfDataObject("", Guid.NewGuid()); var errorResultTO = new ErrorResultTO(); var environment = new ExecutionEnvironment(); var activity = GetWebGetRequestWithTimeoutActivity(mock); activity.Method = "GET"; activity.Url = "BodyValue"; activity.TimeOutText = "-1"; TestStartNode = new FlowStep { Action = activity }; mock.Setup(invoker => invoker.ExecuteRequest(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <List <Tuple <string, string> > >(), It.IsAny <int>())).Throws(new InvalidDataException(Message)); environment.Assign("[[URL]]", "http://rsaklfsvrtfsbld:9910/api/values", 0); dsfDataObject.Environment = environment; dsfDataObject.IsDebug = true; dsfDataObject.EsbChannel = new MockEsb(); bool timeoutSecondsError = false; PrivateObject obj = new PrivateObject(activity); object[] args = new object[] { dsfDataObject, 0, errorResultTO, timeoutSecondsError }; //------------Execute Test--------------------------- var act = obj.Invoke("SetTimeoutSecondsError", args); //------------Assert Results------------------------- Assert.AreEqual(true, act); }
public void DsfWebPutActivity_Execute_ErrorResponse_ShouldSetVariables() { //------------Setup for test-------------------------- const string response = "{\"Message\":\"Error\"}"; var dsfWebPutActivity = new DsfWebPutActivity(); dsfWebPutActivity.ResourceID = InArgument <Guid> .FromValue(Guid.Empty); var mockResourceCatalog = new Mock <IResourceCatalog>(); var webSource = new WebSource { Address = $"http://{Depends.TFSBLDIP}:9910/api/", AuthenticationType = AuthenticationType.Anonymous }; mockResourceCatalog.Setup(resCat => resCat.GetResource <WebSource>(It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(webSource); dsfWebPutActivity.ResourceCatalog = mockResourceCatalog.Object; var serviceOutputs = new List <IServiceOutputMapping> { new ServiceOutputMapping("Message", "[[Message]]", "") }; dsfWebPutActivity.Outputs = serviceOutputs; var serviceXml = XmlResource.Fetch("WebService"); var service = new WebService(serviceXml) { RequestResponse = response }; dsfWebPutActivity.OutputDescription = service.GetOutputDescription(); dsfWebPutActivity.QueryString = "Error"; dsfWebPutActivity.SourceId = Guid.Empty; dsfWebPutActivity.Headers = new List <INameValue>(); var dataObject = new DsfDataObject("", Guid.NewGuid()); dataObject.EsbChannel = new MockEsb(); //------------Execute Test--------------------------- dsfWebPutActivity.Execute(dataObject, 0); //------------Assert Results------------------------- Assert.AreEqual("Error", ExecutionEnvironment.WarewolfEvalResultToString(dataObject.Environment.Eval("[[Message]]", 0))); }
public void DsfNativeActivity_DispatchDebugState_After_SetsEndTimeCorrectly() { var parentInstanceID = Guid.NewGuid(); const StateType StateType = StateType.After; var dataObj = new DsfDataObject(string.Empty, GlobalConstants.NullDataListID) { IsDebug = true, IsOnDemandSimulation = false, EnvironmentID = Guid.NewGuid(), WorkspaceID = Guid.NewGuid(), ServerID = Guid.NewGuid(), ResourceID = Guid.NewGuid(), OriginalInstanceID = Guid.NewGuid(), ParentInstanceID = parentInstanceID.ToString() }; IDebugState passedDebugState = null; var mockDebugDispatcher = new Mock <IDebugDispatcher>(); mockDebugDispatcher.Setup(dispatcher => dispatcher.Write(It.IsAny <IDebugState>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <IList <IDebugState> >())) .Callback((IDebugState ds, bool isTestExecution, bool isDebugFromWeb, string testName, bool isRemoteInvoke, string remoteID, string parentId, IList <IDebugState> remoteItems) => { passedDebugState = ds; }); var activity = new TestActivity(mockDebugDispatcher.Object) { IsSimulationEnabled = false, ScenarioID = Guid.NewGuid().ToString(), IsWorkflow = true, }; var cat = new Mock <IResourceCatalog>(); var res = new Mock <IResource>(); res.Setup(a => a.ResourceName).Returns("bob"); cat.Setup(a => a.GetResource(Guid.Empty, It.IsAny <Guid>())).Returns(res.Object); activity.ResourceCatalog = cat.Object; activity.TestDispatchDebugState(dataObj, StateType); Assert.IsNotNull(passedDebugState); Assert.IsNotNull(passedDebugState.EndTime); Assert.AreNotEqual(DateTime.MinValue, passedDebugState.StartTime); Assert.AreNotEqual(DateTime.MinValue, passedDebugState.EndTime); }
// ReSharper disable InconsistentNaming public void DsfForEach_UpdateDebugParentID_UniqueIdNotSameIfNestingLevelIncreased() // ReSharper restore InconsistentNaming { var dataObject = new DsfDataObject(CurrentDl, Guid.NewGuid()) { // NOTE: WorkflowApplicationFactory.InvokeWorkflowImpl() will use HostSecurityProvider.Instance.ServerID // if this is NOT provided which will cause the tests to fail! ServerID = Guid.NewGuid(), IsDebug = true, ForEachNestingLevel = 1 }; DsfForEachActivity act = new DsfForEachActivity(); var originalGuid = Guid.NewGuid(); act.UniqueID = originalGuid.ToString(); act.UpdateDebugParentID(dataObject); Assert.AreNotEqual(originalGuid.ToString(), act.UniqueID); Assert.AreEqual(act.GetWorkSurfaceMappingId(), originalGuid); }
public void DsfNativeActivity_UpdateDebugParentID_UniqueIdNotSameIfNestingLevelIncreased() { var dataObject = new DsfDataObject("<Datalist></Datalist>", Guid.NewGuid()) { // NOTE: WorkflowApplicationFactory.InvokeWorkflowImpl() will use HostSecurityProvider.Instance.ServerID // if this is NOT provided which will cause the tests to fail! ServerID = Guid.NewGuid(), IsDebug = true, ForEachNestingLevel = 1 }; var act = new TestNativeActivity(false, "bob"); var originalGuid = Guid.NewGuid(); act.UniqueID = originalGuid.ToString(); act.UpdateDebugParentID(dataObject); Assert.AreEqual(originalGuid.ToString(), act.UniqueID); Assert.AreEqual(act.GetWorkSurfaceMappingId(), originalGuid); }
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\"/>" + "<Age Description=\"\" IsEditable=\"True\" ColumnIODirection=\"Output\"/>" + "<Salary 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); dataObj.Environment.Assign("[[Age]]", "15", 0); dataObj.Environment.Assign("[[Salary]]", "1550.55", 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\""); StringAssert.Contains(actual, "\"Age\": 15"); StringAssert.Contains(actual, "\"Salary\": 1550.55"); Assert.IsFalse(actual.Contains("\"Name\": \"Bob\"")); Assert.IsFalse(actual.Contains("\"Surname\": \"Mary\"")); Assert.IsFalse(actual.Contains("\"b\": \"2\"")); Assert.IsFalse(actual.Contains("\"c\": \"3\"")); }
/// <summary> /// The ForEach Activity requires the data returned from an activity /// We will mock the DSF channel to return something that we expect is shaped. /// </summary> /// <returns></returns> public void ExecuteForEachProcessForReal(out IDSFDataObject dataObject) { var svc = new ServiceAction { Name = "ForEachTestAction", ServiceName = "UnitTestService" }; IEsbChannel channel = new EsbServicesEndpoint(); svc.SetActivity(FlowchartProcess); if (CurrentDl == null) { CurrentDl = TestData; } Compiler = DataListFactory.CreateDataListCompiler(); ErrorResultTO errors; Guid exId = Compiler.ConvertTo(DataListFormat.CreateFormat(GlobalConstants._XML), new StringBuilder(TestData), new StringBuilder(CurrentDl), out errors); if (errors.HasErrors()) { string errorString = errors.FetchErrors().Aggregate(string.Empty, (current, item) => current + item); throw new Exception(errorString); } dataObject = new DsfDataObject(CurrentDl, exId) { // NOTE: WorkflowApplicationFactory.InvokeWorkflowImpl() will use HostSecurityProvider.Instance.ServerID // if this is NOT provided which will cause the tests to fail! ServerID = Guid.NewGuid(), ParentThreadID = 1 }; // we need to set this now ;) WfExecutionContainer wfec = new WfExecutionContainer(svc, dataObject, Dev2.Workspaces.WorkspaceRepository.Instance.ServerWorkspace, channel); errors.ClearErrors(); dataObject.DataListID = wfec.Execute(out errors); }
public void PopEnvironment_GivenHasNoEnvironments_ShouldNotSetEnvironment() { //---------------Set up test pack------------------- var mock = new Mock <IExecutionEnvironment>(); mock.SetupAllProperties(); IDSFDataObject dataObject = new DsfDataObject(string.Empty, Guid.NewGuid()); dataObject.Environment = mock.Object; var privateObject = new PrivateObject(dataObject); var field = privateObject.GetField("_environments", BindingFlags.Instance | BindingFlags.NonPublic) as ConcurrentStack <IExecutionEnvironment>; //---------------Assert Precondition---------------- Assert.IsNotNull(dataObject.Environment); Assert.IsNotNull(field); Assert.AreEqual(0, field.Count); //---------------Execute Test ---------------------- dataObject.PopEnvironment(); //---------------Test Result ----------------------- Assert.AreEqual(dataObject.Environment, mock.Object); }
public void CheckOutputFormatOfDataListForViewInBrowserForOneRecordsetOutputRegion() { IDataListCompiler comp = DataListFactory.CreateDataListCompiler(); ErrorResultTO errors; Guid dlId = comp.ConvertTo(DataListFormat.CreateFormat(GlobalConstants._XML), string.Empty.ToStringBuilder(), ServiceShape.ToStringBuilder(), out errors); var resource = ResourceCatalog.Instance.GetResource(_workspaceId, ServiceName); IDSFDataObject dataObj = new DsfDataObject(string.Empty, dlId) { WorkspaceID = _workspaceId, DataListID = dlId, ServiceName = ServiceName, ResourceID = resource.ResourceID }; EsbServicesEndpoint endPoint = new EsbServicesEndpoint(); string result = endPoint.FetchExecutionPayload(dataObj, DataListFormat.CreateFormat(GlobalConstants._XML_Without_SystemTags), out errors); DeleteDataList(dlId); Assert.IsTrue(result.IndexOf("<outputScalar", StringComparison.Ordinal) > 0, "Output format missing required tag of <outputScalar>"); Assert.IsTrue(result.IndexOf("<bothScalar", StringComparison.Ordinal) > 0, "Output format missing required tag of <bothScalar"); Assert.IsTrue(result.IndexOf("<recset", StringComparison.Ordinal) > 0, "Output format missing required tag of <recset></recset>"); Assert.IsTrue(result.IndexOf("<f2", StringComparison.Ordinal) > 0, "Output format missing required tag of <recset><f2/></recset>"); Assert.IsTrue(result.IndexOf("<f3", StringComparison.Ordinal) > 0, "Output format missing required tag of <recset><f3/></recset>"); }
public void PerformExecution_Given_ItemsInQueue_ExecuteAndReqeue_WhenExecutedMultipleTimes_ShouldNotAppend_NoTimeout() { //------------Setup for test-------------------------- var dataObj = new DsfDataObject(It.IsAny <string>(), It.IsAny <Guid>(), It.IsAny <string>()); var dsfConsumeRabbitMQActivity = new DsfConsumeRabbitMQActivity(); const string queueName = "Q1"; var resourceCatalog = new Mock <IResourceCatalog>(); var rabbitMQSource = new Mock <RabbitMQSource>(); var connectionFactory = new Mock <ConnectionFactory>(); var connection = new Mock <IConnection>(); var channel = new Mock <IModel>(); resourceCatalog.Setup(r => r.GetResource <RabbitMQSource>(It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(rabbitMQSource.Object); connectionFactory.Setup(c => c.CreateConnection()).Returns(connection.Object); connection.Setup(c => c.CreateModel()).Returns(channel.Object); channel.Setup(c => c.BasicQos(0, 1, false)); channel.Setup(c => c.BasicConsume(It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <QueueingBasicConsumer>())); var basicGetResult1 = new BasicGetResult(1, true, queueName, "", 1, new BasicProperties(), Encoding.Default.GetBytes("hello")); var basicGetResult2 = new BasicGetResult(2, true, queueName, "", 1, new BasicProperties(), Encoding.Default.GetBytes("world")); channel.SetupSequence(model => model.BasicGet(queueName, It.IsAny <bool>())).Returns(basicGetResult1).Returns(basicGetResult2); var privateObject = new PrivateObject(dsfConsumeRabbitMQActivity); privateObject.SetProperty("ConnectionFactory", connectionFactory.Object); privateObject.SetProperty("ResourceCatalog", resourceCatalog.Object); privateObject.SetProperty("QueueName", queueName); dsfConsumeRabbitMQActivity.Response = "[[msgs().message]]"; dsfConsumeRabbitMQActivity.ReQueue = true; //------------Execute Test--------------------------- privateObject.Invoke("ExecuteTool", dataObj, 0); privateObject.Invoke("ExecuteTool", dataObj, 0); privateObject.Invoke("ExecuteTool", dataObj, 0); //------------Assert Results------------------------- IList <string> actualRecset; string error; GetRecordSetFieldValueFromDataList(dataObj.Environment, "msgs", "message", out actualRecset, out error); Assert.AreEqual(2, actualRecset.Count); }
public void DsfNativeActivity_ExecuteTool_DebugFalse_TestExecution() { var dataObject = new DsfDataObject("<Datalist></Datalist>", Guid.NewGuid()) { ServerID = Guid.NewGuid(), IsDebug = false, ForEachNestingLevel = 0, IsServiceTestExecution = true }; var act = new TestNativeActivity(false, "bob"); var serviceTestModelTO = new ServiceTestModelTO { TestSteps = new List <IServiceTestStep> { new ServiceTestStepTO { UniqueId = Guid.Parse(act.UniqueID), Type = StepType.Assert, StepOutputs = new ObservableCollection <IServiceTestOutput> { new ServiceTestOutputTO { AssertOp = "=", Value = "Bob", Variable = "[[var]]" } } } } }; dataObject.ServiceTest = serviceTestModelTO; act.Execute(dataObject, 0); Assert.AreEqual(RunResult.TestFailed, serviceTestModelTO.Result.RunTestResult); Assert.IsTrue(dataObject.StopExecution); }
public void SharepointSource_Exists_OnResourceCatalog_BlankRecordSet() { //------------Setup for test-------------------------- const string activityName = "SharepointReadList"; var resourceId = Guid.NewGuid(); var sharepointReadListActivity = new SharepointReadListActivity { DisplayName = activityName, SharepointServerResourceId = resourceId, ReadListItems = new List <SharepointReadListTo>(), FilterCriteria = new List <SharepointSearchTo>(), RequireAllCriteriaToMatch = true, SharepointUtils = new SharepointUtils() }; var dataObj = new DsfDataObject("", Guid.NewGuid(), ""); var resourceCatalog = new Mock <IResourceCatalog>(); var mockSharepointHelper = new Mock <ISharepointHelper>(); mockSharepointHelper.Setup(helper => helper.CopyFile(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>())).Returns("Success"); var mockSharepointSource = new MockSharepointSource { MockSharepointHelper = mockSharepointHelper.Object }; resourceCatalog.Setup(r => r.GetResource <SharepointSource>(It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(mockSharepointSource); var privateObject = new PrivateObject(sharepointReadListActivity); privateObject.SetProperty("ResourceCatalog", resourceCatalog.Object); //------------Execute Test--------------------------- privateObject.Invoke("ExecuteTool", dataObj, 0); //------------Assert Result-------------------------- GetRecordSetFieldValueFromDataList(dataObj.Environment, "Files", "Name", out IList <string> result, out string error); Assert.IsNotNull(result); }
public void LargeRows_SplitOnNewLine_ShouldSplitCorrectly() { IList <DataSplitDTO> resultsCollection = new List <DataSplitDTO>(); resultsCollection.Add(new DataSplitDTO("[[rec().data]]", "New Line", "", 1)); var sourceString = File.ReadAllText("LargeRowsDataSplit.txt"); var act = new DsfDataSplitActivity { SourceString = sourceString, ResultsCollection = resultsCollection, SkipBlankRows = true }; var dataObject = new DsfDataObject("", Guid.Empty) { IsDebug = false, }; act.Execute(dataObject, 0); var totalCount = dataObject.Environment.GetCount("rec"); var res = dataObject.Environment.Eval("[[rec().data]]", 0) as CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult; Assert.AreEqual("0827373254", res.Item.First().ToString()); Assert.AreEqual(8300000, totalCount, CurrentDl); }
public void JsonMappingCompoundTo_MaxCount_NotIsCompound() { //------------Setup for test-------------------------- var dataObject = new DsfDataObject(xmldata: string.Empty, dataListId: Guid.NewGuid()); dataObject.Environment.Assign("[[a]]", "10", 0); dataObject.Environment.Assign("[[b]]", "20", 0); dataObject.Environment.Assign("[[rec(1).a]]", "50", 0); dataObject.Environment.Assign("[[rec(1).b]]", "500", 0); dataObject.Environment.Assign("[[rec(2).a]]", "60", 0); dataObject.Environment.Assign("[[rec(2).b]]", "600", 0); //------------Execute Test--------------------------- var jsonMappingCompound = new JsonMappingCompoundTo( env: dataObject.Environment, compound: new JsonMappingTo { SourceName = "[[rec().a]]", DestinationName = "myName" } ); //------------Assert Results------------------------- Assert.IsNotNull(jsonMappingCompound); Assert.IsFalse(jsonMappingCompound.IsCompound); Assert.AreEqual(jsonMappingCompound.MaxCount, 1); // check for list jsonMappingCompound = new JsonMappingCompoundTo( env: dataObject.Environment, compound: new JsonMappingTo { SourceName = "[[rec(*).a]]", DestinationName = "myName" } ); Assert.IsFalse(jsonMappingCompound.IsCompound); Assert.AreEqual(jsonMappingCompound.MaxCount, 2); }
public void GateActivity_Execute_GivenNoConditions_ExpectDetailedLog() { var expectedNextActivity = new Mock <IDev2Activity>(); //---------------Set up test pack------------------- //------------Setup for test-------------------------- var act = new GateActivity { Conditions = new List <ConditionExpression>(), NextNodes = new List <IDev2Activity> { expectedNextActivity.Object }, }; var dataObject = new DsfDataObject("", Guid.NewGuid()); var result = act.Execute(dataObject, 0); Assert.AreEqual(expectedNextActivity.Object, result); }
private string ExecuteOverrideDataFunc(ForEachInnerActivityTO innerActivity) { IDSFDataObject dataObject = new DsfDataObject(string.Empty, Guid.Empty); var origInnerInputMapping = innerActivity.OrigInnerInputMapping; var inputs = TranslateInputMappingToInputs(origInnerInputMapping); foreach (var serviceInput in inputs) { var isVariable = ExecutionEnvironment.IsValidVariableExpression(serviceInput.Value, out string errorMessage, 0); if (isVariable) { var inputName = _dataObject.Environment.EvalToExpression(serviceInput.Value, _update); var inputValue = ExecutionEnvironment.WarewolfEvalResultToString(_dataObject.Environment.Eval(inputName, _update, false, true)); dataObject.Environment.AssignWithFrame(new AssignValue(inputName, inputValue), _update); } else { dataObject.Environment.AssignWithFrame(new AssignValue("[[" + serviceInput.Name + "]]", serviceInput.Value), _update); } } return(dataObject.Environment.ToJson()); }
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 JsonMappingCompoundTo_Constructor_SetsProperties_NotIsCompound() { //------------Setup for test-------------------------- // ReSharper disable RedundantArgumentName var dataObject = new DsfDataObject(xmldata: string.Empty, dataListId: Guid.NewGuid()); dataObject.Environment.Assign("[[a]]", "10", 0); dataObject.Environment.Assign("[[b]]", "20", 0); dataObject.Environment.Assign("[[rec(1).a]]", "50", 0); dataObject.Environment.Assign("[[rec(1).b]]", "500", 0); //------------Execute Test--------------------------- var jsonMappingCompound = new JsonMappingCompoundTo( env: dataObject.Environment, compound: new JsonMappingTo { SourceName = "[[a]]", DestinationName = "a" } ); //------------Assert Results------------------------- Assert.IsNotNull(jsonMappingCompound); Assert.IsFalse(jsonMappingCompound.IsCompound); }
public void DsfNativeActivity_ExecuteTool_Errors_PerformsErrorHandling_ShouldReturnErrors() { var dataObject = new DsfDataObject("<Datalist></Datalist>", Guid.NewGuid()) { ServerID = Guid.NewGuid(), IsDebug = false, ForEachNestingLevel = 0, IsServiceTestExecution = true }; var act = new TestNativeActivity(false, "bob"); act.IsEndedOnError = true; act.OnErrorVariable = "[[Error().Massage]]"; dataObject.Environment.AddError("There is an error with special character: [[special.willNotParse)"); _ = act.Execute(dataObject, 0); var errors = dataObject.Environment.Errors; Assert.AreEqual("There is an error with special character: [[special.willNotParse)", errors.First(), "Warewolf error cannot have special characters"); Assert.AreEqual("parse error: { Error().Massage }", errors.Last()); }
public void CheckOutputFormatOfDataListForViewInBrowserForAllInputRegions() { IDataListCompiler comp = DataListFactory.CreateDataListCompiler(); ErrorResultTO errors; Guid dlId = comp.ConvertTo(DataListFormat.CreateFormat(GlobalConstants._XML), string.Empty, ServiceShape.ToStringBuilder(), out errors); IDSFDataObject dataObj = new DsfDataObject(string.Empty, dlId) { WorkspaceID = _workspaceId, DataListID = dlId, ServiceName = ServiceName }; EsbServicesEndpoint endPoint = new EsbServicesEndpoint(); string result = endPoint.FetchExecutionPayload(dataObj, DataListFormat.CreateFormat(GlobalConstants._XML_Without_SystemTags), out errors); DeleteDataList(dlId); Assert.IsTrue(result.IndexOf("<inputScalar", StringComparison.Ordinal) < 0, "Output format contains additional tag, <inputScalar>"); Assert.IsTrue(result.IndexOf("<noneScalar", StringComparison.Ordinal) < 0, "Output format contains additional tag, <noneScalar>"); Assert.IsTrue(result.IndexOf("<f1", StringComparison.Ordinal) < 0, "Output format contains additional tag, <recset><f1/></recset>"); Assert.IsTrue(result.IndexOf("<f4", StringComparison.Ordinal) < 0, "Output format contains additional tag, <recset><f4/></recset>"); Assert.IsTrue(result.IndexOf("<newrecset", StringComparison.Ordinal) < 0, "Output format contains additional tag, <newrecset></newrecset>"); Assert.IsTrue(result.IndexOf("<field1", StringComparison.Ordinal) < 0, "Output format contains additional tag, <newrecset><f1/></newrecset>"); Assert.IsTrue(result.IndexOf("<field2", StringComparison.Ordinal) < 0, "Output format contains additional tag, <newrecset><f1/></newrecset>"); }
public void DsfNativeActivity_DispatchDebugState_Before_SetsStartTimeCorrectly() { var parentInstanceID = Guid.NewGuid(); const StateType StateType = StateType.Before; var dataObj = new DsfDataObject(string.Empty, GlobalConstants.NullDataListID) { IsDebug = true, IsOnDemandSimulation = false, EnvironmentID = Guid.NewGuid(), WorkspaceID = Guid.NewGuid(), ServerID = Guid.NewGuid(), ResourceID = Guid.NewGuid(), OriginalInstanceID = Guid.NewGuid(), ParentInstanceID = parentInstanceID.ToString() }; var activity = new TestActivity { IsSimulationEnabled = false, SimulationMode = SimulationMode.Never, ScenarioID = Guid.NewGuid().ToString(), IsWorkflow = true, }; var cat = new Mock <IResourceCatalog>(); var res = new Mock <IResource>(); res.Setup(a => a.ResourceName).Returns("bob"); cat.Setup(a => a.GetResource(Guid.Empty, It.IsAny <Guid>())).Returns(res.Object); activity.ResourceCatalog = cat.Object; var actual = activity.TestDispatchDebugState(dataObj, StateType); Assert.IsNotNull(actual); Assert.IsNotNull(actual.StartTime); Assert.AreNotEqual(DateTime.MinValue, actual.StartTime); Assert.AreEqual(DateTime.MinValue, actual.EndTime); }
public void ExecutionEnvironmentUtils_GetXmlOutputFromEnvironment_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.GetXmlOutputFromEnvironment(dataObj, dataList, 0); //------------Assert Results------------------------- StringAssert.Contains(actual, "<DataList>"); StringAssert.Contains(actual, "<rec>"); StringAssert.Contains(actual, "<a>1</a>"); StringAssert.Contains(actual, "<a></a>"); StringAssert.Contains(actual, "</rec>"); StringAssert.Contains(actual, "</DataList>"); StringAssert.Contains(actual, "<FullName>Bob Mary</FullName>"); Assert.IsFalse(actual.Contains("<Name>Bob</Name>")); Assert.IsFalse(actual.Contains("<Surname>Mary</Surname>")); Assert.IsFalse(actual.Contains("<b>2</b>")); Assert.IsFalse(actual.Contains("<c>3</c>")); }
protected static void BindRequestVariablesToDataObject(WebRequestTO request, ref DsfDataObject dataObject) { if (dataObject != null && request != null) { if (!string.IsNullOrEmpty(request.Bookmark)) { dataObject.CurrentBookmarkName = request.Bookmark; } if (!string.IsNullOrEmpty(request.InstanceID)) { Guid tmpId; if (Guid.TryParse(request.InstanceID, out tmpId)) { dataObject.WorkflowInstanceId = tmpId; } } if (!string.IsNullOrEmpty(request.ServiceName) && string.IsNullOrEmpty(dataObject.ServiceName)) { dataObject.ServiceName = request.ServiceName; } } }
public void JsonMappingCompoundTo_EvalResultIndexed_IsCompound() { //------------Setup for test-------------------------- var dataObject = new DsfDataObject(xmldata: string.Empty, dataListId: Guid.NewGuid()); dataObject.Environment.Assign("[[a]]", "10", 0); dataObject.Environment.Assign("[[b]]", "20", 0); dataObject.Environment.Assign("[[rec(1).a]]", "50", 0); dataObject.Environment.Assign("[[rec(1).b]]", "500", 0); //------------Execute Test--------------------------- var jsonMappingCompound = new JsonMappingCompoundTo( env: dataObject.Environment, compound: new JsonMappingTo { SourceName = "[[a]],[[b]]", DestinationName = "myName" } ); //------------Assert Results------------------------- Assert.IsNotNull(jsonMappingCompound); Assert.IsTrue(jsonMappingCompound.IsCompound); }
public void SharepointCopyFileActivity_ValidateRequest_ServerInputPathFrom_IsEmpty_ExpectAreEqual_Success() { //------------Setup for test-------------------------- const string activityName = "SharepointCopyFile"; var resourceCatalog = new Mock <IResourceCatalog>(); var mockSharepointSource = new Mock <SharepointSource>(); var resourceId = Guid.NewGuid(); var sharepointCopyFileActivity = new SharepointCopyFileActivity { DisplayName = activityName, SharepointServerResourceId = resourceId, Result = "[[Files(*).Name]]", ServerInputPathTo = "Hello World.bite", Overwrite = true }; var privateObject = new Warewolf.Testing.PrivateObject(sharepointCopyFileActivity); var dataObj = new DsfDataObject("", Guid.NewGuid(), ""); resourceCatalog.Setup(r => r.GetResource <SharepointSource>(It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(mockSharepointSource.Object); sharepointCopyFileActivity.ResourceCatalog = resourceCatalog.Object; sharepointCopyFileActivity.SharepointSource = mockSharepointSource.Object; try { //------------Execute Test--------------------------- privateObject.Invoke("ValidateRequest"); } catch (TargetInvocationException e) { //------------Assert Result-------------------------- Assert.AreEqual("Server input path FROM is not set", e.InnerException?.Message, "Expected exception was not thrown"); } }
public void DataObject_Ctor_WhenXmlStringContainsAllIncludingDataMergePropertiesSet_ExpectParseAndSet() { //------------Setup for test-------------------------- var debugID = Guid.NewGuid(); var envID = Guid.NewGuid(); var exeID = Guid.NewGuid(); var bookmarkID = Guid.NewGuid(); var parentID = Guid.NewGuid(); var instID = Guid.NewGuid(); var mergeIDOut = Guid.NewGuid(); var mergeIDIn = Guid.NewGuid(); var versionNumber = "3"; var xmlStr = "<Payload>" + "<IsDebug>true</IsDebug>" + "<DebugSessionID>" + debugID + "</DebugSessionID>" + "<EnvironmentID>" + envID + "</EnvironmentID>" + "<VersionNumber>" + versionNumber + "</VersionNumber>" + "<IsOnDemandSimulation>true</IsOnDemandSimulation>" + "<ParentServiceName>TestParentService</ParentServiceName>" + "<ExecutionCallbackID>" + exeID + "</ExecutionCallbackID>" + "<BookmarkExecutionCallbackID>" + bookmarkID + "</BookmarkExecutionCallbackID>" + "<ParentInstanceID>" + parentID + "</ParentInstanceID>" + "<NumberOfSteps>5</NumberOfSteps>" + "<CurrentBookmarkName>MyBookmark</CurrentBookmarkName>" + "<WorkflowInstanceId>" + instID + "</WorkflowInstanceId>" + "<IsDataListScoped>true</IsDataListScoped>" + "<Service>MyTestService</Service>" + "<DatalistOutMergeID>" + mergeIDOut + "</DatalistOutMergeID>" + "<DatalistOutMergeType>Union</DatalistOutMergeType>" + "<DatalistOutMergeDepth>Data</DatalistOutMergeDepth>" + "<DatalistOutMergeFrequency>Never</DatalistOutMergeFrequency>" + "<DatalistInMergeID>" + mergeIDIn + "</DatalistInMergeID>" + "<DatalistInMergeType>Union</DatalistInMergeType>" + "<DatalistInMergeDepth>Data</DatalistInMergeDepth>" + "</Payload>"; //------------Execute Test--------------------------- var dataObjct = new DsfDataObject(xmlStr, Guid.NewGuid(), "<x>1</x>"); //------------Assert Results------------------------- Assert.IsTrue(dataObjct.IsDebug); StringAssert.Contains(dataObjct.DebugSessionID.ToString(), debugID.ToString()); StringAssert.Contains(dataObjct.EnvironmentID.ToString(), envID.ToString()); StringAssert.Contains(dataObjct.VersionNumber.ToString(), versionNumber); Assert.IsTrue(dataObjct.IsOnDemandSimulation); StringAssert.Contains(dataObjct.ParentServiceName, "TestParentService"); StringAssert.Contains(dataObjct.ExecutionCallbackID.ToString(), exeID.ToString()); StringAssert.Contains(dataObjct.BookmarkExecutionCallbackID.ToString(), bookmarkID.ToString()); StringAssert.Contains(dataObjct.ParentInstanceID, parentID.ToString()); Assert.AreEqual(5, dataObjct.NumberOfSteps, "Wrong number of steps"); StringAssert.Contains(dataObjct.CurrentBookmarkName, "MyBookmark"); StringAssert.Contains(dataObjct.WorkflowInstanceId.ToString(), instID.ToString()); Assert.IsTrue(dataObjct.IsDataListScoped); StringAssert.Contains(dataObjct.ServiceName, "MyTestService"); StringAssert.Contains(dataObjct.RawPayload.ToString(), xmlStr); // Data Merge Checks StringAssert.Contains(dataObjct.DatalistOutMergeID.ToString(), mergeIDOut.ToString()); StringAssert.Contains(dataObjct.DatalistOutMergeType.ToString(), enDataListMergeTypes.Union.ToString()); StringAssert.Contains(dataObjct.DatalistOutMergeDepth.ToString(), Common.Interfaces.DataList.Contract.enTranslationDepth.Data.ToString()); StringAssert.Contains(dataObjct.DatalistOutMergeFrequency.ToString(), DataListMergeFrequency.OnCompletion.ToString()); StringAssert.Contains(dataObjct.DatalistInMergeID.ToString(), mergeIDIn.ToString()); StringAssert.Contains(dataObjct.DatalistInMergeType.ToString(), enDataListMergeTypes.Union.ToString()); StringAssert.Contains(dataObjct.DatalistInMergeDepth.ToString(), Common.Interfaces.DataList.Contract.enTranslationDepth.Data.ToString()); }
public void DsfDataObject_Clone_NormalClone_FullDuplicationForProperties() { var executingUser = new Mock <IPrincipal>().Object; //------------Setup for test-------------------------- var wfInstanceID = Guid.NewGuid(); IDSFDataObject dataObject = new DsfDataObject(string.Empty, Guid.NewGuid(), "<x>1</x>"); dataObject.BookmarkExecutionCallbackID = Guid.NewGuid(); dataObject.CurrentBookmarkName = "def"; dataObject.DataList = new StringBuilder("<x/>"); dataObject.DataListID = Guid.NewGuid(); dataObject.DatalistInMergeDepth = enTranslationDepth.Data; dataObject.DatalistInMergeID = Guid.NewGuid(); dataObject.DatalistInMergeType = enDataListMergeTypes.Union; dataObject.DatalistOutMergeDepth = enTranslationDepth.Data; dataObject.DatalistOutMergeFrequency = DataListMergeFrequency.Always; dataObject.DatalistOutMergeID = Guid.NewGuid(); dataObject.DatalistOutMergeType = enDataListMergeTypes.Union; dataObject.DebugSessionID = Guid.NewGuid(); dataObject.EnvironmentID = Guid.NewGuid(); dataObject.VersionNumber = 1; dataObject.ExecutionCallbackID = Guid.NewGuid(); dataObject.ExecutionOrigin = ExecutionOrigin.Debug; dataObject.ExecutingUser = executingUser; dataObject.ExecutionOriginDescription = "xxx"; dataObject.ForceDeleteAtNextNativeActivityCleanup = true; dataObject.IsDataListScoped = false; dataObject.IsDebug = true; dataObject.IsFromWebServer = true; dataObject.IsOnDemandSimulation = true; dataObject.NumberOfSteps = 2; dataObject.OriginalInstanceID = Guid.NewGuid(); dataObject.ParentInstanceID = "1211"; dataObject.ParentServiceName = "xxx"; dataObject.ParentThreadID = 2; dataObject.ParentWorkflowInstanceId = "1233"; dataObject.RawPayload = new StringBuilder("<raw>a</raw>"); dataObject.RemoteDebugItems = new List <IDebugState>(); dataObject.RemoteInvoke = false; dataObject.RemoteInvokeResultShape = new StringBuilder("<x/>"); dataObject.RemoteInvokerID = "999"; dataObject.RemoteServiceType = "NA"; dataObject.ResourceID = Guid.NewGuid(); dataObject.ReturnType = EmitionTypes.XML; dataObject.ServerID = Guid.NewGuid(); dataObject.ServiceName = "xxx"; dataObject.WorkflowInstanceId = wfInstanceID; dataObject.WorkflowResumeable = false; dataObject.ParentID = Guid.NewGuid(); dataObject.WorkspaceID = Guid.NewGuid(); dataObject.ClientID = Guid.NewGuid(); dataObject.RunWorkflowAsync = true; dataObject.IsDebugNested = true; dataObject.ForEachNestingLevel = 3; dataObject.StopExecution = false; dataObject.IsServiceTestExecution = true; dataObject.TestName = "Test 1"; dataObject.IsDebugFromWeb = true; dataObject.SourceResourceID = Guid.NewGuid(); dataObject.IsSubExecution = true; dataObject.ServiceTest = new ServiceTestModelTO { TestName = "Test Mock" }; dataObject.StateNotifier = new Mock <IStateNotifier>().Object; dataObject.Settings = new Dev2WorkflowSettingsTO { KeepLogsForDays = 999 }; var threadsToDispose = new Dictionary <int, List <Guid> >(); var guidList = new List <Guid> { Guid.NewGuid() }; threadsToDispose.Add(3, guidList); dataObject.ThreadsToDispose = threadsToDispose; dataObject.AuthCache = new ConcurrentDictionary <(IPrincipal, Dev2.Common.Interfaces.Enums.AuthorizationContext, string), bool>(); //------------Execute Test--------------------------- var clonedObject = dataObject.Clone(); //------------Assert Results------------------------- // check counts, then check values var properties = typeof(IDSFDataObject).GetProperties(); Assert.AreEqual(72, properties.Length); // now check each value to ensure it transfered Assert.AreEqual(dataObject.BookmarkExecutionCallbackID, clonedObject.BookmarkExecutionCallbackID); Assert.AreEqual(dataObject.CurrentBookmarkName, clonedObject.CurrentBookmarkName); Assert.AreEqual(dataObject.DataList, clonedObject.DataList); Assert.AreEqual(dataObject.DataListID, clonedObject.DataListID); Assert.AreEqual(dataObject.DatalistInMergeDepth, clonedObject.DatalistInMergeDepth); Assert.AreEqual(dataObject.DatalistInMergeID, clonedObject.DatalistInMergeID); Assert.AreEqual(dataObject.DatalistInMergeType, clonedObject.DatalistInMergeType); Assert.AreEqual(dataObject.DatalistOutMergeDepth, clonedObject.DatalistOutMergeDepth); Assert.AreEqual(dataObject.DatalistOutMergeFrequency, clonedObject.DatalistOutMergeFrequency); Assert.AreEqual(dataObject.DatalistOutMergeID, clonedObject.DatalistOutMergeID); Assert.AreEqual(dataObject.DatalistOutMergeType, clonedObject.DatalistOutMergeType); Assert.AreEqual(dataObject.DebugSessionID, clonedObject.DebugSessionID); Assert.AreEqual(dataObject.EnvironmentID, clonedObject.EnvironmentID); Assert.AreEqual(dataObject.VersionNumber, clonedObject.VersionNumber); Assert.AreEqual(dataObject.ExecutingUser, clonedObject.ExecutingUser); Assert.AreEqual(dataObject.ExecutionCallbackID, clonedObject.ExecutionCallbackID); Assert.AreEqual(dataObject.ExecutionOrigin, clonedObject.ExecutionOrigin); Assert.AreEqual(dataObject.ExecutionOriginDescription, clonedObject.ExecutionOriginDescription); Assert.AreEqual(dataObject.ForceDeleteAtNextNativeActivityCleanup, clonedObject.ForceDeleteAtNextNativeActivityCleanup); Assert.AreEqual(dataObject.IsDataListScoped, clonedObject.IsDataListScoped); Assert.AreEqual(dataObject.IsDebug, clonedObject.IsDebug); Assert.AreEqual(dataObject.IsFromWebServer, clonedObject.IsFromWebServer); Assert.AreEqual(dataObject.IsOnDemandSimulation, clonedObject.IsOnDemandSimulation); Assert.AreEqual(dataObject.IsRemoteInvoke, clonedObject.IsRemoteInvoke); Assert.AreEqual(dataObject.IsRemoteInvokeOverridden, clonedObject.IsRemoteInvokeOverridden); Assert.AreEqual(dataObject.NumberOfSteps, clonedObject.NumberOfSteps); Assert.AreEqual(dataObject.OriginalInstanceID, clonedObject.OriginalInstanceID); Assert.AreEqual(dataObject.ParentInstanceID, clonedObject.ParentInstanceID); Assert.AreEqual(dataObject.ParentServiceName, clonedObject.ParentServiceName); Assert.AreEqual(dataObject.ParentThreadID, clonedObject.ParentThreadID); Assert.AreEqual(dataObject.ParentWorkflowInstanceId, clonedObject.ParentWorkflowInstanceId); Assert.AreEqual(dataObject.RawPayload, clonedObject.RawPayload); Assert.AreEqual(dataObject.RemoteDebugItems, clonedObject.RemoteDebugItems); Assert.AreEqual(dataObject.RemoteInvoke, clonedObject.RemoteInvoke); Assert.AreEqual(dataObject.RemoteNonDebugInvoke, clonedObject.RemoteNonDebugInvoke); Assert.AreEqual(dataObject.RemoteInvokeResultShape, clonedObject.RemoteInvokeResultShape); Assert.AreEqual(dataObject.RemoteInvokerID, clonedObject.RemoteInvokerID); Assert.AreEqual(dataObject.RemoteServiceType, clonedObject.RemoteServiceType); Assert.AreEqual(dataObject.ResourceID, clonedObject.ResourceID); Assert.AreEqual(dataObject.ReturnType, clonedObject.ReturnType); Assert.AreEqual(dataObject.ServerID, clonedObject.ServerID); Assert.AreEqual(dataObject.ClientID, clonedObject.ClientID); Assert.AreEqual(dataObject.ServiceName, clonedObject.ServiceName); Assert.AreEqual(dataObject.WorkflowInstanceId, clonedObject.WorkflowInstanceId); Assert.AreEqual(dataObject.WorkflowResumeable, clonedObject.WorkflowResumeable); Assert.AreEqual(dataObject.WorkspaceID, clonedObject.WorkspaceID); Assert.AreEqual(dataObject.ThreadsToDispose, clonedObject.ThreadsToDispose); Assert.AreEqual(dataObject.ParentID, clonedObject.ParentID); Assert.AreEqual(dataObject.RunWorkflowAsync, clonedObject.RunWorkflowAsync); Assert.AreEqual(dataObject.IsDebugNested, clonedObject.IsDebugNested); Assert.AreEqual(dataObject.ForEachNestingLevel, clonedObject.ForEachNestingLevel); Assert.AreEqual(dataObject.StopExecution, clonedObject.StopExecution); Assert.AreEqual(dataObject.SourceResourceID, clonedObject.SourceResourceID); Assert.AreEqual(dataObject.TestName, clonedObject.TestName); Assert.AreEqual(dataObject.IsServiceTestExecution, clonedObject.IsServiceTestExecution); Assert.AreEqual(dataObject.IsDebugFromWeb, clonedObject.IsDebugFromWeb); Assert.AreNotEqual(dataObject.ServiceTest, clonedObject.ServiceTest); Assert.AreEqual(dataObject.ServiceTest.TestName, clonedObject.ServiceTest.TestName); Assert.AreEqual(dataObject.IsSubExecution, clonedObject.IsSubExecution); Assert.AreEqual(dataObject.WebUrl, clonedObject.WebUrl); Assert.AreEqual(dataObject.QueryString, clonedObject.QueryString); Assert.AreEqual(dataObject.ExecutingUser, clonedObject.ExecutingUser); Assert.AreEqual(dataObject.StateNotifier, clonedObject.StateNotifier); Assert.AreNotEqual(dataObject.Settings, clonedObject.Settings); Assert.AreEqual(dataObject.Settings.KeepLogsForDays, clonedObject.Settings.KeepLogsForDays); Assert.AreNotEqual(dataObject.AuthCache, clonedObject.AuthCache); Assert.AreEqual(dataObject.ExecutionException, clonedObject.ExecutionException); }
public void GateActivity_Execute_GivenPassingConditionsOnFirstGateAndFailingSecondGate_ExpectDetailedLog() { var firstGateId = Guid.NewGuid(); var secondGateId = Guid.NewGuid(); var failingCondition = new ConditionExpression { Left = "[[somebob]]", Cond = new ConditionMatch { MatchType = enDecisionType.IsEqual, Right = "notbob" } }; var failingConditions = new List <ConditionExpression>(); failingConditions.Add(failingCondition); var thirdNode = new Mock <IDev2Activity>().Object; var secondGate = new GateActivity { UniqueID = secondGateId.ToString(), RetryEntryPointId = firstGateId, Conditions = failingConditions, NextNodes = new List <IDev2Activity> { thirdNode }, }; //---------------Set up test pack------------------- var passingCondition = new ConditionExpression { Left = "[[a]]", Cond = new ConditionMatch { MatchType = enDecisionType.IsEqual, Right = "bob" } }; var passingConditions = new List <ConditionExpression>(); passingConditions.Add(passingCondition); //------------Setup for test-------------------------- var firstGate = new GateActivity { UniqueID = firstGateId.ToString(), Conditions = passingConditions, NextNodes = new List <IDev2Activity> { secondGate }, GateOptions = new GateOptions() { GateOpts = new Continue() } }; var mockStateNotifier = new Mock <IStateNotifier>(); mockStateNotifier.Setup(stateNotifier => stateNotifier.LogActivityExecuteState(It.IsAny <IDev2Activity>())); firstGate.SetStateNotifier(mockStateNotifier.Object); var dataObject = new DsfDataObject("", Guid.NewGuid()); dataObject.Environment.Assign("[[a]]", "bob", 0); var result = firstGate.Execute(dataObject, 0); dataObject.Environment.Assign("[[a]]", "ralph", 0); Assert.AreEqual("ralph", dataObject.Environment.EvalAsListOfStrings("[[a]]", 0)[0]); Assert.AreEqual(secondGate, result); result = result.Execute(dataObject, 0); Assert.AreEqual(firstGate, result); result = result.Execute(dataObject, 0); Assert.AreEqual("bob", dataObject.Environment.EvalAsListOfStrings("[[a]]", 0)[0]); Assert.AreEqual(secondGate, result); dataObject.Environment.Assign("[[somebob]]", "notbob", 0); result = result.Execute(dataObject, 0); Assert.AreEqual(thirdNode, result); mockStateNotifier.Verify(o => o.LogActivityExecuteState(It.IsAny <IDev2Activity>()), Times.Exactly(2)); }