public void CountRecordsetActivity_GetOutputs_Expected_One_Output()
{
DsfReplaceActivity testAct = new DsfReplaceActivity();
IBinaryDataList outputs = testAct.GetOutputs();
var res = outputs.FetchAllEntries().Count;
// remove test datalist ;)
Assert.AreEqual(1, res);
}
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 find;
scenarioContext.TryGetValue("find", out find);
string replaceWith;
scenarioContext.TryGetValue("replaceWith", out replaceWith);
string resultVar;
scenarioContext.TryGetValue("resultVar", out resultVar);
if (string.IsNullOrEmpty(resultVar))
{
resultVar = ResultVariable;
}
string sentence;
if (scenarioContext.TryGetValue("sentence", out sentence))
{
_inFields = sentence;
}
var replace = new DsfReplaceActivity
{
Result = resultVar,
FieldsToSearch = _inFields,
Find = find,
ReplaceWith = replaceWith
};
TestStartNode = new FlowStep
{
Action = replace
};
scenarioContext.Add("activity", replace);
}
public void CountRecordsetActivity_GetInputs_Expected_Four_Input()
{
DsfReplaceActivity testAct = new DsfReplaceActivity();
IBinaryDataList inputs = testAct.GetInputs();
var res = inputs.FetchAllEntries().Count;
// remove test datalist ;)
DataListRemoval(inputs.UID);
Assert.AreEqual(4, res);
}
public void DsfReplaceActivity_UpdateForEachOutputs_NullUpdates_DoesNothing()
{
//------------Setup for test--------------------------
const string FieldsToSearch = "[[Numeric(1).num]]";
const string Find = "Up";
const string Result = "[[res]]";
const string ReplaceWith = "2";
var act = new DsfReplaceActivity {
FieldsToSearch = FieldsToSearch, Find = Find, ReplaceWith = ReplaceWith, Result = Result
};
act.UpdateForEachOutputs(null);
//------------Assert Results-------------------------
Assert.AreEqual(Result, act.Result);
}
public void GetActivityFieldsOffDsfReplaceActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfReplaceActivity activity = new DsfReplaceActivity();
activity.FieldsToSearch = "[[FieldsToSearch]]";
activity.Find = "[[Find]]";
activity.ReplaceWith = "[[ReplaceWith]]";
activity.Result = "[[Result]]";
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
List <string> actual = strategy.GetActivityFields(activity);
List <string> expected = new List <string> {
"[[FieldsToSearch]]", "[[Find]]", "[[ReplaceWith]]", "[[Result]]"
};
CollectionAssert.AreEqual(expected, actual);
}
public void Dev2FindMissingStrategyFactory_GetActivityFieldsOff_DsfReplace_Activity_ExpectAllFindMissingFieldsToBeReturned()
{
var activity = new DsfReplaceActivity
{
FieldsToSearch = "[[FieldsToSearch]]",
Find = "[[Find]]",
ReplaceWith = "[[ReplaceWith]]",
Result = "[[Result]]"
};
var fac = new Dev2FindMissingStrategyFactory();
var strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
var actual = strategy.GetActivityFields(activity);
var expected = new List <string> {
"[[FieldsToSearch]]", "[[Find]]", "[[ReplaceWith]]", "[[Result]]"
};
CollectionAssert.AreEqual(expected, actual);
}
public void GetOutputs_Called_ShouldReturnListWithResultValueInIt()
{
//------------Setup for test--------------------------
const string FieldsToSearch = "[[Numeric(1).num]]";
const string Find = "Up";
const string Result = "[[res]]";
const string ReplaceWith = "2";
var act = new DsfReplaceActivity {
FieldsToSearch = FieldsToSearch, Find = Find, ReplaceWith = ReplaceWith, Result = Result
};
//------------Execute Test---------------------------
var outputs = act.GetOutputs();
//------------Assert Results-------------------------
Assert.AreEqual(1, outputs.Count);
Assert.AreEqual("[[res]]", outputs[0]);
}
public void DsfReplaceActivity_GetForEachOutputs_WhenHasResult_ReturnsOutputList()
{
//------------Setup for test--------------------------
const string FieldsToSearch = "[[Numeric(1).num]]";
const string Find = "Up";
const string Result = "[[res]]";
const string ReplaceWith = "2";
var act = new DsfReplaceActivity {
FieldsToSearch = FieldsToSearch, Find = Find, ReplaceWith = ReplaceWith, Result = Result
};
//------------Execute Test---------------------------
var dsfForEachItems = act.GetForEachOutputs();
//------------Assert Results-------------------------
Assert.AreEqual(1, dsfForEachItems.Count);
Assert.AreEqual(Result, dsfForEachItems[0].Name);
Assert.AreEqual(Result, dsfForEachItems[0].Value);
}
public void GivenItContainsReplaceIntoAs(string parentName, string activityName, string resultVariable, Table table)
{
var activity = new DsfReplaceActivity {
Result = resultVariable, DisplayName = activityName
};
foreach (var tableRow in table.Rows)
{
var variable = tableRow["In Fields"];
var find = tableRow["Find"];
var replaceValue = tableRow["Replace With"];
activity.FieldsToSearch = variable;
activity.Find = find;
activity.ReplaceWith = replaceValue;
}
_commonSteps.AddVariableToVariableList(resultVariable);
_commonSteps.AddActivityToActivityList(parentName, activityName, activity);
}
public void DsfReplaceActivity_UpdateForEachOutputs_1Updates_UpdateCommandResult()
{
//------------Setup for test--------------------------
const string FieldsToSearch = "[[Numeric(1).num]]";
const string Find = "Up";
const string Result = "[[res]]";
const string ReplaceWith = "2";
var act = new DsfReplaceActivity {
FieldsToSearch = FieldsToSearch, Find = Find, ReplaceWith = ReplaceWith, Result = Result
};
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_Same_CaseMatch_IsEqual()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var activity1 = new DsfReplaceActivity()
{
UniqueID = uniqueId, CaseMatch = true
};
var activity = new DsfReplaceActivity()
{
UniqueID = uniqueId, CaseMatch = true
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity1);
//---------------Execute Test ----------------------
var @equals = activity1.Equals(activity);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}
public void Equals_Given_EmptyActivityTools_AreEqual()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var activity = new DsfReplaceActivity()
{
UniqueID = uniqueId
};
var activity1 = new DsfReplaceActivity()
{
UniqueID = uniqueId
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity);
//---------------Execute Test ----------------------
var @equals = activity.Equals(activity1);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}
public void Equals_Given_Different_DisplayName_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var activity1 = new DsfReplaceActivity()
{
UniqueID = uniqueId, DisplayName = "A"
};
var activity = new DsfReplaceActivity()
{
UniqueID = uniqueId, DisplayName = "ass"
};
//---------------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.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 find;
ScenarioContext.Current.TryGetValue("find", out find);
string replaceWith;
ScenarioContext.Current.TryGetValue("replaceWith", out replaceWith);
string sentence;
if(ScenarioContext.Current.TryGetValue("sentence", out sentence))
{
_inFields = sentence;
}
var replace = new DsfReplaceActivity
{
Result = ResultVariable,
FieldsToSearch = _inFields,
Find = find,
ReplaceWith = replaceWith
};
TestStartNode = new FlowStep
{
Action = replace
};
ScenarioContext.Current.Add("activity", replace);
}
public void DsfReplaceActivity_UpdateForEachInputs_MoreThan1Updates_Updates()
{
//------------Setup for test--------------------------
const string FieldsToSearch = "[[Numeric(1).num]]";
const string Find = "Up";
const string Result = "[[res]]";
const string ReplaceWith = "2";
var act = new DsfReplaceActivity {
FieldsToSearch = FieldsToSearch, Find = Find, ReplaceWith = ReplaceWith, Result = Result
};
var tuple1 = new Tuple <string, string>(FieldsToSearch, "Test");
var tuple2 = new Tuple <string, string>(Find, "Test2");
var tuple3 = new Tuple <string, string>(ReplaceWith, "Test3");
//------------Execute Test---------------------------
act.UpdateForEachInputs(new List <Tuple <string, string> > {
tuple1, tuple2, tuple3
});
//------------Assert Results-------------------------
Assert.AreEqual("Test2", act.Find);
Assert.AreEqual("Test", act.FieldsToSearch);
Assert.AreEqual("Test3", act.ReplaceWith);
}
public void DsfReplaceActivity_UpdateForEachOutputs_NullUpdates_DoesNothing()
{
//------------Setup for test--------------------------
const string FieldsToSearch = "[[Numeric(1).num]]";
const string Find = "Up";
const string Result = "[[res]]";
const string ReplaceWith = "2";
var act = new DsfReplaceActivity { FieldsToSearch = FieldsToSearch, Find = Find, ReplaceWith = ReplaceWith, Result = Result };
act.UpdateForEachOutputs(null);
//------------Assert Results-------------------------
Assert.AreEqual(Result, act.Result);
}
public void CountRecordsetActivity_GetOutputs_Expected_One_Output()
{
DsfReplaceActivity testAct = new DsfReplaceActivity();
IBinaryDataList outputs = testAct.GetOutputs();
var res = outputs.FetchAllEntries().Count;
// remove test datalist ;)
Assert.AreEqual(1, res);
}
public void DsfReplaceActivity_GetForEachOutputs_WhenHasResult_ReturnsOutputList()
{
//------------Setup for test--------------------------
const string FieldsToSearch = "[[Numeric(1).num]]";
const string Find = "Up";
const string Result = "[[res]]";
const string ReplaceWith = "2";
var act = new DsfReplaceActivity { FieldsToSearch = FieldsToSearch, Find = Find, ReplaceWith = ReplaceWith, Result = Result };
//------------Execute Test---------------------------
var dsfForEachItems = act.GetForEachOutputs();
//------------Assert Results-------------------------
Assert.AreEqual(1, dsfForEachItems.Count);
Assert.AreEqual(Result, dsfForEachItems[0].Name);
Assert.AreEqual(Result, dsfForEachItems[0].Value);
}
public void DsfReplaceActivity_GetState_Returns_Inputs_And_Outputs()
{
//------------Setup for test--------------------------
const string FieldsToSearch = "[[Numeric(1).num]]";
const string Find = "Up";
const string Result = "[[res]]";
const string ReplaceWith = "2";
var act = new DsfReplaceActivity {
FieldsToSearch = FieldsToSearch, Find = Find, ReplaceWith = ReplaceWith, Result = Result
};
//------------Execute Test---------------------------
var stateItems = act.GetState();
//------------Assert Results-------------------------
Assert.AreEqual(5, stateItems.Count());
var expectedResults = new[]
{
new StateVariable
{
Name = "FieldsToSearch",
Type = StateVariable.StateType.Input,
Value = act.FieldsToSearch
},
new StateVariable
{
Name = "Find",
Type = StateVariable.StateType.Input,
Value = act.Find
},
new StateVariable
{
Name = "ReplaceWith",
Type = StateVariable.StateType.Input,
Value = act.ReplaceWith
},
new StateVariable
{
Name = "CaseMatch",
Type = StateVariable.StateType.Input,
Value = act.CaseMatch.ToString()
},
new StateVariable
{
Name = "Result",
Type = StateVariable.StateType.Output,
Value = act.Result
}
};
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 DsfReplaceActivity_UpdateForEachInputs_MoreThan1Updates_Updates()
{
//------------Setup for test--------------------------
const string FieldsToSearch = "[[Numeric(1).num]]";
const string Find = "Up";
const string Result = "[[res]]";
const string ReplaceWith = "2";
var act = new DsfReplaceActivity { FieldsToSearch = FieldsToSearch, Find = Find, ReplaceWith = ReplaceWith, Result = Result };
var tuple1 = new Tuple<string, string>(FieldsToSearch, "Test");
var tuple2 = new Tuple<string, string>(Find, "Test2");
var tuple3 = new Tuple<string, string>(ReplaceWith, "Test3");
//------------Execute Test---------------------------
act.UpdateForEachInputs(new List<Tuple<string, string>> { tuple1, tuple2, tuple3 });
//------------Assert Results-------------------------
Assert.AreEqual("Test2", act.Find);
Assert.AreEqual("Test", act.FieldsToSearch);
Assert.AreEqual("Test3", act.ReplaceWith);
}
public void GivenItContainsReplaceIntoAs(string parentName, string activityName, string resultVariable, Table table)
{
DsfReplaceActivity activity = new DsfReplaceActivity { Result = resultVariable, DisplayName = activityName };
foreach(var tableRow in table.Rows)
{
var variable = tableRow["In Fields"];
var find = tableRow["Find"];
var replaceValue = tableRow["Replace With"];
activity.FieldsToSearch = variable;
activity.Find = find;
activity.ReplaceWith = replaceValue;
}
CommonSteps.AddVariableToVariableList(resultVariable);
CommonSteps.AddActivityToActivityList(parentName, activityName, activity);
}
public void GetActivityFieldsOffDsfReplaceActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfReplaceActivity activity = new DsfReplaceActivity();
activity.FieldsToSearch = "[[FieldsToSearch]]";
activity.Find = "[[Find]]";
activity.ReplaceWith = "[[ReplaceWith]]";
activity.Result = "[[Result]]";
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
List<string> actual = strategy.GetActivityFields(activity);
List<string> expected = new List<string> { "[[FieldsToSearch]]", "[[Find]]", "[[ReplaceWith]]", "[[Result]]" };
CollectionAssert.AreEqual(expected, actual);
}
public void DsfReplaceActivity_UpdateForEachOutputs_1Updates_UpdateCommandResult()
{
//------------Setup for test--------------------------
const string FieldsToSearch = "[[Numeric(1).num]]";
const string Find = "Up";
const string Result = "[[res]]";
const string ReplaceWith = "2";
var act = new DsfReplaceActivity { FieldsToSearch = FieldsToSearch, Find = Find, ReplaceWith = ReplaceWith, Result = Result };
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);
}
