public void DataFunc_DifferentAssigns_Object_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var newGuid = Guid.NewGuid();
var commonAssign = CommonAssign(newGuid);
var commonAssign1 = CommonAssign(Guid.NewGuid());
var uniqueId = Guid.NewGuid().ToString();
var dsfForEachActivity = new DsfForEachActivity
{
UniqueID = uniqueId,
DisplayName = "AAA",
DataFunc = new ActivityFunc <string, bool>
{
Handler = commonAssign
}
};
var forEach = new DsfForEachActivity
{
UniqueID = uniqueId,
DisplayName = "AAA",
DataFunc = new ActivityFunc <string, bool>
{
Handler = commonAssign1
}
};
//---------------Assert Precondition----------------
Assert.IsNotNull(dsfForEachActivity);
//---------------Execute Test ----------------------
var @equals = dsfForEachActivity.Equals(forEach);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
DsfForEachActivity SetupArguments(string currentDl, string testData, enForEachType type, bool isInputMapping = false, string inputMapping = null, string from = null, string to = null, string csvIndexes = null, string numberExecutions = null)
{
var activityFunction = new ActivityFunc <string, bool>();
var activity = inputMapping != null?CreateWorkflow(inputMapping, isInputMapping) : CreateWorkflow();
activityFunction.Handler = activity;
var id = Guid.NewGuid().ToString();
var dsfForEachActivity = new DsfForEachActivity
{
DataFunc = activityFunction,
ForEachType = type,
NumOfExections = numberExecutions,
From = @from,
To = to,
CsvIndexes = csvIndexes,
UniqueID = id
};
TestStartNode = new FlowStep
{
Action = dsfForEachActivity
};
CurrentDl = testData;
TestData = currentDl;
return(dsfForEachActivity);
}
public void GivenIHaveAForEachAsExecutions(string activityName, string forEachType, string numberOfExecutions)
{
var forEachActivity = new DsfForEachActivity {
DisplayName = activityName
};
Enum.TryParse(forEachType, out enForEachType typeOfForEach);
forEachActivity.ForEachType = typeOfForEach;
forEachActivity.NumOfExections = numberOfExecutions;
scenarioContext.Add(activityName, forEachActivity);
}
public void GetActivityFieldsOffDsfForEachActivityWithADsfMultiAssignActivityInsideItExpectedAllFindMissingFieldsToBeReturned()
{
DsfMultiAssignActivity multiAssignActivity = new DsfMultiAssignActivity { FieldsCollection = new List<ActivityDTO> { new ActivityDTO("[[AssignRight1]]", "[[AssignLeft1]]", 1), new ActivityDTO("[[AssignRight2]]", "[[AssignLeft2]]", 2) } };
DsfForEachActivity activity = new DsfForEachActivity
{
ForEachElementName = "5",
DataFunc = { Handler = multiAssignActivity }
};
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.ForEach);
List<string> actual = strategy.GetActivityFields(activity);
List<string> expected = new List<string> { "[[AssignRight1]]", "[[AssignLeft1]]", "[[AssignRight2]]", "[[AssignLeft2]]", "5" };
CollectionAssert.AreEqual(expected, actual);
}
public void GetActivityFieldsOffDsfForEachActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfForEachActivity activity = new DsfForEachActivity();
activity.ForEachElementName = "[[ForEachElementName]]";
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
List <string> actual = strategy.GetActivityFields(activity);
List <string> expected = new List <string> {
"[[ForEachElementName]]"
};
CollectionAssert.AreEqual(expected, actual);
}
public void Dev2FindMissingStrategyFactory_GetActivityFieldsOff_DsfForEach_Activity_ExpectAllFindMissingFieldsToBeReturned()
{
var activity = new DsfForEachActivity
{
ForEachElementName = "[[ForEachElementName]]"
};
var fac = new Dev2FindMissingStrategyFactory();
var strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
var actual = strategy.GetActivityFields(activity);
var expected = new List <string> {
"[[ForEachElementName]]"
};
CollectionAssert.AreEqual(expected, actual);
}
public void UniqueIDDifferent_EmptySelectAndApply_Object_IsEqual()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var dsfForEachActivity = new DsfForEachActivity();
var forEach = new DsfForEachActivity();
//---------------Assert Precondition----------------
Assert.IsNotNull(dsfForEachActivity);
//---------------Execute Test ----------------------
var @equals = dsfForEachActivity.Equals(forEach);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
public void GetActivityFieldsOffDsfForEachActivityWithADsfActivityInsideItExpectedAllFindMissingFieldsToBeReturned()
{
DsfActivity dsfActivity = new DsfActivity
{
InputMapping = @"<Inputs><Input Name=""reg"" Source=""NUD2347"" DefaultValue=""NUD2347""><Validator Type=""Required"" /></Input><Input Name=""asdfsad"" Source=""registration223"" DefaultValue=""w3rt24324""><Validator Type=""Required"" /></Input><Input Name=""number"" Source=""[[number]]"" /></Inputs>",
OutputMapping = @"<Outputs><Output Name=""vehicleVin"" MapsTo=""VIN"" Value="""" /><Output Name=""vehicleColor"" MapsTo=""VehicleColor"" Value="""" /><Output Name=""speed"" MapsTo=""speed"" Value="""" Recordset=""Fines"" /><Output Name=""date"" MapsTo=""date"" Value=""Fines.Date"" Recordset=""Fines"" /><Output Name=""location"" MapsTo=""location"" Value="""" Recordset=""Fines"" /></Outputs>"
};
DsfForEachActivity activity = new DsfForEachActivity
{
ForEachElementName = "5",
DataFunc = { Handler = dsfActivity }
};
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.ForEach);
List<string> actual = strategy.GetActivityFields(activity);
List<string> expected = new List<string> { "NUD2347", "registration223", "[[number]]", "Fines.Date", "5" };
CollectionAssert.AreEqual(expected, actual);
}
// ReSharper disable InconsistentNaming
public void DsfForEach_UpdateDebugParentID_UniqueIdSameIfNestingLevelNotChanged()
// 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,
};
DsfForEachActivity act = new DsfForEachActivity();
var originalGuid = Guid.NewGuid();
act.UniqueID = originalGuid.ToString();
act.UpdateDebugParentID(dataObject);
Assert.AreEqual(originalGuid.ToString(), act.UniqueID);
Assert.AreEqual(act.GetWorkSurfaceMappingId(), originalGuid);
}
public void Equals_Given_Different_Object_Is_Not_Equal_CaseSensitive()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var dsfForEachActivity = new DsfForEachActivity {
UniqueID = uniqueId, DisplayName = "AAA"
};
var forEach = new DsfForEachActivity {
UniqueID = uniqueId, DisplayName = "aaa"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(dsfForEachActivity);
//---------------Execute Test ----------------------
var @equals = dsfForEachActivity.Equals(forEach);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
public void ForEachElementName_Different_Object_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var dsfForEachActivity = new DsfForEachActivity {
UniqueID = uniqueId, ForEachElementName = "A"
};
var forEach = new DsfForEachActivity {
UniqueID = uniqueId, ForEachElementName = "ass"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(dsfForEachActivity);
//---------------Execute Test ----------------------
var @equals = dsfForEachActivity.Equals(forEach);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
public void Equals_Given_Same_Object_IsEqual()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var dsfForEachActivity = new DsfForEachActivity {
UniqueID = uniqueId, DisplayName = "a"
};
var forEach = new DsfForEachActivity {
UniqueID = uniqueId, DisplayName = "a"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(dsfForEachActivity);
//---------------Execute Test ----------------------
var @equals = dsfForEachActivity.Equals(forEach);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}
public void ForEachType_Different_Object_Is_Not_Equal_CaseSensitive()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var dsfForEachActivity = new DsfForEachActivity {
UniqueID = uniqueId, ForEachType = enForEachType.InCSV
};
var forEach = new DsfForEachActivity {
UniqueID = uniqueId, ForEachType = enForEachType.InRange
};
//---------------Assert Precondition----------------
Assert.IsNotNull(dsfForEachActivity);
//---------------Execute Test ----------------------
var @equals = dsfForEachActivity.Equals(forEach);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
public void GetActivityFieldsOffDsfForEachActivityWithADsfActivityInsideItExpectedAllFindMissingFieldsToBeReturned()
{
DsfActivity dsfActivity = new DsfActivity();
dsfActivity.InputMapping = @"<Inputs><Input Name=""reg"" Source=""NUD2347"" DefaultValue=""NUD2347""><Validator Type=""Required"" /></Input><Input Name=""asdfsad"" Source=""registration223"" DefaultValue=""w3rt24324""><Validator Type=""Required"" /></Input><Input Name=""number"" Source=""[[number]]"" /></Inputs>";
dsfActivity.OutputMapping = @"<Outputs><Output Name=""vehicleVin"" MapsTo=""VIN"" Value="""" /><Output Name=""vehicleColor"" MapsTo=""VehicleColor"" Value="""" /><Output Name=""speed"" MapsTo=""speed"" Value="""" Recordset=""Fines"" /><Output Name=""date"" MapsTo=""date"" Value=""Fines.Date"" Recordset=""Fines"" /><Output Name=""location"" MapsTo=""location"" Value="""" Recordset=""Fines"" /></Outputs>";
DsfForEachActivity activity = new DsfForEachActivity();
activity.ForEachElementName = "5";
activity.DataFunc.Handler = dsfActivity;
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.ForEach);
List <string> actual = strategy.GetActivityFields(activity);
List <string> expected = new List <string> {
"NUD2347", "registration223", "[[number]]", "Fines.Date", "5"
};
CollectionAssert.AreEqual(expected, actual);
}
/// <summary>
/// Gets all the fields for a specific activity
/// </summary>
/// <param name="activity">The activity that the fields will be retrieved from</param>
/// <returns>Returns all the fields in a list of strings</returns>
public List <string> GetActivityFields(object activity)
{
List <string> results = new List <string>();
Dev2FindMissingStrategyFactory stratFac = new Dev2FindMissingStrategyFactory();
DsfForEachActivity forEachActivity = activity as DsfForEachActivity;
if (forEachActivity != null)
{
IFindMissingStrategy strategy;
enFindMissingType findMissingType;
var boolAct = forEachActivity.DataFunc.Handler as DsfNativeActivity <bool>;
if (boolAct == null)
{
DsfNativeActivity <string> stringAct = forEachActivity.DataFunc.Handler as DsfNativeActivity <string>;
if (stringAct != null)
{
findMissingType = stringAct.GetFindMissingType();
strategy = stratFac.CreateFindMissingStrategy(findMissingType);
results.AddRange(strategy.GetActivityFields(stringAct));
}
}
else
{
findMissingType = boolAct.GetFindMissingType();
strategy = stratFac.CreateFindMissingStrategy(findMissingType);
results.AddRange(strategy.GetActivityFields(boolAct));
}
}
IEnumerable <PropertyInfo> properties = StringAttributeRefectionUtils.ExtractAdornedProperties <FindMissingAttribute>(activity);
foreach (PropertyInfo propertyInfo in properties)
{
object property = propertyInfo.GetValue(activity, null);
if (property != null)
{
results.Add(property.ToString());
}
}
return(results);
}
public void GetActivityFieldsOffDsfForEachActivityWithADsfMultiAssignActivityInsideItExpectedAllFindMissingFieldsToBeReturned()
{
DsfMultiAssignActivity multiAssignActivity = new DsfMultiAssignActivity();
multiAssignActivity.FieldsCollection = new List <ActivityDTO> {
new ActivityDTO("[[AssignRight1]]", "[[AssignLeft1]]", 1), new ActivityDTO("[[AssignRight2]]", "[[AssignLeft2]]", 2)
};
DsfForEachActivity activity = new DsfForEachActivity();
activity.ForEachElementName = "5";
activity.DataFunc.Handler = multiAssignActivity;
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.ForEach);
List <string> actual = strategy.GetActivityFields(activity);
List <string> expected = new List <string> {
"[[AssignRight1]]", "[[AssignLeft1]]", "[[AssignRight2]]", "[[AssignLeft2]]", "5"
};
CollectionAssert.AreEqual(expected, actual);
}
public void SequenceActivityFindMissingStrategy_GetActivityFields_WithAssignAndDataMerge_ReturnsAllVariables()
{
//------------Setup for test--------------------------
var multiAssignActivity = new DsfMultiAssignActivity {
FieldsCollection = new List <ActivityDTO> {
new ActivityDTO("[[AssignRight1]]", "[[AssignLeft1]]", 1), new ActivityDTO("[[AssignRight2]]", "[[AssignLeft2]]", 2)
}
};
var dataMergeActivity = new DsfDataMergeActivity {
Result = "[[Result]]"
};
dataMergeActivity.MergeCollection.Add(new DataMergeDTO("[[rec().a]]", "Index", "6", 1, "[[b]]", "Left"));
var dsfActivity = new DsfActivity {
InputMapping = @"<Inputs><Input Name=""reg"" Source=""NUD2347"" DefaultValue=""NUD2347""><Validator Type=""Required"" /></Input><Input Name=""asdfsad"" Source=""registration223"" DefaultValue=""w3rt24324""><Validator Type=""Required"" /></Input><Input Name=""number"" Source=""[[number]]"" /></Inputs>", OutputMapping = @"<Outputs><Output Name=""vehicleVin"" MapsTo=""VIN"" Value="""" /><Output Name=""vehicleColor"" MapsTo=""VehicleColor"" Value="""" /><Output Name=""speed"" MapsTo=""speed"" Value="""" Recordset=""Fines"" /><Output Name=""date"" MapsTo=""date"" Value=""Fines.Date"" Recordset=""Fines"" /><Output Name=""location"" MapsTo=""location"" Value="""" Recordset=""Fines"" /></Outputs>"
};
var forEachActivity = new DsfForEachActivity {
ForEachElementName = "5", DataFunc = { Handler = dsfActivity }
};
var activity = new DsfSequenceActivity();
activity.Activities.Add(multiAssignActivity);
activity.Activities.Add(dataMergeActivity);
activity.Activities.Add(forEachActivity);
var fac = new Dev2FindMissingStrategyFactory();
var strategy = fac.CreateFindMissingStrategy(enFindMissingType.Sequence);
//------------Execute Test---------------------------
var actual = strategy.GetActivityFields(activity);
//------------Assert Results-------------------------
var expected = new List <string> {
"[[AssignRight1]]", "[[AssignLeft1]]", "[[AssignRight2]]", "[[AssignLeft2]]", "[[b]]", "[[rec().a]]", "6", "[[Result]]", "NUD2347", "registration223", "[[number]]", "Fines.Date", "5"
};
CollectionAssert.AreEqual(expected, actual);
}
public void DsfForEachActivity_Execute_ServiceTestExecution_WithNoUniqueId()
{
var uniqueId = Guid.NewGuid();
var env = new ExecutionEnvironment();
var data = new Mock <IDSFDataObject>();
data.Setup(o => o.Environment).Returns(() => env);
data.Setup(o => o.IsServiceTestExecution).Returns(() => true);
var serviceTestMock = new Mock <IServiceTestModelTO>();
var step = new ServiceTestStepTO();
var step_child = new ServiceTestStepTO {
UniqueId = uniqueId
};
step.Children = new ObservableCollection <IServiceTestStep>()
{
step_child
};
var testSteps = new List <IServiceTestStep>
{
step
};
serviceTestMock.Setup(o => o.TestSteps).Returns(() => testSteps);
var serviceTest = serviceTestMock.Object;
data.Setup(o => o.ServiceTest).Returns(() => serviceTest);
var ob = new DsfForEachActivity
{
UniqueID = uniqueId.ToString()
};
ob.Execute(data.Object, 0);
Assert.AreEqual("Passed", step_child.Result.Message);
Assert.AreEqual(RunResult.TestPassed, step_child.Result.RunTestResult);
}
public void SequenceActivityFindMissingStrategy_GetActivityFields_WithAssignAndDataMerge_ReturnsAllVariables()
{
//------------Setup for test--------------------------
DsfMultiAssignActivity multiAssignActivity = new DsfMultiAssignActivity { FieldsCollection = new List<ActivityDTO> { new ActivityDTO("[[AssignRight1]]", "[[AssignLeft1]]", 1), new ActivityDTO("[[AssignRight2]]", "[[AssignLeft2]]", 2) } };
DsfDataMergeActivity dataMergeActivity = new DsfDataMergeActivity { Result = "[[Result]]" };
dataMergeActivity.MergeCollection.Add(new DataMergeDTO("[[rec().a]]", "Index", "6", 1, "[[b]]", "Left"));
DsfActivity dsfActivity = new DsfActivity { InputMapping = @"<Inputs><Input Name=""reg"" Source=""NUD2347"" DefaultValue=""NUD2347""><Validator Type=""Required"" /></Input><Input Name=""asdfsad"" Source=""registration223"" DefaultValue=""w3rt24324""><Validator Type=""Required"" /></Input><Input Name=""number"" Source=""[[number]]"" /></Inputs>", OutputMapping = @"<Outputs><Output Name=""vehicleVin"" MapsTo=""VIN"" Value="""" /><Output Name=""vehicleColor"" MapsTo=""VehicleColor"" Value="""" /><Output Name=""speed"" MapsTo=""speed"" Value="""" Recordset=""Fines"" /><Output Name=""date"" MapsTo=""date"" Value=""Fines.Date"" Recordset=""Fines"" /><Output Name=""location"" MapsTo=""location"" Value="""" Recordset=""Fines"" /></Outputs>" };
DsfForEachActivity forEachActivity = new DsfForEachActivity { ForEachElementName = "5", DataFunc = { Handler = dsfActivity } };
DsfSequenceActivity activity = new DsfSequenceActivity();
activity.Activities.Add(multiAssignActivity);
activity.Activities.Add(dataMergeActivity);
activity.Activities.Add(forEachActivity);
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.Sequence);
//------------Execute Test---------------------------
List<string> actual = strategy.GetActivityFields(activity);
//------------Assert Results-------------------------
List<string> expected = new List<string> { "[[AssignRight1]]", "[[AssignLeft1]]", "[[AssignRight2]]", "[[AssignLeft2]]", "[[b]]", "[[rec().a]]", "6", "[[Result]]", "NUD2347", "registration223", "[[number]]", "Fines.Date", "5" };
CollectionAssert.AreEqual(expected, actual);
}
public void GetActivityFieldsOffDsfForEachActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfForEachActivity activity = new DsfForEachActivity();
activity.ForEachElementName = "[[ForEachElementName]]";
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
List<string> actual = strategy.GetActivityFields(activity);
List<string> expected = new List<string> { "[[ForEachElementName]]" };
CollectionAssert.AreEqual(expected, actual);
}
public void DsfForEachActivity_GetState_ForEachElementName_ReturnsStateVariable()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var dsfForEachActivity = new DsfForEachActivity
{
ForEachType = enForEachType.InRecordset,
From = "",
To = "",
CsvIndexes = "",
NumOfExections = "",
Recordset = "[[Recordset]]",
ForEachElementName = "AA"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(dsfForEachActivity);
//---------------Execute Test ----------------------
//------------Execute Test---------------------------
var stateItems = dsfForEachActivity.GetState();
//------------Assert Results-------------------------
Assert.AreEqual(7, stateItems.Count());
var expectedResults = new[]
{ new StateVariable
{
Name = "ForEachElementName",
Type = StateVariable.StateType.Input,
Value = "AA"
},
new StateVariable
{
Name = "ForEachType",
Type = StateVariable.StateType.Input,
Value = "InRecordset"
},
new StateVariable
{
Name = "From",
Type = StateVariable.StateType.Input,
Value = ""
},
new StateVariable
{
Name = "To",
Type = StateVariable.StateType.Input,
Value = ""
},
new StateVariable
{
Name = "CsvIndexes",
Type = StateVariable.StateType.Input,
Value = ""
},
new StateVariable
{
Name = "NumOfExections",
Type = StateVariable.StateType.Input,
Value = ""
},
new StateVariable
{
Name = "Recordset",
Type = StateVariable.StateType.Input,
Value = "[[Recordset]]"
} };
var iter = dsfForEachActivity.GetState().Select(
(item, index) => new
{
value = item,
expectValue = expectedResults[index]
}
);
//------------Assert Results-------------------------
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);
}
}
protected override void BuildDataList()
{
scenarioContext.TryGetValue("variableList", out List <Tuple <string, string> > variableList);
if (variableList == null)
{
variableList = new List <Tuple <string, string> >();
scenarioContext.Add("variableList", variableList);
}
variableList.Add(new Tuple <string, string>(ResultRecordsetVariable, ""));
if (scenarioContext.TryGetValue("outMapTo", out string outMapTo))
{
variableList.Add(new Tuple <string, string>(outMapTo, ""));
}
BuildShapeAndTestData();
var activityType = scenarioContext.Get <string>("activityType");
dynamic activity;
if (activityType.Equals("Tool"))
{
activity = new DsfRandomActivity
{
Result = ResultRecordsetVariable,
RandomType = enRandomType.Numbers,
From = "0",
To = "100"
};
}
else
{
activity = new DsfActivity
{
InputMapping = BuildInputMappings(),
OutputMapping = BuildOutputMappings(),
ServiceName = "SpecflowForeachActivityTest"
};
}
var activityFunction = new ActivityFunc <string, bool> {
Handler = activity
};
var foreachType = scenarioContext.Get <enForEachType>("foreachType");
if (!scenarioContext.TryGetValue("recordset", out string recordSet))
{
recordSet = string.Empty;
}
if (!scenarioContext.TryGetValue("from", out string from))
{
from = string.Empty;
}
if (!scenarioContext.TryGetValue("to", out string to))
{
to = string.Empty;
}
if (!scenarioContext.TryGetValue("numberAs", out string numberAs))
{
numberAs = string.Empty;
}
var dsfForEach = new DsfForEachActivity
{
ForEachType = foreachType,
Recordset = recordSet,
From = from,
To = to,
CsvIndexes = numberAs,
NumOfExections = numberAs,
DataFunc = activityFunction
};
TestStartNode = new FlowStep
{
Action = dsfForEach
};
scenarioContext.Add("activity", dsfForEach);
}
public void AddActivityToActivityList(string parentName, string activityName, Activity activity)
{
if (!_scenarioContext.TryGetValue("activityList", out Dictionary <string, Activity> activityList))
{
activityList = new Dictionary <string, Activity>();
_scenarioContext.Add("activityList", activityList);
}
if (activityList.TryGetValue(parentName, out Activity parentActivity))
{
if (parentActivity is DsfSequenceActivity)
{
var seq = parentActivity as DsfSequenceActivity;
seq.Activities.Add(activity);
}
else if (parentActivity is DsfForEachActivity)
{
var forEachActivity = parentActivity as DsfForEachActivity;
var activityFunc = new ActivityFunc <string, bool> {
Handler = activity
};
forEachActivity.DataFunc = activityFunc;
}
}
else
{
var findAllForEach = activityList.FirstOrDefault(pair =>
{
var forEachActivity = pair.Value as DsfForEachActivity;
if (forEachActivity == null)
{
return(false);
}
return(forEachActivity.DataFunc.Handler != null && forEachActivity.DataFunc != null && forEachActivity.DataFunc.Handler as DsfForEachActivity != null);
});
if (findAllForEach.Value is DsfForEachActivity forEachParentActivity)
{
var activityFunc = new ActivityFunc <string, bool> {
Handler = activity
};
DsfForEachActivity foundCorrectParentForEach = null;
while (forEachParentActivity != null)
{
if (forEachParentActivity.DataFunc?.Handler != null && forEachParentActivity.DataFunc.Handler.DisplayName == parentName)
{
foundCorrectParentForEach = forEachParentActivity.DataFunc.Handler as DsfForEachActivity;
break;
}
if (forEachParentActivity.DataFunc != null)
{
forEachParentActivity = forEachParentActivity.DataFunc.Handler as DsfForEachActivity;
}
else
{
forEachParentActivity = null;
}
}
if (foundCorrectParentForEach != null)
{
foundCorrectParentForEach.DataFunc = activityFunc;
}
}
else
{
activityList.Add(activityName, activity);
}
}
}
// 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);
}
private DsfForEachActivity SetupArguments(string currentDl, string testData, enForEachType type, bool isInputMapping = false, string inputMapping = null, string from = null, string to = null, string csvIndexes = null, string numberExecutions = null)
{
var activityFunction = new ActivityFunc<string, bool>();
DsfActivity activity = inputMapping != null ? CreateWorkflow(inputMapping, isInputMapping) : CreateWorkflow();
activityFunction.Handler = activity;
var id = Guid.NewGuid().ToString();
DsfForEachActivity dsfForEachActivity = new DsfForEachActivity
{
DataFunc = activityFunction, ForEachType = type, NumOfExections = numberExecutions, From = @from, To = to, CsvIndexes = csvIndexes, UniqueID = id
};
TestStartNode = new FlowStep
{
Action = dsfForEachActivity
};
CurrentDl = testData;
TestData = currentDl;
return dsfForEachActivity;
}
public void GivenIHaveAForEachAsExecutions(string activityName, string forEachType, string numberOfExecutions)
{
DsfForEachActivity forEachActivity = new DsfForEachActivity { DisplayName = activityName };
enForEachType typeOfForEach;
Enum.TryParse(forEachType, out typeOfForEach);
forEachActivity.ForEachType = typeOfForEach;
forEachActivity.NumOfExections = numberOfExecutions;
ScenarioContext.Current.Add(activityName, forEachActivity);
}
