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"); }