public void Debug_GivenDataObject_ShouldSetInnerBugOuputs_IncrementsDebugInputs()
{
//---------------Set up test pack-------------------
//string displayName, IDebugDispatcher debugDispatcher, bool isAsync = false
var switchActivity = new DsfFlowSwitchActivity("MyName", new Mock <IDebugDispatcher>().Object, It.IsAny <bool>())
{
UniqueID = Guid.NewGuid().ToString(),
ExpressionText = ""
};
var activity = new DsfSwitch(switchActivity)
{
Result = "[[MyResult]]"
};
var dataObject = new Mock <IDSFDataObject>();
dataObject.Setup(o => o.IsDebugMode()).Returns(true);
var obj = new Warewolf.Testing.PrivateObject(activity);
//---------------Assert Precondition----------------
var getDebugInputs = activity.GetDebugInputs(new Mock <IExecutionEnvironment>().Object, 1);
Assert.AreEqual(0, getDebugInputs.Count);
//---------------Execute Test ----------------------
var result = "[[variable]]";
var mySwitch = new Dev2Switch();
obj.Invoke("Debug", dataObject.Object, result, mySwitch);
//---------------Test Result -----------------------
getDebugInputs = activity.GetDebugInputs(new Mock <IExecutionEnvironment>().Object, 1);
Assert.AreEqual(1, getDebugInputs.Count);
}
public void ExecuteTool_GivenIsNotDebugMode_NotAddDebugOutputs()
{
//---------------Set up test pack-------------------
//string displayName, IDebugDispatcher debugDispatcher, bool isAsync = false
var switchActivity = new DsfFlowSwitchActivity("MyName", new Mock <IDebugDispatcher>().Object, It.IsAny <bool>())
{
UniqueID = Guid.NewGuid().ToString(),
ExpressionText = ""
};
var nextActivity = new Mock <IDev2Activity>();
var activity = new DsfSwitchMock(switchActivity)
{
Result = "[[MyResult]]",
Switch = "[[Switch]]",
Switches = new Dictionary <string, IDev2Activity>()
};
activity.Switches.Add("1", nextActivity.Object);
var dataObject = new Mock <IDSFDataObject>();
dataObject.Setup(o => o.IsDebugMode()).Returns(false);
var executionEnvironment = new ExecutionEnvironment();
executionEnvironment.Assign("[[Switch]]", "1", 1);
dataObject.Setup(o => o.Environment).Returns(executionEnvironment);
//---------------Assert Precondition----------------
var getDebugInputs = activity.GetDebugInputs(new Mock <IExecutionEnvironment>().Object, 1);
Assert.AreEqual(0, getDebugInputs.Count);
//---------------Execute Test ----------------------
activity.ExecuteMock(dataObject.Object, 0);
//---------------Test Result -----------------------
getDebugInputs = activity.GetDebugInputs(new Mock <IExecutionEnvironment>().Object, 1);
Assert.AreEqual(0, getDebugInputs.Count);
}
public void DebugOutput_GivenDataObject_ShouldSetInnerBugOuputsIncrementsDebugOutputs()
{
//---------------Set up test pack-------------------
//string displayName, IDebugDispatcher debugDispatcher, bool isAsync = false
var switchActivity = new DsfFlowSwitchActivity("MyName", new Mock <IDebugDispatcher>().Object, It.IsAny <bool>())
{
UniqueID = Guid.NewGuid().ToString()
};
var activity = new DsfSwitch(switchActivity)
{
Result = "[[MyResult]]"
};
var dataObject = new Mock <IDSFDataObject>();
dataObject.Setup(o => o.IsDebugMode()).Returns(true);
var obj = new PrivateObject(activity);
//---------------Assert Precondition----------------
var activityDebugOutputs = activity.GetDebugOutputs(new Mock <IExecutionEnvironment>().Object, 1);
Assert.AreEqual(0, activityDebugOutputs.Count);
//---------------Execute Test ----------------------
obj.Invoke("DebugOutput", dataObject.Object);
//---------------Test Result -----------------------
activityDebugOutputs = activity.GetDebugOutputs(new Mock <IExecutionEnvironment>().Object, 1);
Assert.AreEqual(1, activityDebugOutputs.Count);
}
protected override void BuildDataList()
{
var variableList = scenarioContext.Get <List <Tuple <string, string> > >("variableList");
variableList.Add(new Tuple <string, string>(ResultVariable, ""));
BuildShapeAndTestData();
var flowSwitch = new DsfFlowSwitchActivity
{
ExpressionText =
string.Format(
"Dev2.Data.Decision.Dev2DataListDecisionHandler.Instance.FetchSwitchData(\"{0}\",AmbientDataList)",
variableList.First().Item1),
};
var sw = new FlowSwitch <string>();
sw.Expression = flowSwitch;
var multiAssign = new DsfMultiAssignActivity();
int row = 1;
foreach (var variable in variableList)
{
multiAssign.FieldsCollection.Add(new ActivityDTO(variable.Item1, variable.Item2, row, true));
row++;
}
TestStartNode = new FlowStep
{
Action = multiAssign,
Next = sw
};
scenarioContext.Add("activity", flowSwitch);
}
public void Equals_Given_DifferentInner_SwitchActivity_IsEqual()
{
//---------------Set up test pack-------------------
var uniqId = Guid.NewGuid().ToString();
var inner = new DsfFlowSwitchActivity
{
UniqueID = Guid.NewGuid().ToString(),
ExpressionText = "A",
DisplayName = "A"
};
var inner2 = new DsfFlowSwitchActivity
{
UniqueID = Guid.NewGuid().ToString(),
ExpressionText = "B",
DisplayName = "B"
};
var activity = new DsfSwitch {
UniqueID = uniqId, Inner = inner
};
var activity1 = new DsfSwitch {
UniqueID = uniqId, Inner = inner2
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity);
//---------------Execute Test ----------------------
var @equals = activity.Equals(activity1);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}
protected override void BuildDataList()
{
var variableList = ScenarioContext.Current.Get<List<Tuple<string, string>>>("variableList");
variableList.Add(new Tuple<string, string>(ResultVariable, ""));
BuildShapeAndTestData();
var flowSwitch = new DsfFlowSwitchActivity
{
ExpressionText =
string.Format(
"Dev2.Data.Decision.Dev2DataListDecisionHandler.Instance.FetchSwitchData(\"{0}\",AmbientDataList)",
variableList.First().Item1),
};
var sw = new FlowSwitch<string>();
sw.Expression = flowSwitch;
var multiAssign = new DsfMultiAssignActivity();
int row = 1;
foreach(var variable in variableList)
{
multiAssign.FieldsCollection.Add(new ActivityDTO(variable.Item1, variable.Item2, row, true));
row++;
}
TestStartNode = new FlowStep
{
Action = multiAssign,
Next = sw
};
ScenarioContext.Current.Add("activity", flowSwitch);
}
public void ActivityHelper_Dev2Switch_ExtractData_Null()
{
var inner2 = new DsfFlowSwitchActivity
{
ExpressionText = GlobalConstants.InjectedSwitchDataFetch
};
var val = ActivityHelper.ExtractData(inner2.ExpressionText);
Assert.AreEqual("Dev2.Data.Decision.Dev2DataListDecisionHandler.Instance.FetchSwitchData", val);
}
public void DsfFlowSwitchActivity_GetState_ReturnsStateVariable()
{
//---------------Set up test pack-------------------
//------------Setup for test--------------------------
var act = new DsfFlowSwitchActivity();
//------------Execute Test---------------------------
var stateItems = act.GetState();
//------------Assert Results-------------------------
Assert.AreEqual(0, stateItems.Count());
}
public void ConflictModelFactory_GivenDsfSwitchConflictNode_ShouldReturnMergeToolModel()
{
//------------Setup for test--------------------------
var adapter = new Mock <IApplicationAdaptor>();
adapter.Setup(p => p.TryFindResource(It.IsAny <object>())).Returns(new object());
CustomContainer.Register(adapter.Object);
var node = new Mock <IConflictTreeNode>();
var contextualResource = new Mock <IContextualResourceModel>();
var dev2DecisionStack = new Dev2DecisionStack
{
TheStack = new List <Dev2Decision>(),
TrueArmText = "a",
FalseArmText = "a",
DisplayText = "a",
Mode = Dev2DecisionMode.AND
};
var serializer = new Dev2JsonSerializer();
var serialize = serializer.Serialize(dev2DecisionStack);
var condition = new DsfFlowSwitchActivity
{
ExpressionText = serialize
};
var value = new DsfSwitch(condition)
{
Switch = "bbb",
Switches = new Dictionary <string, IDev2Activity>
{
{ "a", new DsfCalculateActivity() },
{ "b", new DsfCalculateActivity() }
}
};
var assignStep = new FlowStep
{
Action = value
};
node.Setup(p => p.Activity).Returns(value);
var toolConflictItem = new ToolConflictItem(new ViewModels.Merge.Utils.ConflictRowList(new Mock <IConflictModelFactory>().Object, new Mock <IConflictModelFactory>().Object, new List <ConflictTreeNode>(), new List <ConflictTreeNode>()), ViewModels.Merge.Utils.ConflictRowList.Column.Current);
//------------Execute Test---------------------------
var completeConflict = new ConflictModelFactory(toolConflictItem, contextualResource.Object, node.Object);
//------------Assert Results-------------------------
Assert.IsNotNull(completeConflict);
var mergeToolModel = completeConflict.CreateModelItem(toolConflictItem, node.Object);
Assert.AreEqual("bbb", mergeToolModel.MergeDescription);
Assert.AreEqual(typeof(SwitchDesignerViewModel).FullName, ((ToolConflictItem)mergeToolModel).ActivityDesignerViewModel.GetType().FullName);
}
public void GetDebugOutputs_GivenIsNewReturnsZero()
{
//---------------Set up test pack-------------------
//string displayName, IDebugDispatcher debugDispatcher, bool isAsync = false
var switchActivity = new DsfFlowSwitchActivity("MyName", new Mock <IDebugDispatcher>().Object, It.IsAny <bool>())
{
UniqueID = Guid.NewGuid().ToString()
};
var activity = new DsfSwitch(switchActivity);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var customAttributes = activity.GetDebugOutputs(new Mock <IExecutionEnvironment>().Object, 1);
//---------------Test Result -----------------------
Assert.AreEqual(0, customAttributes.Count);
}
static ModelItem CreateSwitchModelItem(FlowStep flowStep)
{
var dsfSwitch = new FlowSwitch <string>();
var uniqueId = Guid.NewGuid();
var activity = new DsfFlowSwitchActivity {
UniqueID = uniqueId.ToString()
};
dsfSwitch.Expression = activity;
dsfSwitch.Cases.Add("Case1", flowStep);
dsfSwitch.Cases.Add("Case2", new FlowStep());
dsfSwitch.Default = new FlowStep();
var modelItem = ModelItemUtils.CreateModelItem(dsfSwitch);
return(modelItem);
}
public void WorkflowHelperCompileExpressionsWithActivityExpectedCompilesExpressionsAddsToCacheThenInvalidate()
{
const string ExpressionParams = "(\"\",AmbientDataList)";
var fsa = new DsfFlowSwitchActivity
{
ExpressionText = GlobalConstants.InjectedSwitchDataFetchOld + ExpressionParams
};
var fda = new DsfFlowDecisionActivity
{
ExpressionText = GlobalConstants.InjectedDecisionHandlerOld + ExpressionParams
};
var startNode = new FlowStep {
Action = new CommentActivityForTest()
};
var chart = new Flowchart {
StartNode = startNode
};
chart.Nodes.Add(startNode);
chart.Nodes.Add(new FlowDecision(fda));
chart.Nodes.Add(new FlowSwitch <string> {
Expression = fsa
});
var workflow = new DynamicActivity
{
Implementation = () => chart
};
var guid = Guid.NewGuid();
new WorkflowHelper().CompileExpressions(workflow, guid);
// No exception thrown means compilation worked
var compiledExpressionRoot = CompiledExpressionInvoker.GetCompiledExpressionRootForImplementation(workflow) as ICompiledExpressionRoot;
Assert.AreEqual(GlobalConstants.Resultscache.Count, 1);
GlobalConstants.InvalidateCache(guid);
Assert.AreEqual(GlobalConstants.Resultscache.Count, 0);
Assert.IsNotNull(compiledExpressionRoot);
}
public void ExecuteTool_GivenSwicthNotMacthing_ShouldUseDefault()
{
//---------------Set up test pack-------------------
//string displayName, IDebugDispatcher debugDispatcher, bool isAsync = false
var switchActivity = new DsfFlowSwitchActivity("MyName", new Mock <IDebugDispatcher>().Object, It.IsAny <bool>())
{
UniqueID = Guid.NewGuid().ToString(),
ExpressionText = ""
};
var nextActivity = new Mock <IDev2Activity>();
var activity = new DsfSwitchMock(switchActivity)
{
Result = "[[MyResult]]",
Switch = "[[Switch]]",
Switches = new Dictionary <string, IDev2Activity>(),
Default = new List <IDev2Activity> {
nextActivity.Object
}
};
var dataObject = new Mock <IDSFDataObject>();
dataObject.Setup(o => o.IsDebugMode()).Returns(false);
var executionEnvironment = new ExecutionEnvironment();
executionEnvironment.Assign("[[Switch]]", "NoMatch", 1);
dataObject.Setup(o => o.Environment).Returns(executionEnvironment);
//---------------Assert Precondition----------------
var getDebugInputs = activity.GetDebugInputs(new Mock <IExecutionEnvironment>().Object, 1);
Assert.AreEqual(0, getDebugInputs.Count);
Assert.IsNull(activity.NextNodes);
//---------------Execute Test ----------------------
activity.ExecuteMock(dataObject.Object, 0);
//---------------Test Result -----------------------
getDebugInputs = activity.GetDebugInputs(new Mock <IExecutionEnvironment>().Object, 1);
Assert.AreEqual(0, getDebugInputs.Count);
Assert.IsNotNull(activity.NextNodes);
Assert.AreEqual(1, activity.NextNodes.Count());
var contains = activity.NextNodes.Single();
Assert.AreEqual(nextActivity.Object, contains);
Assert.AreEqual("Default", activity.Result);
}
public void GetForEachInputs_ReturnsNull()
{
//---------------Set up test pack-------------------
//string displayName, IDebugDispatcher debugDispatcher, bool isAsync = false
var switchActivity = new DsfFlowSwitchActivity("MyName", new Mock <IDebugDispatcher>().Object, It.IsAny <bool>())
{
UniqueID = Guid.NewGuid().ToString()
};
var activity = new DsfSwitch(switchActivity);
//---------------Assert Precondition----------------
var outputs = activity.GetOutputs();
Assert.AreEqual(0, outputs.Count);
//---------------Execute Test ----------------------
var dsfForEachItems = activity.GetForEachInputs();
//---------------Test Result -----------------------
Assert.IsNull(dsfForEachItems);
}
public void WorkflowHelperCompileExpressionsWithActivityExpectedFixesExpressions()
{
const string ExpressionParams = "(\"\",AmbientDataList)";
var fsa = new DsfFlowSwitchActivity
{
ExpressionText = GlobalConstants.InjectedSwitchDataFetchOld + ExpressionParams
};
var fda = new DsfFlowDecisionActivity
{
ExpressionText = GlobalConstants.InjectedDecisionHandlerOld + ExpressionParams
};
var fdv = new VisualBasicValue <Boolean>(GlobalConstants.InjectedDecisionHandlerOld + ExpressionParams);
var fsv = new VisualBasicValue <string>(GlobalConstants.InjectedSwitchDataFetchOld + ExpressionParams);
var startNode = new FlowStep {
Action = new CommentActivityForTest()
};
var chart = new Flowchart {
StartNode = startNode
};
chart.Nodes.Add(startNode);
chart.Nodes.Add(new FlowDecision(fda));
chart.Nodes.Add(new FlowSwitch <string> {
Expression = fsa
});
chart.Nodes.Add(new FlowDecision(fdv));
chart.Nodes.Add(new FlowSwitch <string> {
Expression = fsv
});
var workflow = new DynamicActivity
{
Implementation = () => chart
};
new WorkflowHelper().CompileExpressions(workflow);
Assert.AreEqual(GlobalConstants.InjectedSwitchDataFetch + ExpressionParams, fsa.ExpressionText);
Assert.AreEqual(GlobalConstants.InjectedDecisionHandler + ExpressionParams, fda.ExpressionText);
}
protected override void BuildDataList()
{
var variableList = ScenarioContext.Current.Get <List <Tuple <string, string> > >("variableList");
variableList.Add(new Tuple <string, string>(ResultVariable, ""));
BuildShapeAndTestData();
var flowSwitch = new DsfFlowSwitchActivity
{
ExpressionText =
string.Format(
"Dev2.Data.Decision.Dev2DataListDecisionHandler.Instance.FetchSwitchData(\"{0}\",AmbientDataList)",
(variableList).First().Item1)
};
TestStartNode = new FlowStep
{
Action = flowSwitch
};
ScenarioContext.Current.Add("activity", flowSwitch);
}
public void ExecuteTool_GivenDefaultIsNull_ShouldShowError()
{
//---------------Set up test pack-------------------
//string displayName, IDebugDispatcher debugDispatcher, bool isAsync = false
var switchActivity = new DsfFlowSwitchActivity("MyName", new Mock <IDebugDispatcher>().Object, It.IsAny <bool>())
{
UniqueID = Guid.NewGuid().ToString(),
ExpressionText = ""
};
var nextActivity = new Mock <IDev2Activity>();
var activity = new DsfSwitchMock(switchActivity)
{
Result = "[[MyResult]]",
Switch = "[[Switch]]",
Switches = new Dictionary <string, IDev2Activity>(),
Default = null
};
var dataObject = new Mock <IDSFDataObject>();
dataObject.Setup(o => o.IsDebugMode()).Returns(true);
var executionEnvironment = new ExecutionEnvironment();
executionEnvironment.Assign("[[Switch]]", "NoMatch", 1);
dataObject.Setup(o => o.Environment).Returns(executionEnvironment);
//---------------Assert Precondition----------------
var getDebugInputs = activity.GetDebugInputs(new Mock <IExecutionEnvironment>().Object, 1);
Assert.AreEqual(0, getDebugInputs.Count);
Assert.IsNull(activity.NextNodes);
//---------------Execute Test ----------------------
activity.ExecuteMock(dataObject.Object, 0);
//---------------Test Result -----------------------
getDebugInputs = activity.GetDebugInputs(new Mock <IExecutionEnvironment>().Object, 1);
Assert.AreEqual(1, getDebugInputs.Count);
Assert.IsNotNull(activity.NextNodes);
Assert.AreEqual(0, activity.NextNodes.Count());
Assert.AreEqual(1, executionEnvironment.AllErrors.Count);
Assert.AreEqual("Failed: Switch must have a Default arm connected.", executionEnvironment.AllErrors.First());
}
public void Constructor_GivenIsNew_ShouldHaveCorrectValues()
{
//---------------Set up test pack-------------------
//string displayName, IDebugDispatcher debugDispatcher, bool isAsync = false
var switchActivity = new DsfFlowSwitchActivity("MyName", new Mock <IDebugDispatcher>().Object, It.IsAny <bool>())
{
UniqueID = Guid.NewGuid().ToString()
};
var activity = new DsfSwitch(switchActivity);
//---------------Assert Precondition----------------
Assert.IsNotNull(activity);
//---------------Execute Test ----------------------
//---------------Test Result -----------------------
Assert.AreEqual("Switch", activity.DisplayName);
Assert.AreSame(switchActivity, activity.Inner);
Assert.AreSame(switchActivity.UniqueID, activity.UniqueID);
Assert.IsNull(activity.Switches);
Assert.IsNull(activity.Default);
Assert.IsNull(activity.Switch);
Assert.IsNull(activity.Result);
}
public void SwitchDesignerViewModel_Switch_Dev2Switch()
{
//------------Setup for test--------------------------
#region setup first Mock ModelItem
var popupController = new Mock <IPopupController>();
CustomContainer.Register(popupController.Object);
var env = EnviromentRepositoryTest.CreateMockEnvironment();
var properties = new Dictionary <string, Mock <ModelProperty> >();
var propertyCollection = new Mock <ModelPropertyCollection>();
var testAct = new DsfFlowSwitchActivity {
ExpressionText = "Not Null Test Value"
};
var prop = new Mock <ModelProperty>();
prop.Setup(p => p.ComputedValue).Returns(testAct);
properties.Add("Condition", prop);
propertyCollection.Protected().Setup <ModelProperty>("Find", "Condition", true).Returns(prop.Object);
var mockModelItem = new Mock <ModelItem>();
mockModelItem.Setup(s => s.Properties).Returns(propertyCollection.Object);
#endregion
#region setup decision Mock ModelItem
var crmDecision = new Mock <IContextualResourceModel>();
crmDecision.Setup(r => r.Environment).Returns(env.Object);
crmDecision.Setup(r => r.ResourceName).Returns("Test");
crmDecision.Setup(res => res.WorkflowXaml).Returns(new StringBuilder(StringResourcesTest.xmlServiceDefinition));
var decisionProperties = new Dictionary <string, Mock <ModelProperty> >();
var decisionPropertyCollection = new Mock <ModelPropertyCollection>();
var decisionProp = new Mock <ModelProperty>();
decisionProp.Setup(p => p.ComputedValue).Returns(string.Empty);
decisionProperties.Add("Condition", decisionProp);
decisionPropertyCollection.Protected().Setup <ModelProperty>("Find", "Condition", true).Returns(decisionProp.Object);
var decisionModelItem = new Mock <ModelItem>();
decisionModelItem.Setup(s => s.Properties).Returns(decisionPropertyCollection.Object);
decisionModelItem.Setup(s => s.ItemType).Returns(typeof(FlowSwitch <string>));
prop.Setup(p => p.Value).Returns(decisionModelItem.Object);
#endregion
#region setup Environment Model
env.Setup(c => c.Connection).Returns(new Mock <IEnvironmentConnection>().Object);
#endregion
var switchDesigner = new SwitchDesignerViewModel(mockModelItem.Object, "TrueArm");
//------------Execute Test---------------------------
var dev2Switch = switchDesigner.Switch;
//------------Assert Results-------------------------
Assert.AreEqual("TrueArm", dev2Switch.DisplayText);
Assert.AreEqual("", dev2Switch.SwitchVariable);
Assert.IsNull(dev2Switch.SwitchExpression);
}
// ReSharper disable InconsistentNaming
public void FlowController_HandleConfigureSwitchExpressionMessageAndIsNewTrue()
// ReSharper restore InconsistentNaming
{
#region setup first Mock ModelItem
var env = EnviromentRepositoryTest.CreateMockEnvironment();
var crm = new Mock<IContextualResourceModel>();
crm.Setup(r => r.Environment).Returns(env.Object);
crm.Setup(r => r.ResourceName).Returns("Test");
crm.Setup(res => res.WorkflowXaml).Returns(new StringBuilder(StringResourcesTest.xmlServiceDefinition));
var properties = new Dictionary<string, Mock<ModelProperty>>();
var propertyCollection = new Mock<ModelPropertyCollection>();
var testAct = new DsfFlowSwitchActivity { ExpressionText = "Not Null Test Value" };
var prop = new Mock<ModelProperty>();
prop.Setup(p => p.ComputedValue).Returns(testAct);
properties.Add("Expression", prop);
propertyCollection.Protected().Setup<ModelProperty>("Find", "Expression", true).Returns(prop.Object);
var source = new Mock<ModelItem>();
source.Setup(s => s.Properties).Returns(propertyCollection.Object);
var returnModelItem = new Mock<ModelItem>();
returnModelItem.Setup(item => item.GetCurrentValue()).Returns("[[Var1]]");
returnModelItem.Setup(item => item.ToString()).Returns("[[Var1]]");
#endregion
#region setup switch Mock ModelItem
var decisionProperties = new Dictionary<string, Mock<ModelProperty>>();
var decisionPropertyCollection = new Mock<ModelPropertyCollection>();
var decisionProp = new Mock<ModelProperty>();
decisionProp.Setup(p => p.ComputedValue).Returns("[[Var]]");
decisionProp.Setup(p => p.Value).Returns(returnModelItem.Object);
decisionProperties.Add("ExpressionText", decisionProp);
decisionPropertyCollection.Protected().Setup<ModelProperty>("Find", "ExpressionText", true).Returns(decisionProp.Object);
var decisionModelItem = new Mock<ModelItem>();
decisionModelItem.Setup(s => s.Properties).Returns(decisionPropertyCollection.Object);
prop.Setup(p => p.Value).Returns(decisionModelItem.Object);
#endregion
#region setup Environment Model
env.Setup(c => c.Connection).Returns(new Mock<IEnvironmentConnection>().Object);
#endregion
#region setup Start Decision Wizard
var flowController = new Mock<FlowController>(new Mock<IPopupController>().Object);
flowController.Protected().Setup("StartSwitchDropWizard", ItExpr.IsAny<IEnvironmentModel>(), ItExpr.IsAny<string>()).Verifiable();
#endregion
flowController.Object.Handle(new ConfigureSwitchExpressionMessage { ModelItem = source.Object, EnvironmentModel = env.Object, IsNew = false });
flowController.Protected().Verify("StartSwitchDropWizard", Times.Once(), ItExpr.IsAny<IEnvironmentModel>(), ItExpr.IsAny<string>());
}
public void WorkflowHelperCompileExpressionsWithActivityExpectedCompilesExpressionsAddsToCacheThenInvalidate()
{
const string ExpressionParams = "(\"\",AmbientDataList)";
var fsa = new DsfFlowSwitchActivity
{
ExpressionText = GlobalConstants.InjectedSwitchDataFetchOld + ExpressionParams
};
var fda = new DsfFlowDecisionActivity
{
ExpressionText = GlobalConstants.InjectedDecisionHandlerOld + ExpressionParams
};
var startNode = new FlowStep { Action = new CommentActivityForTest() };
var chart = new Flowchart { StartNode = startNode };
chart.Nodes.Add(startNode);
chart.Nodes.Add(new FlowDecision(fda));
chart.Nodes.Add(new FlowSwitch<string> { Expression = fsa });
var workflow = new DynamicActivity
{
Implementation = () => chart
};
var guid = Guid.NewGuid();
new WorkflowHelper().CompileExpressions(workflow, guid);
// No exception thrown means compilation worked
var compiledExpressionRoot = CompiledExpressionInvoker.GetCompiledExpressionRootForImplementation(workflow) as ICompiledExpressionRoot;
Assert.AreEqual(GlobalConstants.Resultscache.Count, 1);
GlobalConstants.InvalidateCache(guid);
Assert.AreEqual(GlobalConstants.Resultscache.Count, 0);
Assert.IsNotNull(compiledExpressionRoot);
}
#pragma warning restore S2357 // Fields should be private
#pragma warning restore IDE1006 // Naming Styles
public DsfSwitch(DsfFlowSwitchActivity inner)
: base("Switch")
{
Inner = inner;
UniqueID = inner.UniqueID;
}
public void FlowController_ConfigureSwitch_Handle_Switch()
{
//------------Setup for test--------------------------
var popupController = new Mock <IPopupController>();
CustomContainer.Register(popupController.Object);
var env = EnviromentRepositoryTest.CreateMockEnvironment();
var properties = new Dictionary <string, Mock <ModelProperty> >();
var propertyCollection = new Mock <ModelPropertyCollection>();
var testAct = new DsfFlowSwitchActivity {
ExpressionText = ""
};
var prop = new Mock <ModelProperty>();
prop.Setup(p => p.ComputedValue).Returns(testAct);
properties.Add("Expression", prop);
propertyCollection.Protected().Setup <ModelProperty>("Find", "Expression", true).Returns(prop.Object);
var source = new Mock <ModelItem>();
source.Setup(s => s.Properties).Returns(propertyCollection.Object);
#region setup decision Mock ModelItem
var crmSwitch = new Mock <IContextualResourceModel>();
crmSwitch.Setup(r => r.Environment).Returns(env.Object);
crmSwitch.Setup(r => r.ResourceName).Returns("Test");
crmSwitch.Setup(res => res.WorkflowXaml).Returns(new StringBuilder(StringResourcesTest.xmlServiceDefinition));
var switchProperties = new Dictionary <string, Mock <ModelProperty> >();
var switchPropertyCollection = new Mock <ModelPropertyCollection>();
var switchProp = new Mock <ModelProperty>();
switchProp.Setup(p => p.ComputedValue).Returns(string.Empty);
switchProperties.Add("Expression", switchProp);
switchPropertyCollection.Protected().Setup <ModelProperty>("Find", "Expression", true).Returns(switchProp.Object);
var switchModelItem = new Mock <ModelItem>();
switchModelItem.Setup(s => s.Properties).Returns(switchPropertyCollection.Object);
switchModelItem.Setup(s => s.ItemType).Returns(typeof(FlowSwitch <string>));
prop.Setup(p => p.Value).Returns(switchModelItem.Object);
#endregion
#region setup Environment Model
env.Setup(c => c.Connection).Returns(new Mock <IEnvironmentConnection>().Object);
#endregion
var flowController = new FlowController();
var message = new ConfigureSwitchExpressionMessage
{
ModelItem = source.Object,
Server = env.Object,
IsNew = true
};
//------------Execute Test---------------------------
flowController.Handle(message);
//------------Assert Results-------------------------
}
public void ActivityHelper_InjectExpression_Dev2DecisionStack()
{
//---------------Set up test pack-------------------
var dev2DecisionStack = new Dev2DecisionStack()
{
DisplayText = "",
FalseArmText = "",
TrueArmText = "",
Version = "2",
Mode = Dev2DecisionMode.AND
};
dev2DecisionStack.TheStack = new List <Dev2Decision>();
var testAct = new DsfFlowSwitchActivity {
ExpressionText = ""
};
var prop = new Mock <ModelProperty>();
prop.Setup(p => p.ComputedValue).Returns(testAct);
ActivityHelper.InjectExpression(dev2DecisionStack, prop.Object);
//------------Assert Results-------------------------
var act = new DsfDecision {
Conditions = dev2DecisionStack, And = true
};
var stateItems = act.GetState();
Assert.AreEqual(5, stateItems.Count());
var serializer = new Dev2JsonSerializer();
var expectedResults = new[]
{
new StateVariable
{
Name = "Conditions",
Type = StateVariable.StateType.Input,
Value = serializer.Serialize(dev2DecisionStack)
},
new StateVariable
{
Name = "And",
Type = StateVariable.StateType.Input,
Value = "True"
},
new StateVariable
{
Name = "Result",
Type = StateVariable.StateType.Output,
Value = null
},
new StateVariable
{
Name = "TrueArm",
Type = StateVariable.StateType.Output,
Value = ActivityHelper.GetSerializedStateValueFromCollection(act.TrueArm?.ToList())
},
new StateVariable
{
Name = "FalseArm",
Type = StateVariable.StateType.Output,
Value = ActivityHelper.GetSerializedStateValueFromCollection(act.FalseArm?.ToList())
}
};
var iter = act.GetState().Select((item, index) => new
{
value = item,
expectValue = expectedResults[index]
});
Assert.AreEqual(expectedResults.Length, iter.Count());
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 DsfSwitchMock(DsfFlowSwitchActivity activity)
: base(activity)
{
}
public DsfSwitch(DsfFlowSwitchActivity inner)
{
_inner = inner;
}
// ReSharper disable InconsistentNaming
public void FlowController_HandleConfigureSwitchExpressionMessageAndIsNewTrue()
// ReSharper restore InconsistentNaming
{
#region setup first Mock ModelItem
var env = EnviromentRepositoryTest.CreateMockEnvironment();
var crm = new Mock <IContextualResourceModel>();
crm.Setup(r => r.Environment).Returns(env.Object);
crm.Setup(r => r.ResourceName).Returns("Test");
crm.Setup(res => res.WorkflowXaml).Returns(new StringBuilder(StringResourcesTest.xmlServiceDefinition));
var properties = new Dictionary <string, Mock <ModelProperty> >();
var propertyCollection = new Mock <ModelPropertyCollection>();
var testAct = new DsfFlowSwitchActivity {
ExpressionText = "Not Null Test Value"
};
var prop = new Mock <ModelProperty>();
prop.Setup(p => p.ComputedValue).Returns(testAct);
properties.Add("Expression", prop);
propertyCollection.Protected().Setup <ModelProperty>("Find", "Expression", true).Returns(prop.Object);
var source = new Mock <ModelItem>();
source.Setup(s => s.Properties).Returns(propertyCollection.Object);
var returnModelItem = new Mock <ModelItem>();
returnModelItem.Setup(item => item.GetCurrentValue()).Returns("[[Var1]]");
returnModelItem.Setup(item => item.ToString()).Returns("[[Var1]]");
#endregion
#region setup switch Mock ModelItem
var decisionProperties = new Dictionary <string, Mock <ModelProperty> >();
var decisionPropertyCollection = new Mock <ModelPropertyCollection>();
var decisionProp = new Mock <ModelProperty>();
decisionProp.Setup(p => p.ComputedValue).Returns("[[Var]]");
decisionProp.Setup(p => p.Value).Returns(returnModelItem.Object);
decisionProperties.Add("ExpressionText", decisionProp);
decisionPropertyCollection.Protected().Setup <ModelProperty>("Find", "ExpressionText", true).Returns(decisionProp.Object);
var decisionModelItem = new Mock <ModelItem>();
decisionModelItem.Setup(s => s.Properties).Returns(decisionPropertyCollection.Object);
prop.Setup(p => p.Value).Returns(decisionModelItem.Object);
#endregion
#region setup Environment Model
env.Setup(c => c.Connection).Returns(new Mock <IEnvironmentConnection>().Object);
#endregion
#region setup Start Decision Wizard
var flowController = new Mock <FlowController>(new Mock <IPopupController>().Object);
flowController.Protected().Setup("StartSwitchDropWizard", ItExpr.IsAny <IEnvironmentModel>(), ItExpr.IsAny <string>()).Verifiable();
#endregion
flowController.Object.Handle(new ConfigureSwitchExpressionMessage {
ModelItem = source.Object, EnvironmentModel = env.Object, IsNew = false
});
flowController.Protected().Verify("StartSwitchDropWizard", Times.Once(), ItExpr.IsAny <IEnvironmentModel>(), ItExpr.IsAny <string>());
}
public void AddItem(IToolConflictItem model)
{
var service = _workflowDesignerHelper.GetService <ModelService>(_wd);
var root = service.Root;
var chart = _workflowDesignerHelper.GetService <ModelService>(_wd).Find(root, typeof(Flowchart)).FirstOrDefault();
var nodes = chart?.Properties["Nodes"]?.Collection;
if (nodes == null)
{
return;
}
var nodeToAdd = model.ModelItem;
var step = model.FlowNode;
switch (step)
{
case FlowStep normalStep:
normalStep.Next = null;
if (!nodes.Contains(normalStep))
{
nodes.Add(normalStep);
}
break;
case FlowDecision normalDecision:
normalDecision.DisplayName = model.MergeDescription;
normalDecision.False = null;
normalDecision.True = null;
nodes.Add(normalDecision);
break;
case FlowSwitch <string> normalSwitch:
var switchAct = new DsfFlowSwitchActivity
{
ExpressionText = String.Join("", GlobalConstants.InjectedSwitchDataFetch,
"(\"", nodeToAdd.GetProperty <string>("Switch"), "\",",
GlobalConstants.InjectedDecisionDataListVariable,
")"),
UniqueID = nodeToAdd.GetProperty <string>("UniqueID")
};
normalSwitch.DisplayName = model.MergeDescription;
normalSwitch.Expression = switchAct;
normalSwitch.Cases.Clear();
normalSwitch.Default = null;
nodes.Add(normalSwitch);
break;
default:
break;
}
var modelItem = GetItemFromNodeCollection(model.UniqueId);
if (modelItem == null)
{
return;
}
SetShapeLocation(modelItem, model.NodeLocation);
model.IsAddedToWorkflow = true;
}
public void FlowSwitch_GetDifferences_WhenCasesTheSame_SwitchHasNoConflict()
{
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 switchActivity = new DsfFlowSwitchActivity("MyName", new Mock <IDebugDispatcher>().Object, It.IsAny <bool>())
{
UniqueID = Guid.NewGuid().ToString(),
};
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 jsonSerializer = new Dev2JsonSerializer();
switchActivity.ExpressionText = jsonSerializer.Serialize(dev2DecisionStack);
var assignId = Guid.NewGuid().ToString();
var chart = new Flowchart
{
StartNode = new FlowStep
{
Action = new DsfMultiAssignActivity
{
FieldsCollection = new List <ActivityDTO>
{
new ActivityDTO("field1", "field1", 1),
new ActivityDTO("field2", "field2", 4),
new ActivityDTO("field3", "field3", 3),
new ActivityDTO("field3", "field3", 2),
},
UniqueID = assignId
},
Next = new FlowSwitch <string>
{
DisplayName = "DisplayName",
Default = new FlowStep
{
Action = ActivityBuilderFactory.BuildActivity(typeof(DsfCalculateActivity))
},
Expression = switchActivity
}
}
};
var otherChart = new Flowchart
{
StartNode = new FlowStep
{
Action = new DsfMultiAssignActivity
{
FieldsCollection = new List <ActivityDTO>
{
new ActivityDTO("field1", "field1", 1),
new ActivityDTO("field2", "field2", 2),
new ActivityDTO("field2", "fff", 4),
new ActivityDTO("field3", "field3", 3),
},
UniqueID = assignId
},
Next = new FlowSwitch <string>
{
DisplayName = "DisplayName",
Default = new FlowStep
{
Action = ActivityBuilderFactory.BuildActivity(typeof(DsfCalculateActivity))
},
Expression = switchActivity
}
}
};
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(6, 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);
}
