public void SuspendExecutionActivity_GetChildrenNodes_ShouldReturnChildNodes() { var activity = CreateWorkflow(); var activityFunction = new ActivityFunc<string, bool> { DisplayName = activity.DisplayName, Handler = activity, }; var suspendExecutionActivity = new SuspendExecutionActivity { SuspendOption = enSuspendOption.SuspendForDays, PersistValue = "15", AllowManualResumption = true, SaveDataFunc = activityFunction, Response = "[[result]]" }; Assert.AreEqual("Suspend Execution", suspendExecutionActivity.DisplayName); Assert.AreEqual("15", suspendExecutionActivity.PersistValue); Assert.AreEqual(enSuspendOption.SuspendForDays, suspendExecutionActivity.SuspendOption); Assert.IsTrue(suspendExecutionActivity.AllowManualResumption); Assert.AreEqual("TestService", suspendExecutionActivity.SaveDataFunc.DisplayName); var result = suspendExecutionActivity.GetChildrenNodes().ToList(); Assert.AreEqual(1, result.Count); Assert.AreEqual(activity, result[0]); }
public void SuspendExecutionActivity_Equals_Set_OtherIsObjectOfSuspendExecutionActivityEqual_Returns_IsFalse() { var suspendExecutionActivity = new SuspendExecutionActivity(); object suspendExecutionActivityOther = new SuspendExecutionActivity(); var equal = suspendExecutionActivity.Equals(suspendExecutionActivityOther); Assert.IsFalse(equal); }
public void SuspendExecutionActivity_Equals_Set_OtherIsEqual_Returns_IsTrue() { var suspendExecutionActivity = new SuspendExecutionActivity(); var suspendExecutionActivityOther = suspendExecutionActivity; var equal = suspendExecutionActivity.Equals(suspendExecutionActivityOther); Assert.IsTrue(equal); }
public void SuspendExecutionActivity_Equals_Set_BothAreObjects_Returns_IsFalse() { object suspendExecutionActivity = new SuspendExecutionActivity(); var suspendExecutionActivityOther = new object(); var equal = suspendExecutionActivity.Equals(suspendExecutionActivityOther); Assert.IsFalse(equal); }
public void SuspendExecutionActivity_Equals_Set_OtherIsNull_Returns_IsFalse() { var suspendExecutionActivity = new SuspendExecutionActivity(); var equals = suspendExecutionActivity.Equals(null); Assert.IsFalse(equals); }
public void SuspendExecutionActivity_GetHashCode() { var suspendExecutionActivity = new SuspendExecutionActivity(); var hashCode = suspendExecutionActivity.GetHashCode(); Assert.IsNotNull(hashCode); }
public void SuspendExecutionActivity_Initialize() { var suspendExecutionActivity = new SuspendExecutionActivity(); Assert.AreEqual("Suspend Execution", suspendExecutionActivity.DisplayName); Assert.IsNull(suspendExecutionActivity.PersistValue); Assert.AreEqual(enSuspendOption.SuspendUntil, suspendExecutionActivity.SuspendOption); Assert.IsFalse(suspendExecutionActivity.AllowManualResumption); Assert.AreEqual("Data Action", suspendExecutionActivity.SaveDataFunc.DisplayName); }
public void SuspendExecutionActivity_GetSuspendVaidationMessageType_Validate() { Assert.AreEqual("Date", SuspendExecutionActivity.GetSuspendValidationMessageType(enSuspendOption.SuspendUntil)); Assert.AreEqual("Seconds", SuspendExecutionActivity.GetSuspendValidationMessageType(enSuspendOption.SuspendForSeconds)); Assert.AreEqual("Minutes", SuspendExecutionActivity.GetSuspendValidationMessageType(enSuspendOption.SuspendForMinutes)); Assert.AreEqual("Hours", SuspendExecutionActivity.GetSuspendValidationMessageType(enSuspendOption.SuspendForHours)); Assert.AreEqual("Days", SuspendExecutionActivity.GetSuspendValidationMessageType(enSuspendOption.SuspendForDays)); Assert.AreEqual("Months", SuspendExecutionActivity.GetSuspendValidationMessageType(enSuspendOption.SuspendForMonths)); }
public void SuspendExecututionActivity_GetFindMissingType_GivenIsNew_ShouldSetManualResumptionActivity() { //---------------Set up test pack------------------- var activity = CreateWorkflow(); var activityFunction = new ActivityFunc<string, bool> { DisplayName = activity.DisplayName, Handler = activity, }; var suspendExecutionActivity = new SuspendExecutionActivity(); //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- var enFindMissingType = suspendExecutionActivity.GetFindMissingType(); //---------------Test Result ----------------------- Assert.AreEqual(enFindMissingType.SuspendExecution, enFindMissingType); }
public void SuspendExecutionActivity_Execute_ServiceTestExecution_Success() { //------------Setup for test-------------------------- var workflowName = "workflowName"; var url = "http://localhost:3142/secure/WorkflowResume"; var resourceId = Guid.NewGuid(); var nextNodeId = Guid.NewGuid(); var workflowInstanceId = Guid.NewGuid(); var env = CreateExecutionEnvironment(); env.Assign("[[UUID]]", "public", 0); env.Assign("[[JourneyName]]", "whatever", 0); var mockStateNotifier = new Mock<IStateNotifier>(); mockStateNotifier.Setup(stateNotifier => stateNotifier.LogActivityExecuteState(It.IsAny<IDev2Activity>())); var environmentId = Guid.Empty; var mockPrincipal = new Mock<ClaimsPrincipal>(); mockPrincipal.Setup(o => o.Identity).Returns(WindowsIdentity.GetCurrent()); var dataObject = new DsfDataObject(CurrentDl, ExecutionId) { ServiceName = workflowName, ResourceID = resourceId, WorkflowInstanceId = workflowInstanceId, WebUrl = url, ServerID = Guid.NewGuid(), ExecutingUser = mockPrincipal.Object, IsDebug = true, EnvironmentID = environmentId, Environment = env, IsRemoteInvokeOverridden = false, DataList = new StringBuilder(CurrentDl), IsServiceTestExecution = true }; var mockActivity = new Mock<IDev2Activity>(); mockActivity.Setup(o => o.UniqueID).Returns(nextNodeId.ToString()); var dev2Activities = new List<IDev2Activity> {mockActivity.Object}; var activity = CreateWorkflow(); var activityFunction = new ActivityFunc<string, bool> { DisplayName = activity.DisplayName, Handler = activity, }; var config = new PersistenceSettings { Enable = true }; var expectedSuspendId = Guid.NewGuid().ToString(); const enSuspendOption suspendOption = enSuspendOption.SuspendForSeconds; var mockSuspendExecution = new Mock<IPersistenceExecution>(); mockSuspendExecution.Setup(o => o.CreateAndScheduleJob(suspendOption, It.IsAny<string>(), It.IsAny<Dictionary<string, StringBuilder>>())).Returns(expectedSuspendId); var suspendExecutionActivity = new SuspendExecutionActivity(config, mockSuspendExecution.Object) { SuspendOption = suspendOption, PersistValue = "20", AllowManualResumption = true, SaveDataFunc = activityFunction, Result = "[[SuspendID]]", NextNodes = dev2Activities }; suspendExecutionActivity.SetStateNotifier(mockStateNotifier.Object); //------------Execute Test--------------------------- suspendExecutionActivity.Execute(dataObject, 0); //------------Assert Results------------------------- Assert.AreEqual(0, env.Errors.Count); Assert.AreEqual(expectedSuspendId, suspendExecutionActivity.Response); Assert.IsFalse(dataObject.StopExecution, "this will Stop Execution for the whole workflow, which is not ideal for the problem we are resolving"); Assert.IsFalse(dataObject.IsDebugNested); Assert.AreEqual(0, dataObject.ForEachNestingLevel); }
public void SuspendExecutionActivity_Execute_PersistenceNotConfigured_FailWithMessage() { //------------Setup for test-------------------------- var workflowName = "workflowName"; var url = "http://localhost:3142/secure/WorkflowResume"; var resourceId = Guid.NewGuid(); var nextNodeId = Guid.NewGuid(); var workflowInstanceId = Guid.NewGuid(); var env = CreateExecutionEnvironment(); env.Assign("[[UUID]]", "public", 0); env.Assign("[[JourneyName]]", "whatever", 0); var mockStateNotifier = new Mock<IStateNotifier>(); mockStateNotifier.Setup(stateNotifier => stateNotifier.LogActivityExecuteState(It.IsAny<IDev2Activity>())); var environmentId = Guid.Empty; User = new Mock<IPrincipal>().Object; var dataObject = new DsfDataObject(CurrentDl, ExecutionId) { ServiceName = workflowName, ResourceID = resourceId, WorkflowInstanceId = workflowInstanceId, WebUrl = url, ServerID = Guid.NewGuid(), ExecutingUser = User, IsDebug = true, EnvironmentID = environmentId, Environment = env, IsRemoteInvokeOverridden = false, DataList = new StringBuilder(CurrentDl), IsServiceTestExecution = true }; var mockActivity = new Mock<IDev2Activity>(); mockActivity.Setup(o => o.UniqueID).Returns(nextNodeId.ToString()); var dev2Activities = new List<IDev2Activity> {mockActivity.Object}; var activity = CreateWorkflow(); var activityFunction = new ActivityFunc<string, bool> { DisplayName = activity.DisplayName, Handler = activity, }; var suspendUntil = DateTime.Now.AddDays(1); var config = new PersistenceSettings { Enable = false }; var suspendExecutionActivity = new SuspendExecutionActivity(config, new Mock<IPersistenceExecution>().Object) { SuspendOption = enSuspendOption.SuspendUntil, PersistValue = suspendUntil.ToString(), AllowManualResumption = true, SaveDataFunc = activityFunction, Result = "[[SuspendID]]", NextNodes = dev2Activities }; suspendExecutionActivity.SetStateNotifier(mockStateNotifier.Object); //------------Execute Test--------------------------- suspendExecutionActivity.Execute(dataObject, 0); //------------Assert Results------------------------- suspendExecutionActivity.Execute(dataObject, 0); //------------Assert Results------------------------- Assert.AreEqual(1, env.AllErrors.Count); var errors = env.AllErrors.ToList(); Assert.AreEqual(ErrorResource.PersistenceSettingsNoConfigured, errors[0]); }
public void SuspendExecutionActivity_Execute_EncryptData_False() { //------------Setup for test-------------------------- var workflowName = "workflowName"; var url = "http://localhost:3142/secure/WorkflowResume"; var resourceId = Guid.NewGuid(); var nextNodeId = Guid.NewGuid(); var workflowInstanceId = Guid.NewGuid(); var env = CreateExecutionEnvironment(); env.Assign("[[UUID]]", "public", 0); env.Assign("[[JourneyName]]", "whatever", 0); var mockStateNotifier = new Mock<IStateNotifier>(); mockStateNotifier.Setup(stateNotifier => stateNotifier.LogActivityExecuteState(It.IsAny<IDev2Activity>())); var environmentId = Guid.Empty; var mockPrincipal = new Mock<ClaimsPrincipal>(); mockPrincipal.Setup(o => o.Identity).Returns(WindowsIdentity.GetCurrent()); var dataObject = new DsfDataObject(CurrentDl, ExecutionId) { ServiceName = workflowName, ResourceID = resourceId, WorkflowInstanceId = workflowInstanceId, WebUrl = url, ServerID = Guid.NewGuid(), ExecutingUser = mockPrincipal.Object, IsDebug = true, EnvironmentID = environmentId, Environment = env, IsRemoteInvokeOverridden = false, DataList = new StringBuilder(CurrentDl), IsServiceTestExecution = true }; var mockActivity = new Mock<IDev2Activity>(); mockActivity.Setup(o => o.UniqueID).Returns(nextNodeId.ToString()); var dev2Activities = new List<IDev2Activity> {mockActivity.Object}; var activity = CreateWorkflow(); var activityFunction = new ActivityFunc<string, bool> { DisplayName = activity.DisplayName, Handler = activity, }; var suspendUntil = DateTime.Now.AddDays(1); var config = new PersistenceSettings { Enable = true }; var currentEnvironment = dataObject.Environment.ToJson(); var values = new Dictionary<string, StringBuilder> { {"resourceID", new StringBuilder(dataObject.ResourceID.ToString())}, {"environment", new StringBuilder(currentEnvironment)}, {"startActivityId", new StringBuilder(nextNodeId.ToString())}, {"versionNumber", new StringBuilder(dataObject.VersionNumber.ToString())}, {"currentuserprincipal", new StringBuilder(WindowsIdentity.GetCurrent().Name)} }; var mockSuspendExecution = new Mock<IPersistenceExecution>(); mockSuspendExecution.Setup(o => o.CreateAndScheduleJob(enSuspendOption.SuspendUntil, suspendUntil.ToString(), values)).Verifiable(); var suspendExecutionActivity = new SuspendExecutionActivity(config, mockSuspendExecution.Object) { SuspendOption = enSuspendOption.SuspendUntil, PersistValue = suspendUntil.ToString(), AllowManualResumption = true, EncryptData = false, SaveDataFunc = activityFunction, //Result = "[[SuspendID]]", NextNodes = dev2Activities }; suspendExecutionActivity.SetStateNotifier(mockStateNotifier.Object); //------------Execute Test--------------------------- suspendExecutionActivity.Execute(dataObject, 0); //------------Assert Results------------------------- Assert.AreEqual(0, env.Errors.Count); GetScalarValueFromEnvironment(env, "SuspendID", out string suspendId, out string error); Assert.AreEqual(suspendId, suspendExecutionActivity.Response); //TODO: We need to improve on this verify to validate that the environment is not encrypted. Verify fails for unknown mismatch mockSuspendExecution.Verify(o => o.CreateAndScheduleJob(enSuspendOption.SuspendUntil, suspendUntil.ToString(), It.IsAny<Dictionary<string, StringBuilder>>()), Times.Once); }
public void SuspendExecutionActivity_Execute_SuspendForSeconds_SaveSuspendIDIntoEnv_Success() { //------------Setup for test-------------------------- var workflowName = "workflowName"; var url = "http://localhost:3142/secure/WorkflowResume"; var resourceId = Guid.NewGuid(); var nextNodeId = Guid.NewGuid(); var workflowInstanceId = Guid.NewGuid(); var env = CreateExecutionEnvironment(); env.Assign("[[UUID]]", "public", 0); env.Assign("[[JourneyName]]", "whatever", 0); var mockStateNotifier = new Mock<IStateNotifier>(); mockStateNotifier.Setup(stateNotifier => stateNotifier.LogActivityExecuteState(It.IsAny<IDev2Activity>())); var environmentId = Guid.Empty; User = GlobalConstants.GenericPrincipal; var dataObject = new DsfDataObject(CurrentDl, ExecutionId) { ServiceName = workflowName, ResourceID = resourceId, WorkflowInstanceId = workflowInstanceId, WebUrl = url, ServerID = Guid.NewGuid(), ExecutingUser = User, IsDebug = true, EnvironmentID = environmentId, Environment = env, IsRemoteInvokeOverridden = false, DataList = new StringBuilder(CurrentDl), IsServiceTestExecution = true }; var mockActivity = new Mock<IDev2Activity>(); mockActivity.Setup(o => o.UniqueID).Returns(nextNodeId.ToString()); var dev2Activities = new List<IDev2Activity> {mockActivity.Object}; var activity = CreateWorkflow(); var activityFunction = new ActivityFunc<string, bool> { DisplayName = activity.DisplayName, Handler = activity, }; var config = new PersistenceSettings { Enable = true }; var suspendExecutionActivity = new SuspendExecutionActivity(config, new Mock<IPersistenceExecution>().Object) { SuspendOption = enSuspendOption.SuspendForSeconds, PersistValue = "20", AllowManualResumption = true, SaveDataFunc = activityFunction, //Result = "[[SuspendID]]", NextNodes = dev2Activities }; suspendExecutionActivity.SetStateNotifier(mockStateNotifier.Object); //------------Execute Test--------------------------- suspendExecutionActivity.Execute(dataObject, 0); //------------Assert Results------------------------- Assert.AreEqual(0, env.Errors.Count); GetScalarValueFromEnvironment(env, "SuspendID", out string suspendId, out string error); Assert.AreEqual(suspendId, suspendExecutionActivity.Response); }
public void SuspendExecutionActivity_GetState() { var suspendExecutionActivity = new SuspendExecutionActivity { SuspendOption = enSuspendOption.SuspendForDays, PersistValue = "15", AllowManualResumption = true, EncryptData = true, Response = "[[response]]", Result = "[[result]]" }; var stateItems = suspendExecutionActivity.GetState(); Assert.AreEqual(6, stateItems.Count()); var expectedResults = new[] { new StateVariable { Name = "SuspendOption", Value = enSuspendOption.SuspendForDays.ToString(), Type = StateVariable.StateType.Input, }, new StateVariable { Name = "PersistValue", Value = "15", Type = StateVariable.StateType.Input, }, new StateVariable { Name = "AllowManualResumption", Value = "True", Type = StateVariable.StateType.Input, }, new StateVariable { Name = "EncryptData", Value = "True", Type = StateVariable.StateType.Input, }, new StateVariable { Name = "Response", Value = "[[response]]", Type = StateVariable.StateType.Output }, new StateVariable { Name = "Result", Value = "[[result]]", Type = StateVariable.StateType.Output } }; var iter = suspendExecutionActivity.GetState().Select( (item, index) => new { value = item, expectValue = expectedResults[index] } ); foreach (var entry in iter) { Assert.AreEqual(entry.expectValue.Name, entry.value.Name); Assert.AreEqual(entry.expectValue.Type, entry.value.Type); Assert.AreEqual(entry.expectValue.Value, entry.value.Value); } }
public void SuspendExecutionActivity_Execute_Empty_SuspendOptionValue() { //------------Setup for test-------------------------- var workflowName = "workflowName"; var url = "http://localhost:3142/secure/WorkflowResume"; var resourceId = Guid.NewGuid(); var nextNodeId = Guid.NewGuid(); var workflowInstanceId = Guid.NewGuid(); var env = CreateExecutionEnvironment(); env.Assign("[[UUID]]", "public", 0); env.Assign("[[JourneyName]]", "whatever", 0); var mockStateNotifier = new Mock<IStateNotifier>(); mockStateNotifier.Setup(stateNotifier => stateNotifier.LogActivityExecuteState(It.IsAny<IDev2Activity>())); var environmentId = Guid.Empty; var mockPrincipal = new Mock<ClaimsPrincipal>(); mockPrincipal.Setup(o => o.Identity).Returns(WindowsIdentity.GetCurrent()); var dataObject = new DsfDataObject(CurrentDl, ExecutionId) { ServiceName = workflowName, ResourceID = resourceId, WorkflowInstanceId = workflowInstanceId, WebUrl = url, ServerID = Guid.NewGuid(), ExecutingUser = mockPrincipal.Object, IsDebug = true, EnvironmentID = environmentId, Environment = env, IsRemoteInvokeOverridden = false, DataList = new StringBuilder(CurrentDl), IsServiceTestExecution = true }; var mockActivity = new Mock<IDev2Activity>(); mockActivity.Setup(o => o.UniqueID).Returns(nextNodeId.ToString()); var dev2Activities = new List<IDev2Activity> {mockActivity.Object}; var activity = CreateWorkflow(); var activityFunction = new ActivityFunc<string, bool> { DisplayName = activity.DisplayName, Handler = activity, }; var config = new PersistenceSettings { Enable = true }; var suspendExecutionActivity = new SuspendExecutionActivity(config, new Mock<IPersistenceExecution>().Object) { SuspendOption = enSuspendOption.SuspendUntil, PersistValue = string.Empty, AllowManualResumption = true, SaveDataFunc = activityFunction, NextNodes = dev2Activities, }; suspendExecutionActivity.SetStateNotifier(mockStateNotifier.Object); //------------Execute Test--------------------------- suspendExecutionActivity.Execute(dataObject, 0); Assert.AreEqual(null, suspendExecutionActivity.Response); Assert.AreEqual(1, env.Errors.Count()); var errors = env.Errors.ToList(); Assert.AreEqual("Suspend option Date value must not be null or empty.", errors[0]); }
public void ActivityParser_ParseToLinkedFlatList() { var topLevelActivity = new DsfDotNetMultiAssignActivity { DisplayName = "Assign (1)", UniqueID = "d006a409-333a-49d3-8e1c-7c908f6ba461", }; var suspendExecutionActivityOne = new SuspendExecutionActivity { DisplayName = "Suspend Execution", UniqueID = "66b7c885-9ea4-4d75-b822-13ff5ef28128", }; topLevelActivity.NextNodes = new List <IDev2Activity> { suspendExecutionActivityOne }; var dev2DecisionStackOne = new Dev2DecisionStack { DisplayText = "If [[a]] Is = 2" }; var flowDecisionActivityOne = new DsfDecision { DisplayName = "If [[a]] Is = 2", UniqueID = "1764efe9-4e0e-423a-8510-b35dc9b053f4", NextNodes = null, Conditions = dev2DecisionStackOne }; var fileWriteActivityOne = new FileWriteActivity { DisplayName = "Write File", UniqueID = "8e35adbf-d0c4-443b-ab04-2a83ca1aaa62", }; flowDecisionActivityOne.TrueArm = new [] { fileWriteActivityOne }; var flowDecisionActivityOneFalseArmAssign = new DsfDotNetMultiAssignActivity { DisplayName = "Assign (1)", UniqueID = "23b599b7-49f4-40a8-8304-f034d227d3dd", }; var flowDecisionActivityOneFalseArmFileWrite = new FileWriteActivity { DisplayName = "Write File", UniqueID = "baad2ce3-371b-4fec-81f4-0da4112078c8", }; flowDecisionActivityOneFalseArmAssign.NextNodes = new List <IDev2Activity> { flowDecisionActivityOneFalseArmFileWrite }; flowDecisionActivityOneFalseArmFileWrite.NextNodes = new List <IDev2Activity> { suspendExecutionActivityOne }; flowDecisionActivityOne.FalseArm = new [] { flowDecisionActivityOneFalseArmAssign }; suspendExecutionActivityOne.NextNodes = new List <IDev2Activity> { flowDecisionActivityOne }; var suspendExecutionActivityTwo = new SuspendExecutionActivity { DisplayName = "Suspend Execution", UniqueID = "f72ab5fe-efc9-46c5-8944-f2032f0613eb", }; fileWriteActivityOne.NextNodes = new List <IDev2Activity> { suspendExecutionActivityTwo }; var dev2DecisionStackTwo = new Dev2DecisionStack { DisplayText = "If [[a]] Is = 4" }; var flowDecisionActivityTwo = new DsfDecision { DisplayName = "If [[a]] Is = 4", UniqueID = "9ad7861e-6fe8-449f-8640-92147259f919", NextNodes = null, Conditions = dev2DecisionStackTwo }; var fileWriteActivityTwo = new FileWriteActivity { DisplayName = "Write File", UniqueID = "88deb70e-ad45-4735-8a87-a77f7eb54d83", }; var flowDecisionActivityTwoFalseArmAssign = new DsfDotNetMultiAssignActivity { DisplayName = "Assign (1)", UniqueID = "c511b3e4-819f-4c38-81f6-6579ae3f52df", }; var flowDecisionActivityTwoFalseArmFileWrite = new FileWriteActivity { DisplayName = "Write File", UniqueID = "3c477009-7b12-432f-908c-b0ad613e8c57", }; flowDecisionActivityTwoFalseArmAssign.NextNodes = new List <IDev2Activity> { flowDecisionActivityTwoFalseArmFileWrite }; flowDecisionActivityTwoFalseArmFileWrite.NextNodes = new List <IDev2Activity> { suspendExecutionActivityTwo }; flowDecisionActivityTwo.NextNodes = null; flowDecisionActivityTwo.TrueArm = new [] { fileWriteActivityTwo }; flowDecisionActivityTwo.FalseArm = new [] { flowDecisionActivityTwoFalseArmAssign }; suspendExecutionActivityTwo.NextNodes = new List <IDev2Activity> { flowDecisionActivityTwo }; var activityParser = new ActivityParser(); var activities = activityParser.ParseToLinkedFlatList(topLevelActivity); Assert.IsNotNull(activities); var dev2Activities = activities.ToList(); Assert.AreEqual(13, dev2Activities.Count); }