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 formula;
ScenarioContext.Current.TryGetValue("formula", out formula);
var calculate = new DsfCalculateActivity
{
Result = ResultVariable,
Expression = formula
};
TestStartNode = new FlowStep
{
Action = calculate
};
ScenarioContext.Current.Add("activity", calculate);
}
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 formula;
ScenarioContext.Current.TryGetValue("formula", out formula);
var calculate = new DsfCalculateActivity
{
Result = ResultVariable,
Expression = formula
};
TestStartNode = new FlowStep
{
Action = calculate
};
ScenarioContext.Current.Add("activity", calculate);
}
public void ActivityHelper_WithKeyProperty_SetSwitchKeyProperty_Dev2Switch()
{
var uniqueId = Guid.NewGuid().ToString();
var calcActivity = new DsfCalculateActivity {
UniqueID = uniqueId
};
var flowStep = new FlowStep {
Action = calcActivity
};
//---------------Set up test pack-------------------
using (var viewModel = new SwitchDesignerViewModel(CreateSwitchModelItem(flowStep), "Switch"))
{
var mySwitch = new Dev2Switch
{
SwitchExpression = "[[a]]"
};
var parentNodeProperty = viewModel.ModelItem.Properties["Cases"].Dictionary;
//------------Setup for test--------------------------
var switchCaseFirst = ModelItemUtils.CreateModelItem(parentNodeProperty.First());
var switchCaseLast = ModelItemUtils.CreateModelItem(parentNodeProperty.Last());
ActivityHelper.SetSwitchKeyProperty(mySwitch, switchCaseFirst);
var modelItemFirst = switchCaseFirst.Properties["Value"].Value.Properties["Action"].Value;
var modelItemLast = switchCaseLast.Properties["Value"].Value.Properties["Action"].Value;
Assert.AreEqual(uniqueId, modelItemFirst.Properties["UniqueID"].ComputedValue);
Assert.IsNull(modelItemLast);
}
}
static ModelItem CreateModelItem()
{
var calculateActivity = new DsfCalculateActivity {
DisplayName = "Aggregate Calculate"
};
var modelItem = CreateModelItem(calculateActivity);
return(modelItem);
}
public void FalseArm_Different_Object_Is_Equal()
{
//---------------Set up test pack-------------------
var dsfBaseConvertActivity = new DsfBaseConvertActivity();
var dsfCalculateActivity = new DsfCalculateActivity()
{
NextNodes = new List <IDev2Activity>()
{
dsfBaseConvertActivity
}
};
;
var dsfCaseConvertActivity = new DsfCaseConvertActivity()
{
NextNodes = new List <IDev2Activity>()
{
dsfCalculateActivity
}
};
var trueArms = new List <IDev2Activity>
{
dsfCaseConvertActivity
};
var trueArms1 = new List <IDev2Activity>
{
dsfCalculateActivity,
};
var uniqueId = Guid.NewGuid().ToString();
var decision = new Dev2.Activities.DsfDecision()
{
UniqueID = uniqueId
,
DisplayName = "a"
,
FalseArm = trueArms
};
var decision1 = new Dev2.Activities.DsfDecision()
{
UniqueID = uniqueId
,
DisplayName = "a"
,
FalseArm = trueArms1
};
//---------------Assert Precondition----------------
Assert.IsNotNull(decision);
//---------------Execute Test ----------------------
var equals = decision.Equals(decision1);
//---------------Test Result -----------------------
Assert.IsTrue(equals);
}
public void GivenCalculateWithFormulaInto(string parentName, string activityName, string formula, string resultVariable)
{
_commonSteps.AddVariableToVariableList(resultVariable);
var calculateActivity = new DsfCalculateActivity {
Expression = formula, Result = resultVariable, DisplayName = activityName
};
_commonSteps.AddActivityToActivityList(parentName, activityName, calculateActivity);
}
public void DsfCalculateActivity_GetForEachInputs_NullContext_EmptyList()
{
//------------Setup for test--------------------------
var dsfCalculateActivity = new DsfCalculateActivity();
//------------Execute Test---------------------------
var dsfForEachItems = dsfCalculateActivity.GetForEachInputs();
//------------Assert Results-------------------------
Assert.IsFalse(dsfForEachItems.Any());
}
public void GetActivityFieldsOffDsfCalculateActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfCalculateActivity activity = new DsfCalculateActivity();
activity.Expression = "[[Expression]]";
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> { "[[Expression]]", "[[Result]]" };
CollectionAssert.AreEqual(expected, actual);
}
public void Mode_Different_Object_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var dev2DecisionStack = new Dev2DecisionStack()
{
Mode = Dev2DecisionMode.AND
};
var dev2DecisionStack1 = new Dev2DecisionStack()
{
Mode = Dev2DecisionMode.OR
};
var dsfCaseConvertActivity = new DsfCaseConvertActivity();
var dsfCalculateActivity = new DsfCalculateActivity();
var dsfBaseConvertActivity = new DsfBaseConvertActivity();
var trueArms = new List <IDev2Activity>
{
dsfBaseConvertActivity,
dsfCalculateActivity,
dsfCaseConvertActivity
};
var trueArms1 = new List <IDev2Activity>
{
dsfBaseConvertActivity,
dsfCalculateActivity,
dsfCaseConvertActivity
};
var uniqueId = Guid.NewGuid().ToString();
var decision = new Dev2.Activities.DsfDecision()
{
UniqueID = uniqueId
,
DisplayName = "a",
FalseArm = trueArms,
Conditions = dev2DecisionStack
};
var decision1 = new Dev2.Activities.DsfDecision()
{
UniqueID = uniqueId
,
DisplayName = "a",
FalseArm = trueArms1,
Conditions = dev2DecisionStack1
};
//---------------Assert Precondition----------------
Assert.IsNotNull(decision);
//---------------Execute Test ----------------------
var equals = decision.Equals(decision1);
//---------------Test Result -----------------------
Assert.IsFalse(equals);
}
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 DsfCalculateActivity_GetOutputs_Called_ShouldReturnListWithResultValueInIt()
{
//------------Setup for test--------------------------
var act = new DsfCalculateActivity {
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 DsfCalculateActivity {
Expression = expression, Result = result
};
//------------Execute Test---------------------------
act.UpdateForEachOutputs(null);
//------------Assert Results-------------------------
Assert.AreEqual(expression, act.Expression);
}
public void GetActivityFieldsOffDsfCalculateActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfCalculateActivity activity = new DsfCalculateActivity();
activity.Expression = "[[Expression]]";
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> {
"[[Expression]]", "[[Result]]"
};
CollectionAssert.AreEqual(expected, actual);
}
public void DsfCalculateActivity_GetForEachInputs_WhenHasExpression_ReturnsInputList()
{
//------------Setup for test--------------------------
const string expression = "sum([[Numeric(1).num]],[[Numeric(2).num]])";
var act = new DsfCalculateActivity {
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 UniqueIDDifferent_EmptyAssigns_IsEqual()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var activity = new DsfCalculateActivity();
var activity1 = new DsfCalculateActivity();
//---------------Assert Precondition----------------
Assert.IsNotNull(activity);
//---------------Execute Test ----------------------
var @equals = activity.Equals(activity1);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
public void Dev2FindMissingStrategyFactory_GetActivityFieldsOff_DsfCalculate_Activity_ExpectAllFindMissingFieldsToBeReturned()
{
var activity = new DsfCalculateActivity
{
Expression = "[[Expression]]",
Result = "[[Result]]"
};
var fac = new Dev2FindMissingStrategyFactory();
var strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
var actual = strategy.GetActivityFields(activity);
var expected = new List <string> {
"[[Expression]]", "[[Result]]"
};
CollectionAssert.AreEqual(expected, actual);
}
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 DsfCalculateActivity {
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 DsfCalculateActivity {
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 DsfCalculateActivity_GetState_ReturnsStateVariable()
{
//------------Setup for test--------------------------
var calculateActivity = new DsfCalculateActivity {
Expression = "[[Numeric(1).num]]", Result = "Passed"
};
//------------Execute Test---------------------------
var stateItems = calculateActivity.GetState();
Assert.AreEqual(2, stateItems.Count());
var expectedResults = new[]
{
new StateVariable
{
Name = "Expression",
Type = StateVariable.StateType.Input,
Value = "[[Numeric(1).num]]"
},
new StateVariable
{
Name = "Result",
Type = StateVariable.StateType.Output,
Value = "Passed"
}
};
var iter = calculateActivity.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_Different_Object_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var activity = new DsfCalculateActivity()
{
UniqueID = uniqueId, DisplayName = "A"
};
var activity1 = new DsfCalculateActivity()
{
UniqueID = uniqueId, DisplayName = "ass"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity);
//---------------Execute Test ----------------------
var @equals = activity.Equals(activity1);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
public void Result_Different_Object_Is_Not_Equal_CaseSensitive()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var activity = new DsfCalculateActivity()
{
UniqueID = uniqueId, Result = "AAA"
};
var activity1 = new DsfCalculateActivity()
{
UniqueID = uniqueId, Result = "aaa"
};
//---------------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 DsfCalculateActivity()
{
UniqueID = uniqueId, Result = "a"
};
var activity1 = new DsfCalculateActivity()
{
UniqueID = uniqueId, Result = "a"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity);
//---------------Execute Test ----------------------
var @equals = activity.Equals(activity1);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}
public void SequenceDesignerViewModel_ActivityNames_WhenMoreThan4_Has4NamesLastItemEllipsis()
{
//------------Setup for test--------------------------
var dsfSequenceActivity = new DsfSequenceActivity();
var dsfMultiAssignActivity = new DsfMultiAssignActivity();
dsfSequenceActivity.Activities.Add(dsfMultiAssignActivity);
var dsfFindRecordsMultipleCriteriaActivity = new DsfFindRecordsMultipleCriteriaActivity();
dsfSequenceActivity.Activities.Add(dsfFindRecordsMultipleCriteriaActivity);
var dsfGatherSystemInformationActivity = new DsfGatherSystemInformationActivity();
dsfSequenceActivity.Activities.Add(dsfGatherSystemInformationActivity);
var dsfBaseConvertActivity = new DsfBaseConvertActivity();
dsfSequenceActivity.Activities.Add(dsfBaseConvertActivity);
var dsfCaseConvertActivity = new DsfCaseConvertActivity();
dsfSequenceActivity.Activities.Add(dsfCaseConvertActivity);
var dsfCalculateActivity = new DsfCalculateActivity();
dsfSequenceActivity.Activities.Add(dsfCalculateActivity);
var sequenceDesignerViewModel = new SequenceDesignerViewModel(CreateModelItem(dsfSequenceActivity));
//------------Execute Test---------------------------
var activityNames = sequenceDesignerViewModel.ActivityNames;
//------------Assert Results-------------------------
Assert.AreEqual(5, activityNames.Count);
Assert.AreEqual(dsfMultiAssignActivity.DisplayName, activityNames[0]);
Assert.AreEqual(dsfFindRecordsMultipleCriteriaActivity.DisplayName, activityNames[1]);
Assert.AreEqual(dsfGatherSystemInformationActivity.DisplayName, activityNames[2]);
Assert.AreEqual(dsfBaseConvertActivity.DisplayName, activityNames[3]);
Assert.AreEqual("...", activityNames[4]);
CollectionAssert.DoesNotContain(activityNames, dsfCaseConvertActivity.DisplayName);
CollectionAssert.DoesNotContain(activityNames, dsfCalculateActivity.DisplayName);
}
public void GivenCalculateWithFormulaInto(string parentName, string activityName, string formula, string resultVariable)
{
CommonSteps.AddVariableToVariableList(resultVariable);
DsfCalculateActivity calculateActivity = new DsfCalculateActivity { Expression = formula, Result = resultVariable, DisplayName = activityName };
CommonSteps.AddActivityToActivityList(parentName, activityName, calculateActivity);
}
public void Conditions_Different_Object_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var dev2DecisionStack = new Dev2DecisionStack()
{
TheStack = new List <Dev2Decision>()
{
new Dev2Decision()
{
Cols1 = new List <DataStorage.WarewolfAtom>()
{
DataStorage.WarewolfAtom.NewDataString("a")
}
},
new Dev2Decision()
{
Cols1 = new List <DataStorage.WarewolfAtom>()
{
DataStorage.WarewolfAtom.NewDataString("a")
}
}
},
DisplayText = "a"
,
FalseArmText = "ErrorArm"
,
TrueArmText = "true Arm",
Version = "2",
Mode = Dev2DecisionMode.AND
};
var dev2DecisionStack1 = new Dev2DecisionStack()
{
TheStack = new List <Dev2Decision>()
{
new Dev2Decision()
{
Cols1 = new List <DataStorage.WarewolfAtom>()
{
DataStorage.WarewolfAtom.NewDataString("a")
},
Col2 = "Col1"
},
new Dev2Decision()
{
Cols1 = new List <DataStorage.WarewolfAtom>()
{
DataStorage.WarewolfAtom.NewDataString("a")
}
}
},
DisplayText = "a"
,
FalseArmText = "ErrorArm"
,
TrueArmText = "true Arm",
Version = "2",
Mode = Dev2DecisionMode.AND
};
var dsfCaseConvertActivity = new DsfCaseConvertActivity();
var dsfCalculateActivity = new DsfCalculateActivity();
var dsfBaseConvertActivity = new DsfBaseConvertActivity();
var trueArms = new List <IDev2Activity>
{
dsfBaseConvertActivity,
dsfCalculateActivity,
dsfCaseConvertActivity
};
var trueArms1 = new List <IDev2Activity>
{
dsfBaseConvertActivity,
dsfCalculateActivity,
dsfCaseConvertActivity
};
var uniqueId = Guid.NewGuid().ToString();
var decision = new Dev2.Activities.DsfDecision()
{
UniqueID = uniqueId
,
DisplayName = "a",
FalseArm = trueArms,
Conditions = dev2DecisionStack
};
var decision1 = new Dev2.Activities.DsfDecision()
{
UniqueID = uniqueId
,
DisplayName = "a",
FalseArm = trueArms1,
Conditions = dev2DecisionStack1
};
//---------------Assert Precondition----------------
Assert.IsNotNull(decision);
//---------------Execute Test ----------------------
var equals = decision.Equals(decision1);
//---------------Test Result -----------------------
Assert.IsFalse(equals);
}
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 DsfCalculateActivity { Expression = expression, Result = result };
//------------Execute Test---------------------------
act.UpdateForEachOutputs(null);
//------------Assert Results-------------------------
Assert.AreEqual(expression, act.Expression);
}
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 DsfCalculateActivity { 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 DsfCalculateActivity_UpdateForEachOutputs_GivenOneUpdate_UpdatesExpressionToItem2InTuple()
{
//------------Setup for test--------------------------
const string expression = "sum([[Numeric(1).num]],[[Numeric(2).num]])";
const string result = "[[res]]";
var act = new DsfCalculateActivity { 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_GetForEachInputs_WhenHasExpression_ReturnsInputList()
{
//------------Setup for test--------------------------
const string expression = "sum([[Numeric(1).num]],[[Numeric(2).num]])";
var act = new DsfCalculateActivity { 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 SequenceDesignerViewModel_ActivityNames_WhenMoreThan4_Has4NamesLastItemEllipsis()
{
//------------Setup for test--------------------------
var dsfSequenceActivity = new DsfSequenceActivity();
var dsfMultiAssignActivity = new DsfMultiAssignActivity();
dsfSequenceActivity.Activities.Add(dsfMultiAssignActivity);
var dsfFindRecordsMultipleCriteriaActivity = new DsfFindRecordsMultipleCriteriaActivity();
dsfSequenceActivity.Activities.Add(dsfFindRecordsMultipleCriteriaActivity);
var dsfGatherSystemInformationActivity = new DsfGatherSystemInformationActivity();
dsfSequenceActivity.Activities.Add(dsfGatherSystemInformationActivity);
var dsfBaseConvertActivity = new DsfBaseConvertActivity();
dsfSequenceActivity.Activities.Add(dsfBaseConvertActivity);
var dsfCaseConvertActivity = new DsfCaseConvertActivity();
dsfSequenceActivity.Activities.Add(dsfCaseConvertActivity);
var dsfCalculateActivity = new DsfCalculateActivity();
dsfSequenceActivity.Activities.Add(dsfCalculateActivity);
var sequenceDesignerViewModel = new SequenceDesignerViewModel(CreateModelItem(dsfSequenceActivity));
//------------Execute Test---------------------------
var activityNames = sequenceDesignerViewModel.ActivityNames;
//------------Assert Results-------------------------
Assert.AreEqual(5, activityNames.Count);
Assert.AreEqual(dsfMultiAssignActivity.DisplayName, activityNames[0]);
Assert.AreEqual(dsfFindRecordsMultipleCriteriaActivity.DisplayName, activityNames[1]);
Assert.AreEqual(dsfGatherSystemInformationActivity.DisplayName, activityNames[2]);
Assert.AreEqual(dsfBaseConvertActivity.DisplayName, activityNames[3]);
Assert.AreEqual("...", activityNames[4]);
CollectionAssert.DoesNotContain(activityNames, dsfCaseConvertActivity.DisplayName);
CollectionAssert.DoesNotContain(activityNames, dsfCalculateActivity.DisplayName);
}
public void FlowDecision_GetDifferences_WhenMainDecisionModified_DecisionToolHasConflict()
{
var activityParser = new ActivityParser();
var shellView = new Mock <IShellViewModel>();
var serverMock = new Mock <IServer>();
shellView.Setup(model => model.ActiveServer).Returns(serverMock.Object);
CustomContainer.Register(shellView.Object);
CustomContainer.Register <IActivityParser>(activityParser);
var deicisionId = Guid.NewGuid().ToString();
var bb = new DsfFlowDecisionActivity {
UniqueID = deicisionId
};
var jsonSerializer = new Dev2JsonSerializer();
var dev2DecisionStack = new Dev2DecisionStack
{
TheStack = new List <Dev2Decision>
{
new Dev2Decision
{
Cols1 = new List <DataStorage.WarewolfAtom>
{
DataStorage.WarewolfAtom.NewDataString("a")
}
},
new Dev2Decision
{
Cols1 = new List <DataStorage.WarewolfAtom>
{
DataStorage.WarewolfAtom.NewDataString("a")
}
}
},
DisplayText = "a",
FalseArmText = "ErrorArm",
TrueArmText = "true Arm",
Version = "2",
Mode = Dev2DecisionMode.AND
};
bb.ExpressionText = jsonSerializer.Serialize(dev2DecisionStack);
var bb2 = new DsfFlowDecisionActivity {
UniqueID = deicisionId
};
var dev2DecisionStack2 = new Dev2DecisionStack
{
TheStack = new List <Dev2Decision>
{
new Dev2Decision
{
Cols1 = new List <DataStorage.WarewolfAtom>
{
DataStorage.WarewolfAtom.NewDataString("a")
}
},
new Dev2Decision
{
Cols1 = new List <DataStorage.WarewolfAtom>
{
DataStorage.WarewolfAtom.NewDataString("a")
}
}
},
DisplayText = "changed",
FalseArmText = "false",
TrueArmText = "true",
Version = "2",
Mode = Dev2DecisionMode.AND
};
bb2.ExpressionText = jsonSerializer.Serialize(dev2DecisionStack2);
var assignId = Guid.NewGuid().ToString();
var calcActivity = new DsfCalculateActivity {
UniqueID = assignId
};
var chart = new Flowchart
{
StartNode = new FlowStep
{
Action = calcActivity,
Next = new FlowDecision
{
DisplayName = "DisplayName",
True = new FlowStep {
Action = calcActivity
},
Condition = bb
}
}
};
var otherChart = new Flowchart
{
StartNode = new FlowStep
{
Action = calcActivity,
Next = new FlowDecision
{
DisplayName = "DisplayName",
True = new FlowStep {
Action = calcActivity
},
Condition = bb2
}
}
};
var current = ParserTestHelper.CreateContextualResourceModel(otherChart);
var diff = ParserTestHelper.CreateContextualResourceModel(chart);
var psd = new ServiceDifferenceParser();
var(currentTree, diffTree) = psd.GetDifferences(current, diff);
var currConflicts = currentTree;
var diffConflicts = diffTree;
var count = currConflicts.Count + diffConflicts.Count;
Assert.AreEqual(4, count);
Assert.IsFalse(diffTree.First().IsInConflict);
Assert.IsFalse(currentTree.First().IsInConflict);
Assert.IsFalse(diffTree.Last().IsInConflict);
Assert.IsFalse(currentTree.Last().IsInConflict);
Assert.AreEqual(assignId, diffTree[0].UniqueId);
Assert.AreEqual(assignId, currentTree[0].UniqueId);
//First Node chart
var tupleDifference = diffTree[0];
var tupleCurrent = currentTree[0];
Assert.IsNotNull(tupleDifference);
Assert.IsNotNull(tupleCurrent);
var devActivityDiff = tupleDifference.Activity;
var devActivityCurr = tupleCurrent.Activity;
Assert.IsNotNull(devActivityDiff);
Assert.IsNotNull(devActivityCurr);
Assert.AreEqual(assignId, devActivityCurr.UniqueID);
Assert.AreEqual(assignId, devActivityDiff.UniqueID);
//Decision Node chart
var tupleDifference1 = diffTree[1];
var tupleCurrent1 = currentTree[1];
Assert.IsNotNull(tupleDifference1);
Assert.IsNotNull(tupleCurrent1);
var devActivityDiff1 = tupleDifference1.Activity;
var devActivityCurr1 = tupleCurrent1.Activity;
Assert.IsNotNull(devActivityDiff1);
Assert.IsNotNull(devActivityCurr1);
Assert.IsFalse(devActivityDiff1.Equals(devActivityCurr1));
}
public void DsfCalculateActivity_GetForEachInputs_NullContext_EmptyList()
{
//------------Setup for test--------------------------
var dsfCalculateActivity = new DsfCalculateActivity();
//------------Execute Test---------------------------
var dsfForEachItems = dsfCalculateActivity.GetForEachInputs();
//------------Assert Results-------------------------
Assert.IsFalse(dsfForEachItems.Any());
}
static ModelItem CreateModelItem(DsfCalculateActivity calculateActivity)
{
var modelItem = ModelItemUtils.CreateModelItem(calculateActivity);
return(modelItem);
}
