public void GivenItContainsDataSplitAs(string parentName, string activityName, Table table)
{
var activity = new DsfDataSplitActivity {
DisplayName = activityName
};
foreach (var tableRow in table.Rows)
{
var valueToSplit = string.IsNullOrEmpty(tableRow["String"]) ? "" : tableRow["String"];
var variable = tableRow["Variable"];
var type = tableRow["Type"];
var at = tableRow["At"];
var include = tableRow["Include"] == "Selected";
//var escapeChar = tableRow["Escape"];
_commonSteps.AddVariableToVariableList(variable);
if (!string.IsNullOrEmpty(valueToSplit))
{
activity.SourceString = valueToSplit;
}
_commonSteps.AddVariableToVariableList(variable);
activity.ResultsCollection.Add(new DataSplitDTO(variable, type, at, 1, include, true));
}
_commonSteps.AddActivityToActivityList(parentName, activityName, activity);
}
public void LargeRows_SplitOnNewLine_ShouldSplitCorrectly()
{
IList <DataSplitDTO> resultsCollection = new List <DataSplitDTO>();
resultsCollection.Add(new DataSplitDTO("[[rec().data]]", "New Line", "", 1));
var sourceString = "";
if (File.Exists("LargeRowsDataSplit.txt"))
{
sourceString = File.ReadAllText("LargeRowsDataSplit.txt");
}
else if (File.Exists("Out\\LargeRowsDataSplit.txt"))
{
sourceString = File.ReadAllText("Out\\LargeRowsDataSplit.txt");
}
Assert.IsFalse(string.IsNullOrEmpty(sourceString), "Cannot find Deployment Item LargeRowsDataSplit.txt");
var act = new DsfDataSplitActivity {
SourceString = sourceString, ResultsCollection = resultsCollection, SkipBlankRows = true
};
var dataObject = new DsfDataObject("", Guid.Empty)
{
IsDebug = false,
};
act.Execute(dataObject, 0);
var totalCount = dataObject.Environment.GetCount("rec");
var res = dataObject.Environment.Eval("[[rec().data]]", 0) as CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult;
Assert.AreEqual("0827373254", res.Item.First().ToString());
Assert.AreEqual(8300000, totalCount, CurrentDl);
}
public void DsfDataSplitActivity_GetState_ReturnsStateVariable()
{
IList <DataSplitDTO> resultsCollection = new List <DataSplitDTO> {
new DataSplitDTO("[[CompanyName]]", "Index", "2", 1)
};
var act = new DsfDataSplitActivity {
SourceString = "[[CompanyName]]", ReverseOrder = true, SkipBlankRows = true, ResultsCollection = resultsCollection
};
//------------Execute Test---------------------------
var stateItems = act.GetState();
Assert.AreEqual(4, stateItems.Count());
var expectedResults = new[]
{
new StateVariable
{
Name = "SourceString",
Type = StateVariable.StateType.Input,
Value = "[[CompanyName]]"
},
new StateVariable
{
Name = "ReverseOrder",
Type = StateVariable.StateType.Input,
Value = "True"
},
new StateVariable
{
Name = "SkipBlankRows",
Type = StateVariable.StateType.Input,
Value = "True"
},
new StateVariable
{
Name = "ResultsCollection",
Type = StateVariable.StateType.Output,
Value = ActivityHelper.GetSerializedStateValueFromCollection(resultsCollection)
}
};
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 GetActivityFieldsOffDataSplitActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfDataSplitActivity dataSplitActivity = new DsfDataSplitActivity();
dataSplitActivity.OnErrorVariable = "[[onErr]]";
dataSplitActivity.ResultsCollection = new List<DataSplitDTO> { new DataSplitDTO("[[OutputVariable1]]", "Index", "[[At1]]", 1) { EscapeChar = "[[Escaped1]]" }, new DataSplitDTO("[[OutputVariable2]]", "Index", "[[At2]]", 2) { EscapeChar = "[[Escaped2]]" } };
dataSplitActivity.SourceString = "[[SourceString]]";
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.MixedActivity);
List<string> actual = strategy.GetActivityFields(dataSplitActivity);
List<string> expected = new List<string> { "[[Escaped1]]", "[[OutputVariable1]]", "[[At1]]", "[[Escaped2]]", "[[OutputVariable2]]", "[[At2]]", "[[SourceString]]", "[[onErr]]" };
CollectionAssert.AreEqual(expected, actual);
}
public void Equals_Given_Same_ResultsCollection_Different_Indexes_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var splitColl = new List <DataSplitDTO>
{
new DataSplitDTO
{
OutputVariable = "[[VariableA]]"
,
At = "'"
},
new DataSplitDTO
{
OutputVariable = "[[VariableB]]"
,
At = "@"
}
};
var splitColl2 = new List <DataSplitDTO>()
{
new DataSplitDTO
{
OutputVariable = "[[VariableB]]"
,
At = "@"
}
,
new DataSplitDTO
{
OutputVariable = "[[VariableA]]"
,
At = "'"
}
};
var activity1 = new DsfDataSplitActivity()
{
UniqueID = uniqueId, ResultsCollection = splitColl
};
var activity = new DsfDataSplitActivity()
{
UniqueID = uniqueId, ResultsCollection = splitColl2
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity1);
//---------------Execute Test ----------------------
var @equals = activity1.Equals(activity);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
protected override void BuildDataList()
{
BuildShapeAndTestData();
string stringToSplit;
ScenarioContext.Current.TryGetValue("stringToSplit", out stringToSplit);
List <DataSplitDTO> splitCollection;
ScenarioContext.Current.TryGetValue("splitCollection", out splitCollection);
var dataSplit = new DsfDataSplitActivity {
SourceString = stringToSplit
};
int row = 1;
foreach (var dto in splitCollection)
{
dto.IndexNumber = row;
dataSplit.ResultsCollection.Add(dto);
row++;
}
bool reverseOrder;
bool skipBlankRows;
ScenarioContext.Current.TryGetValue("ReverseOrder", out reverseOrder);
ScenarioContext.Current.TryGetValue("SkipBlankRows", out skipBlankRows);
dataSplit.ReverseOrder = reverseOrder;
dataSplit.SkipBlankRows = skipBlankRows;
TestStartNode = new FlowStep
{
Action = dataSplit
};
string errorVariable;
ScenarioContext.Current.TryGetValue("errorVariable", out errorVariable);
string webserviceToCall;
ScenarioContext.Current.TryGetValue("webserviceToCall", out webserviceToCall);
dataSplit.OnErrorVariable = errorVariable;
dataSplit.OnErrorWorkflow = webserviceToCall;
ScenarioContext.Current.Add("activity", dataSplit);
}
public void DsfDataSplitActivity_UpdateForEachOutputs_NullUpdates_DoesNothing()
{
//------------Setup for test--------------------------
IList <DataSplitDTO> resultsCollection = new List <DataSplitDTO> {
new DataSplitDTO("[[CompanyName]]", "Index", "2", 1)
};
var act = new DsfDataSplitActivity {
SourceString = "[[CompanyName]]", ResultsCollection = resultsCollection
};
//------------Execute Test---------------------------
act.UpdateForEachOutputs(null);
//------------Assert Results-------------------------
Assert.AreEqual("[[CompanyName]]", act.SourceString);
}
public void DsfDataSplitActivity_GetOutputs_Called_ShouldReturnListWithResultValueInIt()
{
//------------Setup for test--------------------------
_resultsCollection.Clear();
_resultsCollection.Add(new DataSplitDTO("[[recset1(5).field1]]", "Chars", "|", 1));
_resultsCollection.Add(new DataSplitDTO("[[recset2(2).field2]]", "Chars", "|", 2));
var act = new DsfDataSplitActivity {
SourceString = _source, ResultsCollection = _resultsCollection
};
//------------Execute Test---------------------------
var outputs = act.GetOutputs();
//------------Assert Results-------------------------
Assert.AreEqual(2, outputs.Count);
Assert.AreEqual("[[recset1(5).field1]]", outputs[0]);
Assert.AreEqual("[[recset2(2).field2]]", outputs[1]);
}
public void DsfDataSplitActivity_GetForEachOutputs_WhenHasResult_ReturnsInputList()
{
//------------Setup for test--------------------------
IList <DataSplitDTO> resultsCollection = new List <DataSplitDTO> {
new DataSplitDTO("[[CompanyName]]", "Index", "2", 1)
};
var act = new DsfDataSplitActivity {
SourceString = "[[CompanyName]]", ResultsCollection = resultsCollection
};
//------------Execute Test---------------------------
var dsfForEachItems = act.GetForEachOutputs();
//------------Assert Results-------------------------
Assert.AreEqual(1, dsfForEachItems.Count);
Assert.AreEqual("[[CompanyName]]", dsfForEachItems[0].Name);
Assert.AreEqual("[[CompanyName]]", dsfForEachItems[0].Value);
}
protected override void BuildDataList()
{
BuildShapeAndTestData();
string stringToSplit;
ScenarioContext.Current.TryGetValue("stringToSplit", out stringToSplit);
List<DataSplitDTO> splitCollection;
ScenarioContext.Current.TryGetValue("splitCollection", out splitCollection);
var dataSplit = new DsfDataSplitActivity { SourceString = stringToSplit };
int row = 1;
foreach(var dto in splitCollection)
{
dto.IndexNumber = row;
dataSplit.ResultsCollection.Add(dto);
row++;
}
bool reverseOrder;
bool skipBlankRows;
ScenarioContext.Current.TryGetValue("ReverseOrder", out reverseOrder);
ScenarioContext.Current.TryGetValue("SkipBlankRows", out skipBlankRows);
dataSplit.ReverseOrder = reverseOrder;
dataSplit.SkipBlankRows = skipBlankRows;
TestStartNode = new FlowStep
{
Action = dataSplit
};
string errorVariable;
ScenarioContext.Current.TryGetValue("errorVariable", out errorVariable);
string webserviceToCall;
ScenarioContext.Current.TryGetValue("webserviceToCall", out webserviceToCall);
dataSplit.OnErrorVariable = errorVariable;
dataSplit.OnErrorWorkflow = webserviceToCall;
ScenarioContext.Current.Add("activity", dataSplit);
}
public void DsfDataSplitActivity_UpdateForEachOutputs_1Updates_UpdateCountNumber()
{
//------------Setup for test--------------------------
IList <DataSplitDTO> resultsCollection = new List <DataSplitDTO> {
new DataSplitDTO("[[CompanyName]]", "Index", "2", 1)
};
var act = new DsfDataSplitActivity {
SourceString = "[[CompanyName]]", ResultsCollection = resultsCollection
};
var tuple1 = new Tuple <string, string>("[[CompanyName]]", "Test");
//------------Execute Test---------------------------
act.UpdateForEachOutputs(new List <Tuple <string, string> > {
tuple1
});
//------------Assert Results-------------------------
Assert.AreEqual("Test", act.ResultsCollection[0].OutputVariable);
}
public void Equals_Given_EmptyActivityTools_AreEqual()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var activity = new DsfDataSplitActivity()
{
UniqueID = uniqueId
};
var activity1 = new DsfDataSplitActivity()
{
UniqueID = uniqueId
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity);
//---------------Execute Test ----------------------
var @equals = activity.Equals(activity1);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}
public void Equals_Given_Same_ReverseOrder_IsEqual()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var activity1 = new DsfDataSplitActivity()
{
UniqueID = uniqueId, ReverseOrder = true
};
var activity = new DsfDataSplitActivity()
{
UniqueID = uniqueId, ReverseOrder = true
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity1);
//---------------Execute Test ----------------------
var @equals = activity1.Equals(activity);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}
public void Equals_Given_Different_SourceString_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var activity1 = new DsfDataSplitActivity()
{
UniqueID = uniqueId, SourceString = "A"
};
var activity = new DsfDataSplitActivity()
{
UniqueID = uniqueId, SourceString = "ass"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity1);
//---------------Execute Test ----------------------
var @equals = activity1.Equals(activity);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
public void DsfDataSplitActivity_UpdateForEachInputs_MoreThan1Updates_UpdatesMergeCollection()
{
//------------Setup for test--------------------------
IList <DataSplitDTO> resultsCollection = new List <DataSplitDTO> {
new DataSplitDTO("[[CompanyName]]", "Index", "2", 1), new DataSplitDTO("[[CompanyName]]", "Index", "1", 2)
};
var act = new DsfDataSplitActivity {
SourceString = "[[CompanyName]]", ResultsCollection = resultsCollection
};
var tuple1 = new Tuple <string, string>("2", "Test");
var tuple2 = new Tuple <string, string>("1", "Test2");
var tuple3 = new Tuple <string, string>("[[CompanyName]]", "Test3");
//------------Execute Test---------------------------
act.UpdateForEachInputs(new List <Tuple <string, string> > {
tuple1, tuple2, tuple3
});
//------------Assert Results-------------------------
Assert.AreEqual("Test", act.ResultsCollection[0].At);
Assert.AreEqual("Test2", act.ResultsCollection[1].At);
Assert.AreEqual("Test3", act.SourceString);
}
public void GetActivityFieldsOffDataSplitActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfDataSplitActivity dataSplitActivity = new DsfDataSplitActivity();
dataSplitActivity.OnErrorVariable = "[[onErr]]";
dataSplitActivity.ResultsCollection = new List <DataSplitDTO> {
new DataSplitDTO("[[OutputVariable1]]", "Index", "[[At1]]", 1)
{
EscapeChar = "[[Escaped1]]"
}, new DataSplitDTO("[[OutputVariable2]]", "Index", "[[At2]]", 2)
{
EscapeChar = "[[Escaped2]]"
}
};
dataSplitActivity.SourceString = "[[SourceString]]";
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.MixedActivity);
List <string> actual = strategy.GetActivityFields(dataSplitActivity);
List <string> expected = new List <string> {
"[[Escaped1]]", "[[OutputVariable1]]", "[[At1]]", "[[Escaped2]]", "[[OutputVariable2]]", "[[At2]]", "[[SourceString]]", "[[onErr]]"
};
CollectionAssert.AreEqual(expected, actual);
}
public void DsfDataSplitActivity_GetForEachOutputs_WhenHasResult_ReturnsInputList()
{
//------------Setup for test--------------------------
IList<DataSplitDTO> resultsCollection = new List<DataSplitDTO> { new DataSplitDTO("[[CompanyName]]", "Index", "2", 1) };
var act = new DsfDataSplitActivity { SourceString = "[[CompanyName]]", ResultsCollection = resultsCollection };
//------------Execute Test---------------------------
var dsfForEachItems = act.GetForEachOutputs();
//------------Assert Results-------------------------
Assert.AreEqual(1, dsfForEachItems.Count);
Assert.AreEqual("[[CompanyName]]", dsfForEachItems[0].Name);
Assert.AreEqual("[[CompanyName]]", dsfForEachItems[0].Value);
}
public void DsfDataSplitActivity_UpdateForEachOutputs_1Updates_UpdateCountNumber()
{
//------------Setup for test--------------------------
IList<DataSplitDTO> resultsCollection = new List<DataSplitDTO> { new DataSplitDTO("[[CompanyName]]", "Index", "2", 1) };
var act = new DsfDataSplitActivity { SourceString = "[[CompanyName]]", ResultsCollection = resultsCollection };
var tuple1 = new Tuple<string, string>("[[CompanyName]]", "Test");
//------------Execute Test---------------------------
act.UpdateForEachOutputs(new List<Tuple<string, string>> { tuple1 });
//------------Assert Results-------------------------
Assert.AreEqual("Test", act.ResultsCollection[0].OutputVariable);
}
public void DsfDataSplitActivity_UpdateForEachOutputs_NullUpdates_DoesNothing()
{
//------------Setup for test--------------------------
IList<DataSplitDTO> resultsCollection = new List<DataSplitDTO> { new DataSplitDTO("[[CompanyName]]", "Index", "2", 1) };
var act = new DsfDataSplitActivity { SourceString = "[[CompanyName]]", ResultsCollection = resultsCollection };
//------------Execute Test---------------------------
act.UpdateForEachOutputs(null);
//------------Assert Results-------------------------
Assert.AreEqual("[[CompanyName]]", act.SourceString);
}
public void DsfDataSplitActivity_UpdateForEachInputs_MoreThan1Updates_UpdatesMergeCollection()
{
//------------Setup for test--------------------------
IList<DataSplitDTO> resultsCollection = new List<DataSplitDTO> { new DataSplitDTO("[[CompanyName]]", "Index", "2", 1), new DataSplitDTO("[[CompanyName]]", "Index", "1", 2) };
var act = new DsfDataSplitActivity { SourceString = "[[CompanyName]]", ResultsCollection = resultsCollection };
var tuple1 = new Tuple<string, string>("2", "Test");
var tuple2 = new Tuple<string, string>("1", "Test2");
var tuple3 = new Tuple<string, string>("[[CompanyName]]", "Test3");
//------------Execute Test---------------------------
act.UpdateForEachInputs(new List<Tuple<string, string>> { tuple1, tuple2, tuple3 });
//------------Assert Results-------------------------
Assert.AreEqual("Test", act.ResultsCollection[0].At);
Assert.AreEqual("Test2", act.ResultsCollection[1].At);
Assert.AreEqual("Test3", act.SourceString);
}
public void GivenItContainsDataSplitAs(string parentName, string activityName, Table table)
{
DsfDataSplitActivity activity = new DsfDataSplitActivity { DisplayName = activityName };
foreach(var tableRow in table.Rows)
{
var valueToSplit = string.IsNullOrEmpty(tableRow["String"]) ? "" : tableRow["String"];
var variable = tableRow["Variable"];
var type = tableRow["Type"];
var at = tableRow["At"];
var include = tableRow["Include"] == "Selected";
//var escapeChar = tableRow["Escape"];
CommonSteps.AddVariableToVariableList(variable);
if(!string.IsNullOrEmpty(valueToSplit))
{
activity.SourceString = valueToSplit;
}
CommonSteps.AddVariableToVariableList(variable);
activity.ResultsCollection.Add(new DataSplitDTO(variable, type, at, 1, include, true));
}
CommonSteps.AddActivityToActivityList(parentName, activityName, activity);
}
/// <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);
}
