public void ActivityHelper_InjectExpression_Dev2SwitchIsNull_ReturnNull()
{
//---------------Set up test pack-------------------
var viewModel = new DecisionDesignerViewModel(CreateModelItem());
var dev2DecisionStack = new Dev2DecisionStack()
{
DisplayText = "",
FalseArmText = "",
TrueArmText = "",
Version = "2",
Mode = Dev2DecisionMode.AND
};
dev2DecisionStack.TheStack = new List <Dev2Decision>();
var decisionExpressionMessage = new ConfigureDecisionExpressionMessage();
viewModel.Handle(decisionExpressionMessage);
var mySwitch = new Dev2Switch();
mySwitch = null;
var expressionText1 = string.Join("", GlobalConstants.InjectedSwitchDataFetch,
"(\"", "aaaaaaa", "\",",
GlobalConstants.InjectedDecisionDataListVariable,
")");
var expressionText = viewModel.ModelItem.Properties[expressionText1];
//------------Setup for test--------------------------
var expr = ActivityHelper.InjectExpression(mySwitch, expressionText);
Assert.IsNull(expr);
}
public void DecisionDesignerViewModel_Validate_CustomizedDisplayText()
{
//------------Setup for test--------------------------
var viewModel = new DecisionDesignerViewModel(CreateModelItem("Decision"))
{
DisplayText = "",
TrueArmText = "",
FalseArmText = "",
ExpressionText = ""
};
viewModel.DisplayText = "Testing";
var dev2Decision = new Dev2Decision
{
Col1 = "[[val]]",
EvaluationFn = enDecisionType.IsEqual,
Col2 = "5"
};
var item = new DecisionTO(dev2Decision, 1);
viewModel.Collection.Insert(0, item);
//------------Execute Test---------------------------
//------------Assert Results-------------------------
Assert.AreEqual("Testing", viewModel.DisplayText);
}
public void DecisionDesignerViewModel_RemoveRow_ShouldRemove()
{
//------------Setup for test--------------------------
var viewModel = new DecisionDesignerViewModel(CreateModelItem())
{
DisplayText = "",
TrueArmText = "",
FalseArmText = ""
};
var dev2Decision = new Dev2Decision
{
Col1 = "[[val]]",
EvaluationFn = enDecisionType.IsEqual,
Col2 = "5"
};
var item = new DecisionTO(dev2Decision, 1);
viewModel.Collection.Insert(0, item);
//------------Assert Preconsidtions------------------
Assert.AreEqual(3, viewModel.Collection.Count);
//------------Execute Test---------------------------
viewModel.DeleteCommand.Execute(item);
//------------Assert Results-------------------------
Assert.AreEqual(2, viewModel.Collection.Count);
}
public void DecisionDesignerViewModel_HandleConfigureMessage_SetShowLarge()
{
//------------Setup for test--------------------------
var viewModel = new DecisionDesignerViewModel(CreateModelItem());
//------------Execute Test---------------------------
viewModel.Handle(new ConfigureDecisionExpressionMessage());
//------------Assert Results-------------------------
Assert.IsTrue(viewModel.ShowLarge);
}
public void DecisionDesignerViewModel_Constructor_PropertiesInitialized()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
var viewModel = new DecisionDesignerViewModel(CreateModelItem());
//------------Assert Results-------------------------
Assert.IsNotNull(viewModel.ModelItem);
Assert.IsNotNull(viewModel.Collection);
Assert.AreEqual("ResultsCollection", viewModel.CollectionName);
Assert.AreEqual(0, viewModel.TitleBarToggles.Count);
Assert.AreEqual(38, viewModel.WhereOptions.Count);
}
public void DecisionDesignerViewModel_UpdateHelp_ShouldCallToHelpViewMode()
{
//------------Setup for test--------------------------
var mockMainViewModel = new Mock <IShellViewModel>();
var mockHelpViewModel = new Mock <IHelpWindowViewModel>();
mockHelpViewModel.Setup(model => model.UpdateHelpText(It.IsAny <string>())).Verifiable();
mockMainViewModel.Setup(model => model.HelpViewModel).Returns(mockHelpViewModel.Object);
CustomContainer.Register(mockMainViewModel.Object);
var viewModel = new DecisionDesignerViewModel(CreateModelItem());
//------------Execute Test---------------------------
viewModel.UpdateHelpDescriptor("help");
//------------Assert Results-------------------------
mockHelpViewModel.Verify(model => model.UpdateHelpText(It.IsAny <string>()), Times.Once());
}
void Verify_OnSearchTypeChanged_IsSearchCriteriaEnabled(string searchType, bool isSearchCriteriaEnabled, bool isSearchCriteriaBlank, int indexObject = 0)
{
//------------Setup for test--------------------------
var decisionTO = new DecisionTO("xxxx", "xxxx", searchType, 1);
var viewModel = new DecisionDesignerViewModel(CreateModelItem());
//------------Precondition---------------------------
//------------Execute Test---------------------------
viewModel.SearchTypeUpdatedCommand.Execute(indexObject);
//------------Assert Results-------------------------
Assert.AreEqual(isSearchCriteriaEnabled, decisionTO.IsSearchCriteriaVisible);
Assert.AreEqual(isSearchCriteriaBlank, string.IsNullOrEmpty(decisionTO.SearchCriteria));
}
public void DecisionDesignerViewModel_Validate_FalseText()
{
//------------Setup for test--------------------------
var viewModel = new DecisionDesignerViewModel(CreateModelItem())
{
DisplayText = "text",
TrueArmText = "some text",
FalseArmText = ""
};
//------------Execute Test---------------------------
viewModel.Validate();
//------------Assert Results-------------------------
Assert.IsNotNull(viewModel.Errors);
Assert.AreEqual(1, viewModel.Errors.Count);
Assert.AreEqual(Warewolf.Resource.Errors.ErrorResource.DecisionFalseArmTextNotNullErrorTest, viewModel.Errors[0].Message);
viewModel.Errors[0].Do();
Assert.IsTrue(viewModel.IsFalseArmFocused);
}
static Dev2DecisionCallbackHandler ShowDecisionDialogWindow(ModelItem mi, DecisionDesignerViewModel dataContext)
{
var large = new Large {
DataContext = dataContext
};
var window = new ActivityDefaultWindow();
if (Application.Current != null)
{
window.Style = Application.Current.TryFindResource("DecisionWindowStyle") as Style;
}
var contentPresenter = window.FindChild <ContentPresenter>();
if (contentPresenter != null)
{
contentPresenter.Content = large;
}
window.SetEnableDoneButtonState(true);
var parentContentPane = FindDependencyParent.FindParent <DesignerView>(mi?.Parent?.View);
var dataContext1 = parentContentPane?.DataContext;
if (dataContext1 != null && dataContext1.GetType().Name == "ServiceTestViewModel")
{
window.SetEnableDoneButtonState(false);
}
var showDialog = window.ShowDialog();
window.SetEnableDoneButtonState(true);
if (showDialog.HasValue && showDialog.Value)
{
var dev2DecisionCallbackHandler = new Dev2DecisionCallbackHandler();
dataContext.GetExpressionText();
dev2DecisionCallbackHandler.ModelData = dataContext.ExpressionText;
return(dev2DecisionCallbackHandler);
}
return(null);
}
public static void SetupForSystem()
{
Utils.SetupResourceDictionaryActivities();
var tos = new List <DecisionTO>();
FeatureContext.Current["Tos"] = tos;
var stack = new Dev2DecisionStack();
var mi = CreateModelItem(tos);
FeatureContext.Current["modelItem"] = mi;
var mockView = new Mock <IView>();
FeatureContext.Current.Add("view", mockView.Object);
var vm = new DecisionDesignerViewModel(mi);
FeatureContext.Current["viewModel"] = vm;
var dataContext = vm;
mockView.SetupGet(view => view.DataContext).Returns(dataContext);
Utils.ShowTheViewForTesting(mockView.Object);
}
public void ActivityHelper_Dev2Decision_Null_TrueArmText_SetArmText()
{
//---------------Set up test pack-------------------
using (var viewModel = new DecisionDesignerViewModel(CreateModelItem()))
{
var dev2DecisionStack = new Dev2DecisionStack
{
DisplayText = "",
FalseArmText = "",
TrueArmText = null,
Version = "2",
Mode = Dev2DecisionMode.AND,
TheStack = new List <Dev2Decision>()
};
var decisionExpressionMessage = new ConfigureDecisionExpressionMessage();
viewModel.Handle(decisionExpressionMessage);
//------------Setup for test--------------------------
ActivityHelper.SetArmTextDefaults(dev2DecisionStack);
Assert.AreEqual("True", dev2DecisionStack.TrueArmText);
}
}
public void DecisionDesignerViewModel_GetExpressionText_ShouldSetExpressionText()
{
//------------Setup for test--------------------------
var viewModel = new DecisionDesignerViewModel(CreateModelItem())
{
DisplayText = "",
TrueArmText = "",
FalseArmText = ""
};
var dev2Decision = new Dev2Decision
{
Col1 = "[[val]]",
EvaluationFn = enDecisionType.IsEqual,
Col2 = "5"
};
viewModel.Collection.Add(new DecisionTO(dev2Decision, 1));
//------------Execute Test---------------------------
viewModel.GetExpressionText();
//------------Assert Results-------------------------
Assert.IsNotNull(viewModel.ExpressionText);
StringAssert.Contains(viewModel.ExpressionText, "{\"TheStack\":[{\"Col1\":\"[[val]]\",\"Col2\":\"5\",\"Col3\":\"\",\"Cols1\":null,\"Cols2\":null,\"Cols3\":null,\"PopulatedColumnCount\":2,\"EvaluationFn\":\"IsEqual\"}],\"TotalDecisions\":1,\"ModelName\":\"Dev2DecisionStack\",\"Mode\":\"AND\",\"TrueArmText\":\"\",\"FalseArmText\":\"\",\"DisplayText\":\"\",\"Version\":null}");
}
void Verify_OnSearchTypeChanged_IndexOutOfBounds_DoesNothing(int index)
{
//------------Setup for test--------------------------
var items = new List <DecisionTO>
{
new DecisionTO("xxxx", "xxxx", "Equals", 1),
new DecisionTO("yyyy", "yyyy", "Contains", 2)
};
var viewModel = new DecisionDesignerViewModel(CreateModelItem());
//------------Execute Test---------------------------
viewModel.SearchTypeUpdatedCommand.Execute(index);
//------------Assert Results-------------------------
foreach (var dto in items)
{
Assert.IsTrue(dto.IsSearchCriteriaEnabled);
Assert.IsFalse(string.IsNullOrEmpty(dto.SearchCriteria));
}
}
private static Dev2DecisionCallbackHandler StartDecisionWizard(ModelItem mi)
{
var dataContext = new DecisionDesignerViewModel(mi);
return(ShowDecisionDialogWindow(mi, dataContext));
}
public void ActivityHelper_InjectExpression_Dev2Switch()
{
//---------------Set up test pack-------------------
var serializer = new Dev2JsonSerializer();
var viewModel = new DecisionDesignerViewModel(CreateModelItem());
var dev2DecisionStack = new Dev2DecisionStack()
{
DisplayText = "",
FalseArmText = "",
TrueArmText = "",
Version = "2",
Mode = Dev2DecisionMode.AND
};
dev2DecisionStack.TheStack = new List <Dev2Decision>();
var decisionExpressionMessage = new ConfigureDecisionExpressionMessage();
viewModel.Handle(decisionExpressionMessage);
var mySwitch = new Dev2Switch();
//------------Setup for test--------------------------
var testAct = new DsfFlowSwitchActivity {
ExpressionText = ""
};
var prop = new Mock <ModelProperty>();
prop.Setup(p => p.ComputedValue).Returns(testAct);
ActivityHelper.InjectExpression(mySwitch, prop.Object);
//------------Assert Results-------------------------
var act = new DsfDecision {
Conditions = dev2DecisionStack, And = true
};
var stateItems = act.GetState();
Assert.AreEqual(5, stateItems.Count());
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 void Decision_StaredRecordsetIsBetweenTwoStaredRecordsets_ValidateAndGenerateUserFriendlyModel()
{
//------------Setup for test--------------------------
using (var viewModel = new DecisionDesignerViewModel(CreateModelItem(nameof(Decision)))
{
TrueArmText = "",
FalseArmText = "",
ExpressionText = "",
DisplayText = "Testing"
})
{
var dev2Decision = new Dev2Decision
{
Col1 = "[[recset(*).field]]",
EvaluationFn = enDecisionType.IsBetween,
Col2 = "[[recset(*).field]]",
Col3 = "[[recset(*).field]]"
};
var mockedEnvironment = new Mock <IExecutionEnvironment>();
mockedEnvironment.Setup(env => env.EvalAsListOfStrings(It.IsAny <string>(), It.IsAny <int>())).Returns(new List <string> {
"Some Value"
});
var userFriendlyModel = dev2Decision.GenerateToolLabel(mockedEnvironment.Object, Dev2DecisionMode.AND, out ErrorResultTO errors);
Assert.AreEqual("If Some Value Is Between Some Value AND Some Value", userFriendlyModel, "User friendly model was not generated correctly for decision on multiple starred recordsets.");
var item = new DecisionTO(dev2Decision, 1);
viewModel.Collection.Insert(0, item);
dev2Decision = new Dev2Decision
{
Col1 = "[[recset(*).field]]",
EvaluationFn = enDecisionType.IsBetween,
Col2 = "[[recset(*).field]]",
Col3 = "[[val]]"
};
mockedEnvironment.Setup(env => env.EvalAsListOfStrings(It.IsAny <string>(), It.IsAny <int>())).Returns(new List <string> {
"Some Value"
});
userFriendlyModel = dev2Decision.GenerateToolLabel(mockedEnvironment.Object, Dev2DecisionMode.AND, out errors);
Assert.AreEqual("If Some Value Is Between Some Value AND [[val]]", userFriendlyModel, "User friendly model was not generated correctly.");
item = new DecisionTO(dev2Decision, 1);
viewModel.Collection.Insert(0, item);
dev2Decision = new Dev2Decision
{
Col1 = "[[recset(*).field]]",
EvaluationFn = enDecisionType.IsBetween,
Col2 = "[[val]]",
Col3 = "[[recset(*).field]]"
};
mockedEnvironment.Setup(env => env.EvalAsListOfStrings(It.IsAny <string>(), It.IsAny <int>())).Returns(new List <string> {
"Some Value"
});
userFriendlyModel = dev2Decision.GenerateToolLabel(mockedEnvironment.Object, Dev2DecisionMode.AND, out errors);
Assert.AreEqual("If Some Value Is Between [[val]] AND Some Value", userFriendlyModel, "User friendly model was not generated correctly.");
item = new DecisionTO(dev2Decision, 1);
viewModel.Collection.Insert(0, item);
var dev2Decision4 = new Dev2Decision
{
Col1 = "[[val]]",
EvaluationFn = enDecisionType.IsBetween,
Col2 = "[[recset(*).field]]",
Col3 = "[[recset(*).field]]"
};
mockedEnvironment.Setup(env => env.EvalAsListOfStrings(It.IsAny <string>(), It.IsAny <int>())).Returns(new List <string> {
"Some Value"
});
userFriendlyModel = dev2Decision.GenerateToolLabel(mockedEnvironment.Object, Dev2DecisionMode.AND, out errors);
item = new DecisionTO(dev2Decision4, 1);
viewModel.Collection.Insert(0, item);
dev2Decision = new Dev2Decision
{
Col1 = "[[val]]",
EvaluationFn = enDecisionType.IsBetween,
Col2 = "[[val]]",
Col3 = "[[recset(*).field]]"
};
mockedEnvironment.Setup(env => env.EvalAsListOfStrings(It.IsAny <string>(), It.IsAny <int>())).Returns(new List <string> {
"Some Value"
});
userFriendlyModel = dev2Decision.GenerateToolLabel(mockedEnvironment.Object, Dev2DecisionMode.AND, out errors);
Assert.AreEqual("If [[val]] Is Between [[val]] AND Some Value", userFriendlyModel, "User friendly model was not generated correctly.");
item = new DecisionTO(dev2Decision, 1);
viewModel.Collection.Insert(0, item);
dev2Decision = new Dev2Decision
{
Col1 = "[[val]]",
EvaluationFn = enDecisionType.IsBetween,
Col2 = "[[recset(*).field]]",
Col3 = "[[val]]"
};
mockedEnvironment.Setup(env => env.EvalAsListOfStrings(It.IsAny <string>(), It.IsAny <int>())).Returns(new List <string> {
"Some Value"
});
userFriendlyModel = dev2Decision.GenerateToolLabel(mockedEnvironment.Object, Dev2DecisionMode.AND, out errors);
Assert.AreEqual("If [[val]] Is Between Some Value AND [[val]]", userFriendlyModel, "User friendly model was not generated correctly.");
item = new DecisionTO(dev2Decision, 1);
viewModel.Collection.Insert(0, item);
dev2Decision = new Dev2Decision
{
Col1 = "[[recset(*).field]]",
EvaluationFn = enDecisionType.IsBetween,
Col2 = "[[val]]",
Col3 = "[[val]]"
};
mockedEnvironment.Setup(env => env.EvalAsListOfStrings(It.IsAny <string>(), It.IsAny <int>())).Returns(new List <string> {
"Some Value"
});
userFriendlyModel = dev2Decision.GenerateToolLabel(mockedEnvironment.Object, Dev2DecisionMode.AND, out errors);
Assert.AreEqual("If Some Value Is Between [[val]] AND [[val]]", userFriendlyModel, "User friendly model was not generated correctly.");
item = new DecisionTO(dev2Decision, 1);
viewModel.Collection.Insert(0, item);
dev2Decision = new Dev2Decision
{
Col1 = "[[recset(*).field]]",
EvaluationFn = enDecisionType.IsEqual,
Col2 = "[[recset(*).field]]"
};
mockedEnvironment.Setup(env => env.EvalAsListOfStrings(It.IsAny <string>(), It.IsAny <int>())).Returns(new List <string> {
"Some Value"
});
userFriendlyModel = dev2Decision.GenerateToolLabel(mockedEnvironment.Object, Dev2DecisionMode.AND, out errors);
Assert.AreEqual("If Some Value = Some Value", userFriendlyModel, "User friendly model was not generated correctly.");
item = new DecisionTO(dev2Decision, 1);
viewModel.Collection.Insert(0, item);
//------------Execute Test---------------------------
//------------Assert Results-------------------------
Assert.AreEqual("Testing", viewModel.DisplayText);
}
}
