public void DsfCalculateActivity_GetForEachInputs_NullContext_EmptyList()
{
//------------Setup for test--------------------------
var dsfCalculateActivity = new DsfAggregateCalculateActivity();
//------------Execute Test---------------------------
var dsfForEachItems = dsfCalculateActivity.GetForEachInputs();
//------------Assert Results-------------------------
Assert.IsFalse(dsfForEachItems.Any());
}
public void GivenContainsAggregateCalculateWithFormulaInto(string parentName, string activityName, string formula, string resultVariable)
{
_commonSteps.AddVariableToVariableList(resultVariable);
var aggCalculateActivity = new DsfAggregateCalculateActivity {
Expression = formula, Result = resultVariable, DisplayName = activityName
};
_commonSteps.AddActivityToActivityList(parentName, activityName, aggCalculateActivity);
}
private void BuildInternal(bool isAggregate)
{
List <Tuple <string, string> > variableList;
scenarioContext.TryGetValue("variableList", out variableList);
if (variableList == null)
{
variableList = new List <Tuple <string, string> >();
scenarioContext.Add("variableList", variableList);
}
var resultVariable = ResultVariable;
string resVar;
if (scenarioContext.TryGetValue("resVar", out resVar))
{
resultVariable = resVar;
}
variableList.Add(new Tuple <string, string>(resultVariable, ""));
BuildShapeAndTestData();
string formula;
scenarioContext.TryGetValue("formula", out formula);
if (isAggregate)
{
var calculate = new DsfAggregateCalculateActivity
{
Result = resultVariable,
Expression = formula
};
TestStartNode = new FlowStep
{
Action = calculate
};
scenarioContext.Add("activity", calculate);
}
else
{
var calculate = new DsfCalculateActivity
{
Result = resultVariable,
Expression = formula
};
TestStartNode = new FlowStep
{
Action = calculate
};
scenarioContext.Add("activity", calculate);
}
}
public void DsfAggregateCalculateActivity_GetOutputs_Called_ShouldReturnListWithResultValueInIt()
{
//------------Setup for test--------------------------
var act = new DsfAggregateCalculateActivity {
Expression = @"Sum([[scalar]], 10)", Result = "[[result]]"
};
//------------Execute Test---------------------------
var outputs = act.GetOutputs();
//------------Assert Results-------------------------
Assert.AreEqual(1, outputs.Count);
Assert.AreEqual("[[result]]", outputs[0]);
}
public void DsfCalculateActivity_UpdateForEachOutputs_GivenNullUpdates_DoNothing()
{
//------------Setup for test--------------------------
const string expression = "sum([[Numeric(1).num]],[[Numeric(2).num]])";
const string result = "[[res]]";
var act = new DsfAggregateCalculateActivity {
Expression = expression, Result = result
};
//------------Execute Test---------------------------
act.UpdateForEachOutputs(null);
//------------Assert Results-------------------------
Assert.AreEqual(expression, act.Expression);
}
public void UniqueIDDifferent_EmptyAssigns_IsEqual()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var activity = new DsfAggregateCalculateActivity();
var activity1 = new DsfAggregateCalculateActivity();
//---------------Assert Precondition----------------
Assert.IsNotNull(activity);
//---------------Execute Test ----------------------
var @equals = activity.Equals(activity1);
//---------------Test Result -----------------------
Assert.IsFalse(equals);
}
public void DsfCalculateActivity_GetForEachInputs_WhenHasExpression_ReturnsInputList()
{
//------------Setup for test--------------------------
const string expression = "sum([[Numeric(1).num]],[[Numeric(2).num]])";
var act = new DsfAggregateCalculateActivity {
Expression = expression, Result = "[[res]]"
};
//------------Execute Test---------------------------
var dsfForEachItems = act.GetForEachInputs();
//------------Assert Results-------------------------
Assert.AreEqual(1, dsfForEachItems.Count);
Assert.AreEqual(expression, dsfForEachItems[0].Name);
Assert.AreEqual(expression, dsfForEachItems[0].Value);
}
public void DsfCalculateActivity_UpdateForEachOutputs_GivenOneUpdate_UpdatesExpressionToItem2InTuple()
{
//------------Setup for test--------------------------
const string expression = "sum([[Numeric(1).num]],[[Numeric(2).num]])";
const string result = "[[res]]";
var act = new DsfAggregateCalculateActivity {
Expression = expression, 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 DsfCalculateActivity_UpdateForEachOutputs_GivenMoreThanOneUpdates_DoNothing()
{
//------------Setup for test--------------------------
const string expression = "sum([[Numeric(1).num]],[[Numeric(2).num]])";
const string result = "[[res]]";
var act = new DsfAggregateCalculateActivity {
Expression = expression, 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(expression, act.Expression);
}
public void Equals_Given_Different_Object_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var activity = new DsfAggregateCalculateActivity()
{
UniqueID = uniqueId, DisplayName = "A"
};
var activity1 = new DsfAggregateCalculateActivity()
{
UniqueID = uniqueId, DisplayName = "ass"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity);
//---------------Execute Test ----------------------
var @equals = activity.Equals(activity1);
//---------------Test Result -----------------------
Assert.IsFalse(equals);
}
public void Result_Same_Object_IsEqual()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var activity = new DsfAggregateCalculateActivity()
{
UniqueID = uniqueId, Result = "a"
};
var activity1 = new DsfAggregateCalculateActivity()
{
UniqueID = uniqueId, Result = "a"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity);
//---------------Execute Test ----------------------
var @equals = activity.Equals(activity1);
//---------------Test Result -----------------------
Assert.IsTrue(equals);
}
public void Expression_Different_Object_Is_Not_Equal_CaseSensitive()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var activity = new DsfAggregateCalculateActivity()
{
UniqueID = uniqueId, Expression = "AAA"
};
var activity1 = new DsfAggregateCalculateActivity()
{
UniqueID = uniqueId, Expression = "aaa"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity);
//---------------Execute Test ----------------------
var @equals = activity.Equals(activity1);
//---------------Test Result -----------------------
Assert.IsFalse(equals);
}
public void DsfCalculateActivity_GetState_Returns_Inputs_And_Outputs()
{
//------------Setup for test--------------------------
const string expression = "sum([[Numeric(1).num]],[[Numeric(2).num]])";
const string result = "[[res]]";
var act = new DsfAggregateCalculateActivity {
Expression = expression, Result = result
};
var tuple1 = new Tuple <string, string>("[[res]]", "Test");
//------------Execute Test---------------------------
var stateItems = act.GetState();
//------------Assert Results-------------------------
Assert.IsNotNull(stateItems);
Assert.AreEqual(2, stateItems.Count());
Assert.AreEqual("Expression", stateItems.ToList()[0].Name);
Assert.AreEqual(StateVariable.StateType.Input, stateItems.ToList()[0].Type);
Assert.AreEqual(expression, stateItems.ToList()[0].Value);
Assert.AreEqual("Result", stateItems.ToList()[1].Name);
Assert.AreEqual(StateVariable.StateType.Output, stateItems.ToList()[1].Type);
Assert.AreEqual(result, stateItems.ToList()[1].Value);
}
