public void Equals_Given_SameDefault_DifferentIndexes_SwitchActivity_AreEqual()
{
//---------------Set up test pack-------------------
var uniqId = Guid.NewGuid().ToString();
var newUniqueId = Guid.NewGuid().ToString();
var defaults = new List <IDev2Activity> {
new TestActivity {
UniqueID = newUniqueId
}, new TestActivity()
};
var defaults2 = new List <IDev2Activity> {
new TestActivity(), new TestActivity {
UniqueID = newUniqueId
}
};
var activity = new DsfSwitch {
UniqueID = uniqId, Default = defaults
};
var activity1 = new DsfSwitch {
UniqueID = uniqId, Default = defaults2
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity);
//---------------Execute Test ----------------------
var @equals = activity.Equals(activity1);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}
public void Equals_Given_SameSwitches_DifferentIndexes_SwitchActivity_AreNotEqual()
{
//---------------Set up test pack-------------------
var uniqId = Guid.NewGuid().ToString();
var assign = new DsfMultiAssignActivity();
var switches = new Dictionary <string, IDev2Activity> {
{ "Arm2", assign }, { "Arm", assign }
};
var switches2 = new Dictionary <string, IDev2Activity> {
{ "Arm", assign }, { "Arm2", assign }
};
var activity = new DsfSwitch {
UniqueID = uniqId, Switches = switches
};
var activity1 = new DsfSwitch {
UniqueID = uniqId, Switches = switches2
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity);
//---------------Execute Test ----------------------
var @equals = activity.Equals(activity1);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}
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);
}
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 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);
}
public void Equals_Given_Empty_SwitchActivity_AreNotEqual()
{
//---------------Set up test pack-------------------
var activity = new DsfSwitch();
var activity1 = new DsfSwitch();
//---------------Assert Precondition----------------
Assert.IsNotNull(activity);
//---------------Execute Test ----------------------
var @equals = activity.Equals(activity1);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
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);
}
public void Equals_Given_SameSwitch_SwitchActivity_AreEqual()
{
//---------------Set up test pack-------------------
var uniqId = Guid.NewGuid().ToString();
var activity = new DsfSwitch {
UniqueID = uniqId, Switch = ""
};
var activity1 = new DsfSwitch {
UniqueID = uniqId, Switch = ""
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity);
//---------------Execute Test ----------------------
var @equals = activity.Equals(activity1);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}
public void Equals_Given_SameResult_Different_Casing_SwitchActivity_AreNotEqual()
{
//---------------Set up test pack-------------------
var uniqId = Guid.NewGuid().ToString();
var activity = new DsfSwitch {
UniqueID = uniqId, Result = "A"
};
var activity1 = new DsfSwitch {
UniqueID = uniqId, Result = "a"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity);
//---------------Execute Test ----------------------
var @equals = activity.Equals(activity1);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
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 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 Equals_Given_DifferentDisplayName_SwitchActivity_AreNotEqual()
{
//---------------Set up test pack-------------------
var uniqId = Guid.NewGuid().ToString();
var defaults = new List <IDev2Activity>();
var activity = new DsfSwitch
{
UniqueID = uniqId,
Default = defaults,
DisplayName = "The Switch Display Name",
};
var activity1 = new DsfSwitch {
UniqueID = uniqId, Default = defaults
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity);
//---------------Execute Test ----------------------
var @equals = activity.Equals(activity1);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
public void Equals_Given_DifferentErrorWorkflow_SwitchActivity_AreNotEqual()
{
//---------------Set up test pack-------------------
var uniqId = Guid.NewGuid().ToString();
var defaults = new List <IDev2Activity>();
var activity = new DsfSwitch
{
UniqueID = uniqId,
Default = defaults,
OnErrorWorkflow = "https://host:4321/err",
};
var activity1 = new DsfSwitch {
UniqueID = uniqId, Default = defaults
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity);
//---------------Execute Test ----------------------
var @equals = activity.Equals(activity1);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
public void DsfSwitch_GetState_ReturnsStateVariable()
{
//---------------Set up test pack-------------------
var nextActivity = new Mock <IDev2Activity>();
var serializer = new Dev2JsonSerializer();
//------------Setup for test--------------------------
const string expectedResult = "[[MyResult]]";
const string expectedSwitch = "[[Switch]]";
var expectedSwitches = new Dictionary <string, IDev2Activity>();
var expectedDefault = new List <IDev2Activity> {
nextActivity.Object
};
var act = new DsfSwitch
{
Result = expectedResult,
Switch = expectedSwitch,
Switches = expectedSwitches,
Default = expectedDefault
};
//------------Execute Test---------------------------
var stateItems = act.GetState();
Assert.AreEqual(4, stateItems.Count());
var expectedResults = new[]
{
new StateVariable
{
Name = "Switch",
Type = StateVariable.StateType.Input,
Value = expectedSwitch
},
new StateVariable
{
Name = "Switches",
Type = StateVariable.StateType.Output,
Value = serializer.Serialize(expectedSwitches)
},
new StateVariable
{
Name = "Default",
Type = StateVariable.StateType.Output,
Value = serializer.Serialize(expectedDefault)
},
new StateVariable
{
Name = "Result",
Value = expectedResult,
Type = StateVariable.StateType.Output
}
};
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);
}
}
IEnumerable<IDev2Activity> ParseSwitch(FlowSwitch<string> switchFlowSwitch, List<IDev2Activity> seenActivities)
{
var activity = switchFlowSwitch.Expression as DsfFlowSwitchActivity;
if (activity != null)
{
if (seenActivities.Contains(activity))
{
return new List<IDev2Activity> { activity };
}
var val = new StringBuilder(Dev2DecisionStack.ExtractModelFromWorkflowPersistedData(activity.ExpressionText));
Dev2Switch ds = new Dev2Switch { SwitchVariable = val.ToString() };
var swi = new DsfSwitch(activity);
if (!seenActivities.Contains(activity))
{
seenActivities.Add(swi);
}
swi.Switches = switchFlowSwitch.Cases.Select(a => new Tuple<string, IDev2Activity>(a.Key, ParseTools(a.Value, seenActivities).FirstOrDefault())).ToDictionary(a => a.Item1, a => a.Item2);
swi.Default = ParseTools(switchFlowSwitch.Default, seenActivities);
swi.Switch = ds.SwitchVariable;
return new List<IDev2Activity>
{ swi
};
}
throw new Exception("Invalid activity");
}
