static void AddVariables(string variable, string splitType, string splitAt, bool include = false, string escape = "")
{
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>(variable, ""));
List <DataSplitDTO> splitCollection;
ScenarioContext.Current.TryGetValue("splitCollection", out splitCollection);
if (splitCollection == null)
{
splitCollection = new List <DataSplitDTO>();
ScenarioContext.Current.Add("splitCollection", splitCollection);
}
DataSplitDTO dto = new DataSplitDTO {
OutputVariable = variable, SplitType = splitType, At = splitAt, EscapeChar = escape, Include = include
};
splitCollection.Add(dto);
}
public void DataSplitDTO_Ctor_CreateWithSplitTypeOfSpace_EnabledAtFalse()
{
//------------Execute Test---------------------------
var dataSplitDTO = new DataSplitDTO("[[var]]", "Space", "", 0);
//------------Assert Results-------------------------
Assert.IsFalse(dataSplitDTO.EnableAt);
}
public void DataSplitDTO_CanAdd_WithNewLineSplitTypeAndNoOtherValues_ReturnTrue()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
var dataSplitDTO = new DataSplitDTO(string.Empty, "NewLine", null, 1);
//------------Assert Results-------------------------
Assert.IsTrue(dataSplitDTO.CanAdd());
}
public void DataSplitDTO_CanRemove_WithNewLineInputTypeAndVar_ReturnFalse()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
var dataSplitDTO = new DataSplitDTO("s", "NewLine", null, 1);
//------------Assert Results-------------------------
Assert.IsFalse(dataSplitDTO.CanRemove());
}
public void DataSplitDTO_CanRemove_WithNoInputVarAndNoAt_ReturnTrue()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
var dataSplitDTO = new DataSplitDTO(string.Empty, null, null, 1);
//------------Assert Results-------------------------
Assert.IsTrue(dataSplitDTO.CanRemove());
}
public void DataSplitDTO_CanRemove_WithNoInputVarButValueForAt_ReturnFalse()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
var dataSplitDTO = new DataSplitDTO(string.Empty, null, "|", 1);
//------------Assert Results-------------------------
Assert.IsFalse(dataSplitDTO.CanRemove());
}
public void DataSplitDTO_GetRuleSet_IsEmptyIsTrue_ValidateRulesReturnsTrue()
{
//------------Setup for test--------------------------
var dto = new DataSplitDTO();
//------------Execute Test---------------------------
Verify_RuleSet(dto, "OutputVariable", null);
Verify_RuleSet(dto, "At", null);
}
public void DataSplitDTO_GetRuleSetOutputVariable_IsNotNullOrEmpty_ValidateRulesReturnsTrue()
{
//------------Setup for test--------------------------
var dto = new DataSplitDTO {
OutputVariable = "[[h]]", At = "1"
};
//------------Execute Test---------------------------
Verify_RuleSet(dto, "OutputVariable", null);
}
public void DataSplitDTO_GetRuleSetAt_SplitTypeIsCharsAndIsEmpty_ValidateRulesReturnsFalse()
{
//------------Setup for test--------------------------
var dto = new DataSplitDTO {
OutputVariable = "[[a]]", At = "", SplitType = DataSplitDTO.SplitTypeChars
};
//------------Execute Test---------------------------
Verify_RuleSet(dto, "At", "cannot be empty");
}
public void DataSplitDTO_GetRuleSetAt_SplitTypeIsCharsAndIsEmpty_ValidateRulesReturnsFalse()
{
//------------Setup for test--------------------------
var dto = new DataSplitDTO {
OutputVariable = "[[a]]", At = "", SplitType = DataSplitDTO.SplitTypeChars
};
//------------Execute Test---------------------------
Verify_RuleSet(dto, "At", Warewolf.Resource.Errors.ErrorResource.CannotBeNull);
}
public void DataSplitDTO_GetRuleSetAt_SplitTypeIsIndexAndIs0_ValidateRulesReturnsTrue()
{
//------------Setup for test--------------------------
var dto = new DataSplitDTO {
OutputVariable = "[[a]]", At = "0", SplitType = DataSplitDTO.SplitTypeIndex
};
//------------Execute Test---------------------------
Verify_RuleSet(dto, "At", null);
}
public void DataSplitDTO_GetRuleSetAt_SplitTypeIsCharsAndExpressionIsInvalid_ValidateRulesReturnsFalse()
{
//------------Setup for test--------------------------
var dto = new DataSplitDTO {
OutputVariable = "[[a]]", At = "h]]", SplitType = DataSplitDTO.SplitTypeChars
};
//------------Execute Test---------------------------
Verify_RuleSet(dto, "At", "Invalid expression: opening and closing brackets don't match");
}
public void DataSplitDTO_GetRuleSetAt_SplitTypeIsIndexAndIsLessThan0_ValidateRulesReturnsTrue()
{
//------------Setup for test--------------------------
var dto = new DataSplitDTO {
OutputVariable = "[[a]]", At = "-1", SplitType = DataSplitDTO.SplitTypeIndex
};
//------------Execute Test---------------------------
Verify_RuleSet(dto, "At", " must be a real number");
}
public void DataSplitDTO_GetRuleSetAt_SplitTypeIsCharsAndExpressionIsValid_ValidateRulesReturnsTrue()
{
//------------Setup for test--------------------------
var dto = new DataSplitDTO {
OutputVariable = "[[a]]", At = "[[h]]", SplitType = DataSplitDTO.SplitTypeChars
};
//------------Execute Test---------------------------
Verify_RuleSet(dto, "At", null);
}
public void DataSplitDTO_GetRuleSetOutputVariable_IsNotNullOrEmpty_ValidateRulesReturnsFalse()
{
//------------Setup for test--------------------------
var dto = new DataSplitDTO {
OutputVariable = "[[h&]]", At = "1"
};
//------------Execute Test---------------------------
Verify_RuleSet(dto, "OutputVariable", "Variable name [[h&]] contains invalid character(s)");
}
public void DataSplitDTO_GetRuleSetAt_SplitTypeIsIndexAndIsLessThan0_ValidateRulesReturnsTrue()
{
//------------Setup for test--------------------------
var dto = new DataSplitDTO {
OutputVariable = "[[a]]", At = "-1", SplitType = DataSplitDTO.SplitTypeIndex
};
//------------Execute Test---------------------------
Verify_RuleSet(dto, "At", Warewolf.Resource.Errors.ErrorResource.MustBeRealNumber);
}
public void DataSplitDTO_GetRuleSetOutputVariable_ExpressionIsValid_ValidateRulesReturnsTrue()
{
//------------Setup for test--------------------------
var dto = new DataSplitDTO {
OutputVariable = "[[h]]"
};
//------------Execute Test---------------------------
Verify_RuleSet(dto, "OutputVariable", null);
}
public void DataSplitDTO_GetRuleSetOutputVariable_ExpressionIsInvalid_ValidateRulesReturnsFalse()
{
//------------Setup for test--------------------------
var dto = new DataSplitDTO {
OutputVariable = "h]]"
};
//------------Execute Test---------------------------
Verify_RuleSet(dto, "OutputVariable", "Invalid expression: opening and closing brackets don't match");
}
void Verify_IsEmpty(string splitType)
{
//------------Setup for test--------------------------
var dto = new DataSplitDTO {
SplitType = splitType
};
//------------Execute Test---------------------------
var actual = dto.IsEmpty();
//------------Assert Results-------------------------
Assert.IsTrue(actual);
}
public void DataSplitDTO_IsEmpty_PropertiesAreNotEmpty_False()
{
//------------Setup for test--------------------------
var dto = new DataSplitDTO {
OutputVariable = "xxx"
};
//------------Execute Test---------------------------
var actual = dto.IsEmpty();
//------------Assert Results-------------------------
Assert.IsFalse(actual);
}
public void DataSplitDTO_ConvertToOutputTO_OutputTOPropertiesInitialized()
{
//------------Setup for test--------------------------
var dto = new DataSplitDTO {
OutputVariable = "[[h]]", OutList = new List <string>(new[] { "hello" })
};
//------------Execute Test---------------------------
var outputTO = dto.ConvertToOutputTO();
//------------Assert Results-------------------------
Assert.IsNotNull(outputTO);
Assert.AreEqual("[[h]]", outputTO.OutPutDescription);
Assert.AreSame(dto.OutList, outputTO.OutputStrings);
}
public void DataSplitDTO_ClearRow_PropertiesAreEmpty()
{
//------------Setup for test--------------------------
var dto = new DataSplitDTO {
OutputVariable = "xxx", SplitType = DataSplitDTO.SplitTypeNone, Include = true, EscapeChar = "'"
};
Assert.IsFalse(dto.IsEmpty());
//------------Execute Test---------------------------
dto.ClearRow();
//------------Assert Results-------------------------
Assert.IsTrue(dto.IsEmpty());
}
static DataSplitDesignerViewModel CreateViewModel()
{
var mi = ModelItemUtils.CreateModelItem(new DsfDataSplitActivity());
mi.SetProperty("DisplayName", "Split");
mi.SetProperty("SourceString", "a,b");
var dto = new DataSplitDTO("a]]", DataSplitDTO.SplitTypeIndex, "a", 0);
// ReSharper disable PossibleNullReferenceException
var miCollection = mi.Properties["ResultsCollection"].Collection;
miCollection.Add(dto);
// ReSharper restore PossibleNullReferenceException
var viewModel = new DataSplitDesignerViewModel(mi);
return(viewModel);
}
public void DataSplitDTO_Constructor_FullConstructor_PropertiesInitializedCorrectly()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
var dto = new DataSplitDTO(string.Empty, null, null, 1);
//------------Assert Results-------------------------
Assert.AreEqual(DataSplitDTO.SplitTypeIndex, dto.SplitType);
Assert.AreEqual(string.Empty, dto.At);
Assert.AreEqual(false, dto.EnableAt);
Assert.AreEqual(true, dto.IsEscapeCharEnabled);
Assert.AreEqual(1, dto.IndexNumber);
Assert.IsNull(dto.EscapeChar);
Assert.AreEqual(false, dto.Include);
Assert.IsNotNull(dto.Errors);
Assert.AreEqual(false, dto.IsAtFocused);
Assert.AreEqual(false, dto.IsOutputVariableFocused);
Assert.AreEqual(false, dto.IsEscapeCharFocused);
}
static void Verify_RuleSet(DataSplitDTO dto, string propertyName, string expectedErrorMessage)
{
const string trueString = "True";
const string noneString = "None";
var datalist = string.Format("<DataList><var Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /><a Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /><b Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /><h Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /><r Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /><rec Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" ><set Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /></rec></DataList>", trueString, noneString);
//------------Execute Test---------------------------
var ruleSet = dto.GetRuleSet(propertyName, datalist);
var errors = ruleSet.ValidateRules(null, null);
//------------Assert Results-------------------------
if (expectedErrorMessage == null)
{
Assert.AreEqual(0, errors.Count);
}
else
{
var err = errors.FirstOrDefault(e => e.Message.Contains(expectedErrorMessage));
Assert.IsNotNull(err);
}
}
public void DataSplitDesignerViewModel_ValidateCollectionItem_ValidatesPropertiesOfDTO()
{
//------------Setup for test--------------------------
var mi = ModelItemUtils.CreateModelItem(new DsfDataSplitActivity());
mi.SetProperty("DisplayName", "Split");
mi.SetProperty("SourceString", "a,b");
var dto = new DataSplitDTO("a]]", DataSplitDTO.SplitTypeIndex, "a", 0);
// ReSharper disable PossibleNullReferenceException
var miCollection = mi.Properties["ResultsCollection"].Collection;
var dtoModelItem = miCollection.Add(dto);
// ReSharper restore PossibleNullReferenceException
var viewModel = new DataSplitDesignerViewModel(mi);
viewModel.GetDatalistString = () =>
{
const string trueString = "True";
const string noneString = "None";
var datalist = string.Format("<DataList><var Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /><a Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /><b Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /><h Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /><r Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /><rec Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" ><set Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /></rec></DataList>", trueString, noneString);
return(datalist);
};
//------------Execute Test---------------------------
viewModel.Validate();
//------------Assert Results-------------------------
Assert.AreEqual(2, viewModel.Errors.Count);
StringAssert.Contains(viewModel.Errors[0].Message, Warewolf.Resource.Errors.ErrorResource.DataSplitInvalidExpressionErrorTest);
Verify_IsFocused(dtoModelItem, viewModel.Errors[0].Do, "IsOutputVariableFocused");
StringAssert.Contains(viewModel.Errors[1].Message, Warewolf.Resource.Errors.ErrorResource.DataSplitUsingNullErrorTest);
Verify_IsFocused(dtoModelItem, viewModel.Errors[1].Do, "IsAtFocused");
}
