public void Method_GivenIsNew_ShouldHaveTreatAsNullTrue()
{
//---------------Set up test pack-------------------
var dsfDeleteRecordActivity = new DsfDeleteRecordNullHandlerActivity();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
Assert.IsTrue(dsfDeleteRecordActivity.TreatNullAsZero);
//---------------Test Result -----------------------
}
public void DsfDeleteRecordActivity_UpdateForEachOutputs_NullUpdates_DoesNothing()
{
//------------Setup for test--------------------------
const string result = "[[res]]";
var act = new DsfDeleteRecordNullHandlerActivity {
RecordsetName = "[[Numeric()]]", Result = result
};
act.UpdateForEachOutputs(null);
//------------Assert Results-------------------------
Assert.AreEqual(result, act.Result);
}
public void DsfDeleteRecordActivity_GetForEachOutputs_WhenHasResult_ReturnsOutputList()
{
//------------Setup for test--------------------------
var act = new DsfDeleteRecordNullHandlerActivity {
RecordsetName = "[[Numeric()]]", 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 DsfDeleteRecordNullHandlerActivity_GetState_ReturnsStateVariable()
{
//------------Setup for test--------------------------
var act = new DsfDeleteRecordNullHandlerActivity {
RecordsetName = "[[Numeric()]]", TreatNullAsZero = false, Result = "[[res]]"
};
//------------Execute Test---------------------------
var stateItems = act.GetState();
Assert.AreEqual(3, stateItems.Count());
var expectedResults = new[]
{
new StateVariable
{
Name = "RecordsetName",
Type = StateVariable.StateType.Input,
Value = "[[Numeric()]]"
},
new StateVariable
{
Name = "TreatNullAsZero",
Type = StateVariable.StateType.Input,
Value = "False"
},
new StateVariable
{
Name = "Result",
Type = StateVariable.StateType.Output,
Value = "[[res]]"
}
};
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 DsfDeleteRecordActivity_UpdateForEachOutputs_1Updates_UpdateResult()
{
//------------Setup for test--------------------------
var act = new DsfDeleteRecordNullHandlerActivity {
RecordsetName = "[[Numeric()]]", 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 GetActivityFieldsOffDsfDeleteRecordActivityExpectedAllFindMissingFieldsToBeReturned()
{
var nullHandlerActivity = new DsfDeleteRecordNullHandlerActivity();
nullHandlerActivity.RecordsetName = "[[RecordsetName]]";
nullHandlerActivity.Result = "[[Result]]";
var fac = new Dev2FindMissingStrategyFactory();
var strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
var actual = strategy.GetActivityFields(nullHandlerActivity);
var expected = new List <string> {
"[[RecordsetName]]", "[[Result]]"
};
CollectionAssert.AreEqual(expected, actual);
}
public void DsfDeleteRecordActivity_UpdateForEachInputs_UpdatesNotMatching_DoesNotUpdateRecordsetName()
{
//------------Setup for test--------------------------
const string recordsetName = "[[Numeric()]]";
var act = new DsfDeleteRecordNullHandlerActivity {
RecordsetName = recordsetName, Result = "[[res]]"
};
var tuple1 = new Tuple <string, string>("Test", "Test");
//------------Execute Test---------------------------
act.UpdateForEachInputs(new List <Tuple <string, string> > {
tuple1
});
//------------Assert Results-------------------------
Assert.AreEqual(recordsetName, act.RecordsetName);
}
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();
var recordset = scenarioContext.Get <string>("recordset");
bool treaNullAsZero;
scenarioContext.TryGetValue("treaNullAsZero", out treaNullAsZero);
DsfActivityAbstract <string> delete;
scenarioContext.TryGetValue("activityMode", out delete);
if (delete != null)
{
delete = new DsfDeleteRecordNullHandlerActivity
{
RecordsetName = recordset,
Result = ResultVariable,
TreatNullAsZero = treaNullAsZero
}
}
;
else
{
delete = new DsfDeleteRecordActivity
{
RecordsetName = recordset,
Result = ResultVariable,
};
}
TestStartNode = new FlowStep
{
Action = delete
};
scenarioContext.Add("activity", delete);
}
public void DsfDeleteRecordActivity_UpdateForEachOutputs_MoreThan1Updates_DoesNothing()
{
//------------Setup for test--------------------------
const string result = "[[res]]";
var act = new DsfDeleteRecordNullHandlerActivity {
RecordsetName = "[[Numeric()]]", Result = result
};
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(result, act.Result);
}
public void GivenItContainsDeleteAs(string parentName, string activityName, Table table)
{
var nullHandlerActivity = new DsfDeleteRecordNullHandlerActivity {
DisplayName = activityName
};
foreach (var tableRow in table.Rows)
{
var result = tableRow["result"];
var variable = tableRow["Variable"];
_commonSteps.AddVariableToVariableList(result);
nullHandlerActivity.RecordsetName = variable;
nullHandlerActivity.Result = result;
}
_commonSteps.AddActivityToActivityList(parentName, activityName, nullHandlerActivity);
}
public void Equals_Given_DisplayName_Different_DisplayName_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var activity1 = new DsfDeleteRecordNullHandlerActivity()
{
UniqueID = uniqueId, DisplayName = "A"
};
var activity = new DsfDeleteRecordNullHandlerActivity()
{
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 DsfDeleteRecordNullHandlerActivity()
{
UniqueID = uniqueId
};
var activity1 = new DsfDeleteRecordNullHandlerActivity()
{
UniqueID = uniqueId
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity);
//---------------Execute Test ----------------------
var @equals = activity.Equals(activity1);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}
public void Equals_Given_Same_TreatNullAsZero_IsEqual()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var activity1 = new DsfDeleteRecordNullHandlerActivity()
{
UniqueID = uniqueId, TreatNullAsZero = true
};
var activity = new DsfDeleteRecordNullHandlerActivity()
{
UniqueID = uniqueId, TreatNullAsZero = true
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity1);
//---------------Execute Test ----------------------
var @equals = activity1.Equals(activity);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}