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