public void SequenceDesignerViewModel_ActivityNames_When4_HasAllNames()
{
//------------Setup for test--------------------------
var dsfSequenceActivity = new DsfSequenceActivity();
var dsfMultiAssignActivity = new DsfMultiAssignActivity();
dsfSequenceActivity.Activities.Add(dsfMultiAssignActivity);
var dsfFindRecordsMultipleCriteriaActivity = new DsfFindRecordsMultipleCriteriaActivity();
dsfSequenceActivity.Activities.Add(dsfFindRecordsMultipleCriteriaActivity);
var dsfGatherSystemInformationActivity = new DsfGatherSystemInformationActivity();
dsfSequenceActivity.Activities.Add(dsfGatherSystemInformationActivity);
var dsfBaseConvertActivity = new DsfBaseConvertActivity();
dsfSequenceActivity.Activities.Add(dsfBaseConvertActivity);
var sequenceDesignerViewModel = new SequenceDesignerViewModel(CreateModelItem(dsfSequenceActivity));
//------------Execute Test---------------------------
var activityNames = sequenceDesignerViewModel.ActivityNames;
//------------Assert Results-------------------------
Assert.AreEqual(4, activityNames.Count);
Assert.AreEqual(dsfMultiAssignActivity.DisplayName, activityNames[0]);
Assert.AreEqual(dsfFindRecordsMultipleCriteriaActivity.DisplayName, activityNames[1]);
Assert.AreEqual(dsfGatherSystemInformationActivity.DisplayName, activityNames[2]);
Assert.AreEqual(dsfBaseConvertActivity.DisplayName, activityNames[3]);
}
public void Equals_Given_Different_ResultsCollection_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var resultsColl = new List <FindRecordsTO>
{
new FindRecordsTO
{
SearchType = "SOMETHING"
}
};
var resultsColl2 = new List <FindRecordsTO>
{
new FindRecordsTO
{
SearchType = "NONE"
}
};
var activity1 = new DsfFindRecordsMultipleCriteriaActivity()
{
UniqueID = uniqueId, ResultsCollection = resultsColl
};
var activity = new DsfFindRecordsMultipleCriteriaActivity()
{
UniqueID = uniqueId, ResultsCollection = resultsColl2
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity1);
//---------------Execute Test ----------------------
var @equals = activity1.Equals(activity);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
protected override void BuildDataList()
{
List <Tuple <string, string> > variableList;
scenarioContext.TryGetValue("variableList", out variableList);
if (variableList == null)
{
variableList = new List <Tuple <string, string> >();
scenarioContext.Add("variableList", variableList);
}
variableList.Add(new Tuple <string, string>(ResultVariable, ""));
BuildShapeAndTestData();
string fieldsToSearch;
scenarioContext.TryGetValue("fieldsToSearch", out fieldsToSearch);
List <FindRecordsTO> searchList;
scenarioContext.TryGetValue("searchList", out searchList);
bool requireAllTrue;
scenarioContext.TryGetValue("requireAllTrue", out requireAllTrue);
bool requireAllFieldsToMatch;
scenarioContext.TryGetValue("requireAllFieldsToMatch", out requireAllFieldsToMatch);
var findRecordsMultipleIndex = new DsfFindRecordsMultipleCriteriaActivity
{
FieldsToSearch = fieldsToSearch,
ResultsCollection = searchList,
RequireAllTrue = requireAllTrue,
RequireAllFieldsToMatch = requireAllFieldsToMatch,
Result = ResultVariable
};
string updatedResultField;
if (scenarioContext.TryGetValue("specifiedResult", out updatedResultField))
{
if (!string.IsNullOrEmpty(updatedResultField))
{
findRecordsMultipleIndex.Result = updatedResultField;
}
}
TestStartNode = new FlowStep
{
Action = findRecordsMultipleIndex
};
scenarioContext.Add("activity", findRecordsMultipleIndex);
}
public void DsfFindRecordsMultipleCriteriaActivity_UpdateForEachOutputs_NullUpdates_DoesNothing()
{
//------------Setup for test--------------------------
var act = new DsfFindRecordsMultipleCriteriaActivity
{
FieldsToSearch = "[[Customers(*).DOB]]",
ResultsCollection = new List <FindRecordsTO> {
new FindRecordsTO("/", "Contains", 1)
},
Result = "[[res]]"
};
//------------Execute Test---------------------------
act.UpdateForEachOutputs(null);
//------------Assert Results-------------------------
Assert.AreEqual("[[res]]", act.Result);
}
public void DDsfFindRecordsMultipleCriteriaActivity_UpdateForEachOutputs_MoreThan1Updates_DoesNothing()
{
//------------Setup for test--------------------------
var act = new DsfFindRecordsMultipleCriteriaActivity
{
FieldsToSearch = "[[Customers(*).DOB]]",
ResultsCollection = new List<FindRecordsTO> { new FindRecordsTO("/", "Contains", 1) },
Result = "[[res]]"
};
var tuple1 = new Tuple<string, string>("Test", "Test");
var tuple2 = new Tuple<string, string>("Test2", "Test2");
//------------Execute Test---------------------------
act.UpdateForEachOutputs(new List<Tuple<string, string>> { tuple1, tuple2 });
//------------Assert Results-------------------------
Assert.AreEqual("[[res]]", act.Result);
}
public void SequenceDesignerViewModel_SetSmallViewItem_WhenValidModelItem_ActivityAdded()
{
//------------Setup for test--------------------------
var dsfSequenceActivity = new DsfSequenceActivity();
var dsfMultiAssignActivity = new DsfMultiAssignActivity();
dsfSequenceActivity.Activities.Add(dsfMultiAssignActivity);
var dsfFindRecordsMultipleCriteriaActivity = new DsfFindRecordsMultipleCriteriaActivity();
dsfSequenceActivity.Activities.Add(dsfFindRecordsMultipleCriteriaActivity);
var sequenceDesignerViewModel = new SequenceDesignerViewModel(CreateModelItem(dsfSequenceActivity));
ModelItem modelItem = ModelItemUtils.CreateModelItem(new DsfGatherSystemInformationActivity());
//------------Execute Test---------------------------
sequenceDesignerViewModel.SmallViewItem = modelItem;
//------------Assert Results-------------------------
Assert.AreEqual(3, dsfSequenceActivity.Activities.Count);
}
public void SequenceDesignerViewModel_SetSmallViewItem_WhenModelItemDsfDbServiceActivity_ActivityNotAdded()
{
//------------Setup for test--------------------------
var dsfSequenceActivity = new DsfSequenceActivity();
var dsfMultiAssignActivity = new DsfMultiAssignActivity();
dsfSequenceActivity.Activities.Add(dsfMultiAssignActivity);
var dsfFindRecordsMultipleCriteriaActivity = new DsfFindRecordsMultipleCriteriaActivity();
dsfSequenceActivity.Activities.Add(dsfFindRecordsMultipleCriteriaActivity);
var sequenceDesignerViewModel = new SequenceDesignerViewModel(CreateModelItem(dsfSequenceActivity));
ModelItem modelItem = ModelItemUtils.CreateModelItem(new DsfDatabaseActivity());
//------------Execute Test---------------------------
sequenceDesignerViewModel.SmallViewItem = modelItem;
//------------Assert Results-------------------------
Assert.AreEqual(2, dsfSequenceActivity.Activities.Count);
}
public void DsfFindRecordsMultipleCriteriaActivity_GetForEachInputs_WhenHasExpression_ReturnsInputList()
{
//------------Setup for test--------------------------
var act = new DsfFindRecordsMultipleCriteriaActivity
{
FieldsToSearch = "[[Customers(*).DOB]]",
ResultsCollection = new List<FindRecordsTO> { new FindRecordsTO("/", "Contains", 1) },
Result = "[[res]]"
};
//------------Execute Test---------------------------
var dsfForEachItems = act.GetForEachInputs();
//------------Assert Results-------------------------
Assert.AreEqual(2, dsfForEachItems.Count);
Assert.AreEqual("[[Customers(*).DOB]]", dsfForEachItems[0].Name);
Assert.AreEqual("[[Customers(*).DOB]]", dsfForEachItems[0].Value);
Assert.AreEqual("/", dsfForEachItems[1].Name);
Assert.AreEqual("/", dsfForEachItems[1].Value);
}
public void DsfFindRecordsMultipleCriteriaActivity_GetOutputs_Called_ShouldReturnListWithResultValueInIt()
{
//------------Setup for test--------------------------
var act = new DsfFindRecordsMultipleCriteriaActivity
{
FieldsToSearch = "[[Recset().Field1]],[[Recset().Field2]],[[Recset().Field3]]",
ResultsCollection = new List <FindRecordsTO> {
new FindRecordsTO("jimmy", ">", 1)
},
StartIndex = "",
Result = "[[Result().res]]"
};
//------------Execute Test---------------------------
var outputs = act.GetOutputs();
//------------Assert Results-------------------------
Assert.AreEqual(1, outputs.Count);
Assert.AreEqual("[[Result().res]]", outputs[0]);
}
public void GivenItContainsFindRecordIndexSearchAndResultAs(string parentName, string activityName, string recsetToSearch, string resultVariable, Table table)
{
var result = resultVariable;
var recset = recsetToSearch;
_commonSteps.AddVariableToVariableList(result);
var activity = new DsfFindRecordsMultipleCriteriaActivity {
RequireAllFieldsToMatch = false, RequireAllTrue = false, Result = result, FieldsToSearch = recset, DisplayName = activityName
};
foreach (var tableRow in table.Rows)
{
var matchType = tableRow["Match Type"];
var matchValue = tableRow["Match"];
activity.ResultsCollection.Add(new FindRecordsTO(matchValue, matchType, 1, true));
}
_commonSteps.AddActivityToActivityList(parentName, activityName, activity);
}
public void DsfFindRecordsMultipleCriteriaActivity_GetForEachOutputs_WhenHasResult_ReturnsInputList()
{
//------------Setup for test--------------------------
var act = new DsfFindRecordsMultipleCriteriaActivity
{
FieldsToSearch = "[[Customers(*).DOB]]",
ResultsCollection = new List <FindRecordsTO> {
new FindRecordsTO("/", "Contains", 1)
},
Result = "[[res]]"
};
//------------Execute Test---------------------------
var dsfForEachItems = act.GetForEachOutputs();
//------------Assert Results-------------------------
Assert.AreEqual(1, dsfForEachItems.Count);
Assert.AreEqual("[[res]]", dsfForEachItems[0].Name);
Assert.AreEqual("[[res]]", dsfForEachItems[0].Value);
}
public void Equals_Given_EmptyActivityTools_AreEqual()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var activity = new DsfFindRecordsMultipleCriteriaActivity()
{
UniqueID = uniqueId
};
var activity1 = new DsfFindRecordsMultipleCriteriaActivity()
{
UniqueID = uniqueId
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity);
//---------------Execute Test ----------------------
var @equals = activity.Equals(activity1);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}
public void Equals_Given_Same_FieldsToSearch_IsEqual()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var activity1 = new DsfFindRecordsMultipleCriteriaActivity()
{
UniqueID = uniqueId, FieldsToSearch = "a"
};
var activity = new DsfFindRecordsMultipleCriteriaActivity()
{
UniqueID = uniqueId, FieldsToSearch = "a"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity1);
//---------------Execute Test ----------------------
var @equals = activity1.Equals(activity);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}
public void DsfFindRecordsMultipleCriteriaActivity_UpdateForEachOutputs_1Updates_UpdateResult()
{
//------------Setup for test--------------------------
var act = new DsfFindRecordsMultipleCriteriaActivity
{
FieldsToSearch = "[[Customers(*).DOB]]",
ResultsCollection = new List <FindRecordsTO> {
new FindRecordsTO("/", "Contains", 1)
},
Result = "[[res]]"
};
var tuple1 = new Tuple <string, string>("[[res]]", "Test");
//------------Execute Test---------------------------
act.UpdateForEachOutputs(new List <Tuple <string, string> > {
tuple1
});
//------------Assert Results-------------------------
Assert.AreEqual("Test", act.Result);
}
public void Equals_Given_DisplayName_Different_DisplayName_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var activity1 = new DsfFindRecordsMultipleCriteriaActivity()
{
UniqueID = uniqueId, DisplayName = "A"
};
var activity = new DsfFindRecordsMultipleCriteriaActivity()
{
UniqueID = uniqueId, DisplayName = "ass"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity1);
//---------------Execute Test ----------------------
var @equals = activity1.Equals(activity);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
public void Equals_Given_Different_RequireAllFieldsToMatch_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var activity1 = new DsfFindRecordsMultipleCriteriaActivity()
{
UniqueID = uniqueId, RequireAllFieldsToMatch = false
};
var activity = new DsfFindRecordsMultipleCriteriaActivity()
{
UniqueID = uniqueId, RequireAllFieldsToMatch = true
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity1);
//---------------Execute Test ----------------------
var @equals = activity1.Equals(activity);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
public void SequenceDesignerViewModel_DoDrop_WhenNoFormats_ActivityNotAdded()
{
//------------Setup for test--------------------------
var dsfSequenceActivity = new DsfSequenceActivity();
var dsfMultiAssignActivity = new DsfMultiAssignActivity();
dsfSequenceActivity.Activities.Add(dsfMultiAssignActivity);
var dsfFindRecordsMultipleCriteriaActivity = new DsfFindRecordsMultipleCriteriaActivity();
dsfSequenceActivity.Activities.Add(dsfFindRecordsMultipleCriteriaActivity);
var sequenceDesignerViewModel = new SequenceDesignerViewModel(CreateModelItem(dsfSequenceActivity));
var dataObjectMock = new Mock <IDataObject>();
dataObjectMock.Setup(o => o.GetFormats()).Returns(new string[] { });
//------------Execute Test---------------------------
bool doDrop = sequenceDesignerViewModel.DoDrop(dataObjectMock.Object);
//------------Assert Results-------------------------
Assert.IsFalse(doDrop);
Assert.AreEqual(2, dsfSequenceActivity.Activities.Count);
}
public void GetActivityFieldsOf_DsfFindRecordsMultipleCriteriaActivity_ExpectedAllFindMissingFieldsToBeReturned()
{
var act = new DsfFindRecordsMultipleCriteriaActivity
{
ResultsCollection = new List <FindRecordsTO>
{
new FindRecordsTO("criteria1", "any", 1),
new FindRecordsTO("criteria2", "any", 2)
},
OnErrorVariable = "[[onErr]]",
FieldsToSearch = "field1",
Result = "[[result]]"
};
var fac = new Dev2FindMissingStrategyFactory();
var strategy = fac.CreateFindMissingStrategy(enFindMissingType.MixedActivity);
var actual = strategy.GetActivityFields(act);
var expected = new List <string> {
"", "", "criteria1", "", "", "criteria2", "field1", "[[result]]", "[[onErr]]"
};
CollectionAssert.AreEqual(expected, actual);
}
public void SequenceDesignerViewModel_DoDrop_WhenFormatDoesNotContainModelItemFormat_ActivityNotAdded()
{
//------------Setup for test--------------------------
var dsfSequenceActivity = new DsfSequenceActivity();
var dsfMultiAssignActivity = new DsfMultiAssignActivity();
dsfSequenceActivity.Activities.Add(dsfMultiAssignActivity);
var dsfFindRecordsMultipleCriteriaActivity = new DsfFindRecordsMultipleCriteriaActivity();
dsfSequenceActivity.Activities.Add(dsfFindRecordsMultipleCriteriaActivity);
var sequenceDesignerViewModel = new SequenceDesignerViewModel(CreateModelItem(dsfSequenceActivity));
var dataObjectMock = new Mock <IDataObject>();
dataObjectMock.Setup(o => o.GetFormats()).Returns(new[] { "Something Else" });
dataObjectMock.Setup(o => o.GetData("Something Else")).Returns(ModelItemUtils.CreateModelItem(new DsfGatherSystemInformationActivity()));
//------------Execute Test---------------------------
bool doDrop = sequenceDesignerViewModel.DoDrop(dataObjectMock.Object);
//------------Assert Results-------------------------
Assert.IsFalse(doDrop);
Assert.AreEqual(2, dsfSequenceActivity.Activities.Count);
}
protected override void BuildDataList()
{
List<Tuple<string, string>> variableList;
ScenarioContext.Current.TryGetValue("variableList", out variableList);
if(variableList == null)
{
variableList = new List<Tuple<string, string>>();
ScenarioContext.Current.Add("variableList", variableList);
}
variableList.Add(new Tuple<string, string>(ResultVariable, ""));
BuildShapeAndTestData();
string fieldsToSearch;
ScenarioContext.Current.TryGetValue("fieldsToSearch", out fieldsToSearch);
List<FindRecordsTO> searchList;
ScenarioContext.Current.TryGetValue("searchList", out searchList);
bool requireAllTrue;
ScenarioContext.Current.TryGetValue("requireAllTrue", out requireAllTrue);
bool requireAllFieldsToMatch;
ScenarioContext.Current.TryGetValue("requireAllFieldsToMatch", out requireAllFieldsToMatch);
var findRecordsMultipleIndex = new DsfFindRecordsMultipleCriteriaActivity
{
FieldsToSearch = fieldsToSearch,
ResultsCollection = searchList,
RequireAllTrue = requireAllTrue,
RequireAllFieldsToMatch = requireAllFieldsToMatch,
Result = ResultVariable
};
TestStartNode = new FlowStep
{
Action = findRecordsMultipleIndex
};
ScenarioContext.Current.Add("activity", findRecordsMultipleIndex);
}
public void DsfFindRecordsMultipleCriteriaActivity_UpdateForEachInputs_MoreThan1Updates_UpdatesMergeCollection()
{
//------------Setup for test--------------------------
var act = new DsfFindRecordsMultipleCriteriaActivity
{
FieldsToSearch = "[[Customers(*).DOB]]",
ResultsCollection = new List <FindRecordsTO> {
new FindRecordsTO("/", "Contains", 1)
},
Result = "[[res]]"
};
var tuple1 = new Tuple <string, string>("/", "Test");
var tuple2 = new Tuple <string, string>("[[Customers(*).DOB]]", "Test2");
//------------Execute Test---------------------------
act.UpdateForEachInputs(new List <Tuple <string, string> > {
tuple1, tuple2
}, null);
//------------Assert Results-------------------------
Assert.AreEqual("Test", act.ResultsCollection[0].SearchCriteria);
Assert.AreEqual("Test2", act.FieldsToSearch);
}
public void SequenceDesignerViewModel_ActivityNames_WhenMoreThan4_Has4NamesLastItemEllipsis()
{
//------------Setup for test--------------------------
var dsfSequenceActivity = new DsfSequenceActivity();
var dsfMultiAssignActivity = new DsfMultiAssignActivity();
dsfSequenceActivity.Activities.Add(dsfMultiAssignActivity);
var dsfFindRecordsMultipleCriteriaActivity = new DsfFindRecordsMultipleCriteriaActivity();
dsfSequenceActivity.Activities.Add(dsfFindRecordsMultipleCriteriaActivity);
var dsfGatherSystemInformationActivity = new DsfGatherSystemInformationActivity();
dsfSequenceActivity.Activities.Add(dsfGatherSystemInformationActivity);
var dsfBaseConvertActivity = new DsfBaseConvertActivity();
dsfSequenceActivity.Activities.Add(dsfBaseConvertActivity);
var dsfCaseConvertActivity = new DsfCaseConvertActivity();
dsfSequenceActivity.Activities.Add(dsfCaseConvertActivity);
var dsfCalculateActivity = new DsfCalculateActivity();
dsfSequenceActivity.Activities.Add(dsfCalculateActivity);
var sequenceDesignerViewModel = new SequenceDesignerViewModel(CreateModelItem(dsfSequenceActivity));
//------------Execute Test---------------------------
var activityNames = sequenceDesignerViewModel.ActivityNames;
//------------Assert Results-------------------------
Assert.AreEqual(5, activityNames.Count);
Assert.AreEqual(dsfMultiAssignActivity.DisplayName, activityNames[0]);
Assert.AreEqual(dsfFindRecordsMultipleCriteriaActivity.DisplayName, activityNames[1]);
Assert.AreEqual(dsfGatherSystemInformationActivity.DisplayName, activityNames[2]);
Assert.AreEqual(dsfBaseConvertActivity.DisplayName, activityNames[3]);
Assert.AreEqual("...", activityNames[4]);
CollectionAssert.DoesNotContain(activityNames, dsfCaseConvertActivity.DisplayName);
CollectionAssert.DoesNotContain(activityNames, dsfCalculateActivity.DisplayName);
}
public void AddResultDebugInputs_Sets_Operand_To_EmptyString()
{
//------------Setup for test-------------------------
var activity = new DsfFindRecordsMultipleCriteriaActivity();
var privateObject = new PrivateObject(activity);
IEnumerable <FindRecordsTO> resultsCollection = new List <FindRecordsTO>
{
new FindRecordsTO {
SearchCriteria = "1", IndexNumber = 1, SearchType = "="
}
};
var atomResult = CommonFunctions.WarewolfEvalResult.NewWarewolfAtomResult(DataStorage.WarewolfAtom.NewInt(1));
var environment = new Mock <IExecutionEnvironment>();
environment.Setup(executionEnvironment => executionEnvironment.Eval("1", 0, false, false)).Returns(atomResult);
var args = new object[] { resultsCollection, environment.Object, 0 };
//------------Execute Test---------------------------
privateObject.Invoke("AddResultDebugInputs", args);
//------------Assert Results-------------------------
var debugInputs = activity.GetDebugInputs(environment.Object, 0);
Assert.IsTrue(debugInputs.Single().ResultsList.All(p => p.Operator == ""));
}
public void SequenceDesignerViewModel_DoDrop_WhenModelItemsFormatHasSingleItem_ActivitiesAdded()
{
//------------Setup for test--------------------------
var dsfSequenceActivity = new DsfSequenceActivity();
var dsfMultiAssignActivity = new DsfMultiAssignActivity();
dsfSequenceActivity.Activities.Add(dsfMultiAssignActivity);
var dsfFindRecordsMultipleCriteriaActivity = new DsfFindRecordsMultipleCriteriaActivity();
dsfSequenceActivity.Activities.Add(dsfFindRecordsMultipleCriteriaActivity);
var sequenceDesignerViewModel = new SequenceDesignerViewModel(CreateModelItem(dsfSequenceActivity));
var dataObjectMock = new Mock <IDataObject>();
dataObjectMock.Setup(o => o.GetFormats()).Returns(new[] { "ModelItemsFormat" });
dataObjectMock.Setup(o => o.GetData("ModelItemsFormat")).Returns(new List <ModelItem> {
ModelItemUtils.CreateModelItem(new DsfGatherSystemInformationActivity())
});
//------------Execute Test---------------------------
bool doDrop = sequenceDesignerViewModel.DoDrop(dataObjectMock.Object);
//------------Assert Results-------------------------
Assert.IsTrue(doDrop);
Assert.AreEqual(3, dsfSequenceActivity.Activities.Count);
}
public void DsfFindRecordsMultipleCriteriaActivity_UpdateForEachOutputs_NullUpdates_DoesNothing()
{
//------------Setup for test--------------------------
var act = new DsfFindRecordsMultipleCriteriaActivity
{
FieldsToSearch = "[[Customers(*).DOB]]",
ResultsCollection = new List<FindRecordsTO> { new FindRecordsTO("/", "Contains", 1) },
Result = "[[res]]"
};
//------------Execute Test---------------------------
act.UpdateForEachOutputs(null);
//------------Assert Results-------------------------
Assert.AreEqual("[[res]]", act.Result);
}
public void GivenItContainsFindRecordIndexSearchAndResultAs(string parentName, string activityName, string recsetToSearch, string resultVariable, Table table)
{
var result = resultVariable;
var recset = recsetToSearch;
CommonSteps.AddVariableToVariableList(result);
DsfFindRecordsMultipleCriteriaActivity activity = new DsfFindRecordsMultipleCriteriaActivity { RequireAllFieldsToMatch = false, RequireAllTrue = false, Result = result, FieldsToSearch = recset, DisplayName = activityName };
foreach(var tableRow in table.Rows)
{
var matchType = tableRow["Match Type"];
var matchValue = tableRow["Match"];
activity.ResultsCollection.Add(new FindRecordsTO(matchValue, matchType, 1, true));
}
CommonSteps.AddActivityToActivityList(parentName, activityName, activity);
}
public void DsfFindRecordsMultipleCriteriaActivity_GetState_ReturnsStateVariable()
{
var resultsCol = new List <FindRecordsTO>
{
new FindRecordsTO
{
SearchType = "SOMETHING"
}
,
new FindRecordsTO
{
SearchType = "NONE"
}
};
var act = new DsfFindRecordsMultipleCriteriaActivity()
{
ResultsCollection = resultsCol, FieldsToSearch = "[[rec().a]]", RequireAllTrue = true, RequireAllFieldsToMatch = false, Result = "[[match]]"
};
//------------Execute Test---------------------------
var stateItems = act.GetState();
Assert.AreEqual(5, stateItems.Count());
var expectedResults = new[]
{
new StateVariable
{
Name = "ResultsCollection",
Type = StateVariable.StateType.Input,
Value = ActivityHelper.GetSerializedStateValueFromCollection(resultsCol)
},
new StateVariable
{
Name = "FieldsToSearch",
Type = StateVariable.StateType.Input,
Value = "[[rec().a]]"
},
new StateVariable
{
Name = "RequireAllTrue",
Type = StateVariable.StateType.Input,
Value = "True"
},
new StateVariable
{
Name = "RequireAllFieldsToMatch",
Type = StateVariable.StateType.Input,
Value = "False"
},
new StateVariable
{
Name = "Result",
Type = StateVariable.StateType.Output,
Value = "[[match]]"
}
};
var iter = act.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);
}
}
public void SequenceDesignerViewModel_ActivityNames_When4_HasAllNames()
{
//------------Setup for test--------------------------
var dsfSequenceActivity = new DsfSequenceActivity();
var dsfMultiAssignActivity = new DsfMultiAssignActivity();
dsfSequenceActivity.Activities.Add(dsfMultiAssignActivity);
var dsfFindRecordsMultipleCriteriaActivity = new DsfFindRecordsMultipleCriteriaActivity();
dsfSequenceActivity.Activities.Add(dsfFindRecordsMultipleCriteriaActivity);
var dsfGatherSystemInformationActivity = new DsfGatherSystemInformationActivity();
dsfSequenceActivity.Activities.Add(dsfGatherSystemInformationActivity);
var dsfBaseConvertActivity = new DsfBaseConvertActivity();
dsfSequenceActivity.Activities.Add(dsfBaseConvertActivity);
var sequenceDesignerViewModel = new SequenceDesignerViewModel(CreateModelItem(dsfSequenceActivity));
//------------Execute Test---------------------------
var activityNames = sequenceDesignerViewModel.ActivityNames;
//------------Assert Results-------------------------
Assert.AreEqual(4, activityNames.Count);
Assert.AreEqual(dsfMultiAssignActivity.DisplayName, activityNames[0]);
Assert.AreEqual(dsfFindRecordsMultipleCriteriaActivity.DisplayName, activityNames[1]);
Assert.AreEqual(dsfGatherSystemInformationActivity.DisplayName, activityNames[2]);
Assert.AreEqual(dsfBaseConvertActivity.DisplayName, activityNames[3]);
}
public void SequenceDesignerViewModel_ActivityNames_WhenMoreThan4_Has4NamesLastItemEllipsis()
{
//------------Setup for test--------------------------
var dsfSequenceActivity = new DsfSequenceActivity();
var dsfMultiAssignActivity = new DsfMultiAssignActivity();
dsfSequenceActivity.Activities.Add(dsfMultiAssignActivity);
var dsfFindRecordsMultipleCriteriaActivity = new DsfFindRecordsMultipleCriteriaActivity();
dsfSequenceActivity.Activities.Add(dsfFindRecordsMultipleCriteriaActivity);
var dsfGatherSystemInformationActivity = new DsfGatherSystemInformationActivity();
dsfSequenceActivity.Activities.Add(dsfGatherSystemInformationActivity);
var dsfBaseConvertActivity = new DsfBaseConvertActivity();
dsfSequenceActivity.Activities.Add(dsfBaseConvertActivity);
var dsfCaseConvertActivity = new DsfCaseConvertActivity();
dsfSequenceActivity.Activities.Add(dsfCaseConvertActivity);
var dsfCalculateActivity = new DsfCalculateActivity();
dsfSequenceActivity.Activities.Add(dsfCalculateActivity);
var sequenceDesignerViewModel = new SequenceDesignerViewModel(CreateModelItem(dsfSequenceActivity));
//------------Execute Test---------------------------
var activityNames = sequenceDesignerViewModel.ActivityNames;
//------------Assert Results-------------------------
Assert.AreEqual(5, activityNames.Count);
Assert.AreEqual(dsfMultiAssignActivity.DisplayName, activityNames[0]);
Assert.AreEqual(dsfFindRecordsMultipleCriteriaActivity.DisplayName, activityNames[1]);
Assert.AreEqual(dsfGatherSystemInformationActivity.DisplayName, activityNames[2]);
Assert.AreEqual(dsfBaseConvertActivity.DisplayName, activityNames[3]);
Assert.AreEqual("...", activityNames[4]);
CollectionAssert.DoesNotContain(activityNames, dsfCaseConvertActivity.DisplayName);
CollectionAssert.DoesNotContain(activityNames, dsfCalculateActivity.DisplayName);
}
public void SequenceDesignerViewModel_SetSmallViewItem_WhenValidModelItem_ActivityAdded()
{
//------------Setup for test--------------------------
var dsfSequenceActivity = new DsfSequenceActivity();
var dsfMultiAssignActivity = new DsfMultiAssignActivity();
dsfSequenceActivity.Activities.Add(dsfMultiAssignActivity);
var dsfFindRecordsMultipleCriteriaActivity = new DsfFindRecordsMultipleCriteriaActivity();
dsfSequenceActivity.Activities.Add(dsfFindRecordsMultipleCriteriaActivity);
var sequenceDesignerViewModel = new SequenceDesignerViewModel(CreateModelItem(dsfSequenceActivity));
ModelItem modelItem = ModelItemUtils.CreateModelItem(new DsfGatherSystemInformationActivity());
//------------Execute Test---------------------------
sequenceDesignerViewModel.SmallViewItem = modelItem;
//------------Assert Results-------------------------
Assert.AreEqual(3, dsfSequenceActivity.Activities.Count);
}
public void SequenceDesignerViewModel_SetSmallViewItem_WhenModelItemDsfDbServiceActivity_ActivityNotAdded()
{
//------------Setup for test--------------------------
var dsfSequenceActivity = new DsfSequenceActivity();
var dsfMultiAssignActivity = new DsfMultiAssignActivity();
dsfSequenceActivity.Activities.Add(dsfMultiAssignActivity);
var dsfFindRecordsMultipleCriteriaActivity = new DsfFindRecordsMultipleCriteriaActivity();
dsfSequenceActivity.Activities.Add(dsfFindRecordsMultipleCriteriaActivity);
var sequenceDesignerViewModel = new SequenceDesignerViewModel(CreateModelItem(dsfSequenceActivity));
ModelItem modelItem = ModelItemUtils.CreateModelItem(new DsfDatabaseActivity());
//------------Execute Test---------------------------
sequenceDesignerViewModel.SmallViewItem = modelItem;
//------------Assert Results-------------------------
Assert.AreEqual(2, dsfSequenceActivity.Activities.Count);
}
public void SequenceDesignerViewModel_DoDrop_WhenNoFormats_ActivityNotAdded()
{
//------------Setup for test--------------------------
var dsfSequenceActivity = new DsfSequenceActivity();
var dsfMultiAssignActivity = new DsfMultiAssignActivity();
dsfSequenceActivity.Activities.Add(dsfMultiAssignActivity);
var dsfFindRecordsMultipleCriteriaActivity = new DsfFindRecordsMultipleCriteriaActivity();
dsfSequenceActivity.Activities.Add(dsfFindRecordsMultipleCriteriaActivity);
var sequenceDesignerViewModel = new SequenceDesignerViewModel(CreateModelItem(dsfSequenceActivity));
var dataObjectMock = new Mock<IDataObject>();
dataObjectMock.Setup(o => o.GetFormats()).Returns(new string[] { });
//------------Execute Test---------------------------
bool doDrop = sequenceDesignerViewModel.DoDrop(dataObjectMock.Object);
//------------Assert Results-------------------------
Assert.IsFalse(doDrop);
Assert.AreEqual(2, dsfSequenceActivity.Activities.Count);
}
public void SequenceDesignerViewModel_DoDrop_WhenFormatDoesNotContainModelItemFormat_ActivityNotAdded()
{
//------------Setup for test--------------------------
var dsfSequenceActivity = new DsfSequenceActivity();
var dsfMultiAssignActivity = new DsfMultiAssignActivity();
dsfSequenceActivity.Activities.Add(dsfMultiAssignActivity);
var dsfFindRecordsMultipleCriteriaActivity = new DsfFindRecordsMultipleCriteriaActivity();
dsfSequenceActivity.Activities.Add(dsfFindRecordsMultipleCriteriaActivity);
var sequenceDesignerViewModel = new SequenceDesignerViewModel(CreateModelItem(dsfSequenceActivity));
var dataObjectMock = new Mock<IDataObject>();
dataObjectMock.Setup(o => o.GetFormats()).Returns(new[] { "Something Else" });
dataObjectMock.Setup(o => o.GetData("Something Else")).Returns(ModelItemUtils.CreateModelItem(new DsfGatherSystemInformationActivity()));
//------------Execute Test---------------------------
bool doDrop = sequenceDesignerViewModel.DoDrop(dataObjectMock.Object);
//------------Assert Results-------------------------
Assert.IsFalse(doDrop);
Assert.AreEqual(2, dsfSequenceActivity.Activities.Count);
}
public void SequenceDesignerViewModel_DoDrop_WhenModelItemsFormatHasSingleItem_ActivitiesAdded()
{
//------------Setup for test--------------------------
var dsfSequenceActivity = new DsfSequenceActivity();
var dsfMultiAssignActivity = new DsfMultiAssignActivity();
dsfSequenceActivity.Activities.Add(dsfMultiAssignActivity);
var dsfFindRecordsMultipleCriteriaActivity = new DsfFindRecordsMultipleCriteriaActivity();
dsfSequenceActivity.Activities.Add(dsfFindRecordsMultipleCriteriaActivity);
var sequenceDesignerViewModel = new SequenceDesignerViewModel(CreateModelItem(dsfSequenceActivity));
var dataObjectMock = new Mock<IDataObject>();
dataObjectMock.Setup(o => o.GetFormats()).Returns(new[] { "ModelItemsFormat" });
dataObjectMock.Setup(o => o.GetData("ModelItemsFormat")).Returns(new List<ModelItem> { ModelItemUtils.CreateModelItem(new DsfGatherSystemInformationActivity()) });
//------------Execute Test---------------------------
bool doDrop = sequenceDesignerViewModel.DoDrop(dataObjectMock.Object);
//------------Assert Results-------------------------
Assert.IsTrue(doDrop);
Assert.AreEqual(3, dsfSequenceActivity.Activities.Count);
}
/// <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>();
Type activityType = activity.GetType();
if (activityType == typeof(DsfDataSplitActivity))
{
DsfDataSplitActivity dsAct = activity as DsfDataSplitActivity;
if (dsAct != null)
{
results.AddRange(InternalFindMissing(dsAct.ResultsCollection));
if (!string.IsNullOrEmpty(dsAct.SourceString))
{
results.Add(dsAct.SourceString);
}
}
}
if (activityType == typeof(DsfCreateJsonActivity))
{
var dsAct = activity as DsfCreateJsonActivity;
if (dsAct != null)
{
results.AddRange(InternalFindMissing(dsAct.JsonMappings));
if (!string.IsNullOrEmpty(dsAct.JsonString))
{
results.Add(dsAct.JsonString);
}
}
}
if (activityType == typeof(SharepointReadListActivity))
{
var dsAct = activity as SharepointReadListActivity;
if (dsAct != null)
{
results.AddRange(InternalFindMissing(dsAct.ReadListItems));
if (dsAct.FilterCriteria != null)
{
results.AddRange(InternalFindMissing(dsAct.FilterCriteria));
}
}
}
if (activityType == typeof(SharepointCreateListItemActivity))
{
var dsAct = activity as SharepointCreateListItemActivity;
if (dsAct != null)
{
results.AddRange(InternalFindMissing(dsAct.ReadListItems));
results.Add(dsAct.Result);
}
}
if (activityType == typeof(SharepointDeleteListItemActivity))
{
var dsAct = activity as SharepointDeleteListItemActivity;
if (dsAct != null)
{
results.AddRange(InternalFindMissing(dsAct.FilterCriteria));
results.Add(dsAct.DeleteCount);
}
}
if (activityType == typeof(SharepointUpdateListItemActivity))
{
var dsAct = activity as SharepointUpdateListItemActivity;
if (dsAct != null)
{
results.AddRange(InternalFindMissing(dsAct.ReadListItems));
results.AddRange(InternalFindMissing(dsAct.FilterCriteria));
results.Add(dsAct.Result);
}
}
else if (activityType == typeof(DsfDataMergeActivity))
{
DsfDataMergeActivity dmAct = activity as DsfDataMergeActivity;
if (dmAct != null)
{
results.AddRange(InternalFindMissing(dmAct.MergeCollection));
if (!string.IsNullOrEmpty(dmAct.Result))
{
results.Add(dmAct.Result);
}
}
}
else if (activityType == typeof(DsfXPathActivity))
{
DsfXPathActivity xpAct = activity as DsfXPathActivity;
if (xpAct != null)
{
results.AddRange(InternalFindMissing(xpAct.ResultsCollection));
if (!string.IsNullOrEmpty(xpAct.SourceString))
{
results.Add(xpAct.SourceString);
}
}
}
else if (activityType == typeof(DsfSqlBulkInsertActivity))
{
var sbiAct = activity as DsfSqlBulkInsertActivity;
if (sbiAct != null)
{
results.AddRange(InternalFindMissing(sbiAct.InputMappings));
if (!string.IsNullOrEmpty(sbiAct.Result))
{
results.Add(sbiAct.Result);
}
}
}
else if (activityType == typeof(DsfFindRecordsMultipleCriteriaActivity))
{
DsfFindRecordsMultipleCriteriaActivity frmAct = activity as DsfFindRecordsMultipleCriteriaActivity;
if (frmAct != null)
{
results.AddRange(InternalFindMissing(frmAct.ResultsCollection));
if (!string.IsNullOrEmpty(frmAct.FieldsToSearch))
{
results.Add(frmAct.FieldsToSearch);
}
if (!string.IsNullOrEmpty(frmAct.Result))
{
results.Add(frmAct.Result);
}
}
}
var act = activity as DsfNativeActivity <string>;
if (act != null)
{
if (!string.IsNullOrEmpty(act.OnErrorVariable))
{
results.Add(act.OnErrorVariable);
}
if (!string.IsNullOrEmpty(act.OnErrorWorkflow))
{
results.Add(act.OnErrorWorkflow);
}
}
return(results);
}
