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();
var recordsetName = ScenarioContext.Current.Get <string>("recordset");
var sortOrder = ScenarioContext.Current.Get <string>("sortOrder");
var sortRecords = new DsfSortRecordsActivity
{
SortField = recordsetName,
SelectedSort = sortOrder
};
TestStartNode = new FlowStep
{
Action = sortRecords
};
ScenarioContext.Current.Add("activity", sortRecords);
}
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();
var recordsetName = ScenarioContext.Current.Get<string>("recordset");
var sortOrder = ScenarioContext.Current.Get<string>("sortOrder");
var sortRecords = new DsfSortRecordsActivity
{
SortField = recordsetName,
SelectedSort = sortOrder
};
TestStartNode = new FlowStep
{
Action = sortRecords
};
ScenarioContext.Current.Add("activity", sortRecords);
}
public void DsfSortRecordsActivity_UpdateForEachOutputs_NullUpdates_DoesNothing()
{
//------------Setup for test--------------------------
const string SortField = "[[Company().Name]]";
var act = new DsfSortRecordsActivity {
SortField = SortField
};
act.UpdateForEachOutputs(null);
//------------Assert Results-------------------------
Assert.AreEqual(SortField, act.SortField);
}
public void SortRecords_GetOutputs_Expected_Zero_Output()
{
DsfSortRecordsActivity testAct = new DsfSortRecordsActivity();
IBinaryDataList outputs = testAct.GetOutputs();
var res = outputs.FetchAllEntries().Count;
// remove test datalist ;)
Assert.AreEqual(0, res);
}
public void GetOutputs_Called_ShouldReturnListWithResultValueInIt()
{
//------------Setup for test--------------------------
var act = new DsfSortRecordsActivity {
SortField = "[[recset().Id]]", SelectedSort = "Forward"
};
//------------Execute Test---------------------------
var outputs = act.GetOutputs();
//------------Assert Results-------------------------
Assert.AreEqual(1, outputs.Count);
Assert.AreEqual("[[recset().Id]]", outputs[0]);
}
public void SortRecords_GetInputs_Expected_Two_Input()
{
DsfSortRecordsActivity testAct = new DsfSortRecordsActivity();
IBinaryDataList inputs = testAct.GetInputs();
var res = inputs.FetchAllEntries().Count;
// remove test datalist ;)
DataListRemoval(inputs.UID);
Assert.AreEqual(2, res);
}
public void GetActivityFieldsOffDsfSortRecordsActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfSortRecordsActivity activity = new DsfSortRecordsActivity();
activity.SortField = "[[SortField]]";
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
List <string> actual = strategy.GetActivityFields(activity);
List <string> expected = new List <string> {
"[[SortField]]"
};
CollectionAssert.AreEqual(expected, actual);
}
public void Dev2FindMissingStrategyFactory_GetActivityFieldsOff_DsfSortRecords_Activity_ExpectAllFindMissingFieldsToBeReturned()
{
var activity = new DsfSortRecordsActivity
{
SortField = "[[SortField]]"
};
var fac = new Dev2FindMissingStrategyFactory();
var strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
var actual = strategy.GetActivityFields(activity);
var expected = new List <string> {
"[[SortField]]"
};
CollectionAssert.AreEqual(expected, actual);
}
private DsfSortRecordsActivity SetupArgumentsReturnObj(string currentDL, string testData, string sortField, string selectedSort)
{
var act = new DsfSortRecordsActivity {
SortField = sortField, SelectedSort = selectedSort
};
TestStartNode = new FlowStep
{
Action = act
};
CurrentDl = currentDL;
TestData = testData;
return(act);
}
public void DsfSortRecordsActivity_Execute_GetDebugInputs_ExpectCorrectInputs()
{
DsfSortRecordsActivity act = SetupArgumentsReturnObj(
TestData = ActivityStrings.SortDataList_Shape
, TestData = ActivityStrings.SortDataList
, "[[recset().DoesntExisit]]"
, "Forward"
);
TestData = ActivityStrings.SortDataList;
IDSFDataObject result = ExecuteProcess(isDebug: true);
var debug = act.GetDebugInputs(null, 0);
Assert.AreEqual(debug.Count, 2);
// remove test datalist ;)
}
public void DsfSortRecordsActivity_GetForEachOutputs_WhenHasResult_ReturnsOutputList()
{
//------------Setup for test--------------------------
const string SortField = "[[Company().Name]]";
var act = new DsfSortRecordsActivity {
SortField = SortField
};
//------------Execute Test---------------------------
var dsfForEachItems = act.GetForEachOutputs();
//------------Assert Results-------------------------
Assert.AreEqual(1, dsfForEachItems.Count);
Assert.AreEqual(SortField, dsfForEachItems[0].Name);
Assert.AreEqual(SortField, dsfForEachItems[0].Value);
}
public void DsfSortRecordsActivity_UpdateForEachOutputs_1Updates_UpdateCommandResult()
{
//------------Setup for test--------------------------
const string SortField = "[[Company().Name]]";
var act = new DsfSortRecordsActivity {
SortField = SortField
};
var tuple1 = new Tuple <string, string>(SortField, "Test");
//------------Execute Test---------------------------
act.UpdateForEachOutputs(new List <Tuple <string, string> > {
tuple1
});
//------------Assert Results-------------------------
Assert.AreEqual("Test", act.SortField);
}
public void DsfSortRecordsActivity_UpdateForEachOutputs_MoreThan1Updates_DoesNothing()
{
//------------Setup for test--------------------------
const string SortField = "[[Company().Name]]";
var act = new DsfSortRecordsActivity {
SortField = SortField
};
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(SortField, act.SortField);
}
public void DsfSortRecordsActivity_GetState_ReturnsStateVariable()
{
//---------------Set up test pack-------------------
//------------Setup for test--------------------------
var act = new DsfSortRecordsActivity {
SortField = "[[recset()]]", SelectedSort = "Forward"
};
//------------Execute Test---------------------------
var stateItems = act.GetState();
Assert.AreEqual(2, stateItems.Count());
var expectedResults = new[]
{
new StateVariable
{
Name = "SortField",
Type = StateVariable.StateType.InputOutput,
Value = "[[recset()]]"
},
new StateVariable
{
Name = "SelectedSort",
Type = StateVariable.StateType.Input,
Value = "Forward"
}
};
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 Equals_Given_Same_SelectedSort_IsEqual()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var activity1 = new DsfSortRecordsActivity()
{
UniqueID = uniqueId, SelectedSort = "a"
};
var activity = new DsfSortRecordsActivity()
{
UniqueID = uniqueId, SelectedSort = "a"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity1);
//---------------Execute Test ----------------------
var @equals = activity1.Equals(activity);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}
public void Equals_Given_DisplayName_Different_DisplayName_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var activity1 = new DsfSortRecordsActivity()
{
UniqueID = uniqueId, DisplayName = "A"
};
var activity = new DsfSortRecordsActivity()
{
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_EmptyActivityTools_AreEqual()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var activity = new DsfSortRecordsActivity()
{
UniqueID = uniqueId
};
var activity1 = new DsfSortRecordsActivity()
{
UniqueID = uniqueId
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity);
//---------------Execute Test ----------------------
var @equals = activity.Equals(activity1);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}
public void GetActivityFieldsOffDsfSortRecordsActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfSortRecordsActivity activity = new DsfSortRecordsActivity();
activity.SortField = "[[SortField]]";
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
List<string> actual = strategy.GetActivityFields(activity);
List<string> expected = new List<string> { "[[SortField]]" };
CollectionAssert.AreEqual(expected, actual);
}
public void DsfSortRecordsActivity_GetForEachOutputs_WhenHasResult_ReturnsOutputList()
{
//------------Setup for test--------------------------
const string SortField = "[[Company().Name]]";
var act = new DsfSortRecordsActivity { SortField = SortField };
//------------Execute Test---------------------------
var dsfForEachItems = act.GetForEachOutputs();
//------------Assert Results-------------------------
Assert.AreEqual(1, dsfForEachItems.Count);
Assert.AreEqual(SortField, dsfForEachItems[0].Name);
Assert.AreEqual(SortField, dsfForEachItems[0].Value);
}
public void DsfSortRecordsActivity_UpdateForEachOutputs_1Updates_UpdateCommandResult()
{
//------------Setup for test--------------------------
const string SortField = "[[Company().Name]]";
var act = new DsfSortRecordsActivity { SortField = SortField };
var tuple1 = new Tuple<string, string>(SortField, "Test");
//------------Execute Test---------------------------
act.UpdateForEachOutputs(new List<Tuple<string, string>> { tuple1 });
//------------Assert Results-------------------------
Assert.AreEqual("Test", act.SortField);
}
public void DsfSortRecordsActivity_UpdateForEachOutputs_NullUpdates_DoesNothing()
{
//------------Setup for test--------------------------
const string SortField = "[[Company().Name]]";
var act = new DsfSortRecordsActivity { SortField = SortField };
act.UpdateForEachOutputs(null);
//------------Assert Results-------------------------
Assert.AreEqual(SortField, act.SortField);
}
public void DsfSortRecordsActivity_UpdateForEachOutputs_MoreThan1Updates_DoesNothing()
{
//------------Setup for test--------------------------
const string SortField = "[[Company().Name]]";
var act = new DsfSortRecordsActivity { SortField = SortField };
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(SortField, act.SortField);
}
private DsfSortRecordsActivity SetupArgumentsReturnObj(string currentDL, string testData, string sortField, string selectedSort)
{
var act = new DsfSortRecordsActivity { SortField = sortField, SelectedSort = selectedSort };
TestStartNode = new FlowStep
{
Action = act
};
CurrentDl = currentDL;
TestData = testData;
return act;
}
