private void InsertToCollection(IEnumerable <string> listToAdd, ModelItem modelItem)
{
var modelProperty = modelItem.Properties["MergeCollection"];
if (modelProperty != null)
{
ModelItemCollection mic = modelProperty.Collection;
if (mic != null)
{
List <DataMergeDTO> listOfValidRows = MergeCollection.Where(c => !c.CanRemove()).ToList();
if (listOfValidRows.Count > 0)
{
DataMergeDTO dataMergeDto = MergeCollection.Last(c => !c.CanRemove());
int startIndex = MergeCollection.IndexOf(dataMergeDto) + 1;
foreach (string s in listToAdd)
{
mic.Insert(startIndex, new DataMergeDTO(s, MergeCollection[startIndex - 1].MergeType, MergeCollection[startIndex - 1].At, startIndex + 1, MergeCollection[startIndex - 1].Padding, MergeCollection[startIndex - 1].Alignment));
startIndex++;
}
CleanUpCollection(mic, modelItem, startIndex);
}
else
{
AddToCollection(listToAdd, modelItem);
}
}
}
}
public void DataMergeDTO_CanAdd_WithNewLineMergeTypeAndNoOtherValues_ReturnTrue()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
var dataMergeDTO = new DataMergeDTO(string.Empty, "NewLine", null, 1, null, null);
//------------Assert Results-------------------------
Assert.IsTrue(dataMergeDTO.CanAdd());
}
public void DataMergeDTO_CanAdd_WithNoInputVarButValueForAt_ReturnTrue()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
var dataMergeDTO = new DataMergeDTO(string.Empty, null, "|", 1, null, null);
//------------Assert Results-------------------------
Assert.IsTrue(dataMergeDTO.CanAdd());
}
public void DataMergeDTO_CanAdd_WithNoInputVarAndNoAt_ReturnFalse()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
var dataMergeDTO = new DataMergeDTO(string.Empty, null, null, 1, null, null);
//------------Assert Results-------------------------
Assert.IsFalse(dataMergeDTO.CanAdd());
}
public static IDev2TOFn CreateNewDTO(IDev2TOFn dto, int index = 0, bool inserted = false, string initializeWith = "")
{
IDev2TOFn toReturn = null;
TypeSwitch.Do(dto,
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Case <ActivityDTO>(x => toReturn = new ActivityDTO(initializeWith, "", index, inserted)),
// ReSharper restore ImplicitlyCapturedClosure
TypeSwitch.Case <DataSplitDTO>(x =>
{
var dataSplitDto = dto as DataSplitDTO;
if (dataSplitDto != null)
{
toReturn = new DataSplitDTO(initializeWith, dataSplitDto.SplitType, dataSplitDto.At, index, false, inserted);
}
}),
TypeSwitch.Case <DataMergeDTO>(x =>
{
var dataMergeDto = dto as DataMergeDTO;
if (dataMergeDto != null)
{
toReturn = new DataMergeDTO(initializeWith, dataMergeDto.MergeType, dataMergeDto.At, index, dataMergeDto.Padding, dataMergeDto.Alignment, inserted);
}
}),
TypeSwitch.Case <CaseConvertTO>(x =>
{
var caseConvertTO = dto as CaseConvertTO;
if (caseConvertTO != null)
{
toReturn = CaseConverterFactory.CreateCaseConverterTO(initializeWith, caseConvertTO.ConvertType, caseConvertTO.Result, index);
}
}),
TypeSwitch.Case <BaseConvertTO>(x =>
{
var baseConvertTO = dto as BaseConvertTO;
if (baseConvertTO != null)
{
toReturn = new BaseConvertTO(initializeWith, baseConvertTO.FromType, baseConvertTO.ToType, baseConvertTO.ToExpression, index, inserted);
}
}),
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Case <GatherSystemInformationTO>(x => toReturn =
// ReSharper restore ImplicitlyCapturedClosure
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.FullDateTime,
initializeWith, index, inserted)),
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Case <XPathDTO>(x => toReturn = new XPathDTO(initializeWith, "", index, inserted)),
// ReSharper restore ImplicitlyCapturedClosure
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Case <FindRecordsTO>(() => toReturn = new FindRecordsTO("", "", index, inserted)),
// ReSharper restore ImplicitlyCapturedClosure
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Default(() => toReturn = null));
// ReSharper restore ImplicitlyCapturedClosure
return(toReturn);
}
public static IDev2TOFn CreateNewDTO(IDev2TOFn dto, int index = 0, bool inserted = false, string initializeWith = "")
{
IDev2TOFn toReturn = null;
TypeSwitch.Do(dto,
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Case<ActivityDTO>(x => toReturn = new ActivityDTO(initializeWith, "", index, inserted)),
// ReSharper restore ImplicitlyCapturedClosure
TypeSwitch.Case<DataSplitDTO>(x =>
{
var dataSplitDto = dto as DataSplitDTO;
if(dataSplitDto != null)
{
toReturn = new DataSplitDTO(initializeWith, dataSplitDto.SplitType, dataSplitDto.At, index, false, inserted);
}
}),
TypeSwitch.Case<DataMergeDTO>(x =>
{
var dataMergeDto = dto as DataMergeDTO;
if(dataMergeDto != null)
{
toReturn = new DataMergeDTO(initializeWith, dataMergeDto.MergeType, dataMergeDto.At, index, dataMergeDto.Padding, dataMergeDto.Alignment, inserted);
}
}),
TypeSwitch.Case<CaseConvertTO>(x =>
{
var caseConvertTO = dto as CaseConvertTO;
if(caseConvertTO != null)
{
toReturn = CaseConverterFactory.CreateCaseConverterTO(initializeWith, caseConvertTO.ConvertType, caseConvertTO.Result, index);
}
}),
TypeSwitch.Case<BaseConvertTO>(x =>
{
var baseConvertTO = dto as BaseConvertTO;
if(baseConvertTO != null)
{
toReturn = new BaseConvertTO(initializeWith, baseConvertTO.FromType, baseConvertTO.ToType, baseConvertTO.ToExpression, index, inserted);
}
}),
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Case<GatherSystemInformationTO>(x => toReturn =
// ReSharper restore ImplicitlyCapturedClosure
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.FullDateTime,
initializeWith, index, inserted)),
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Case<XPathDTO>(x => toReturn = new XPathDTO(initializeWith, "", index, inserted)),
// ReSharper restore ImplicitlyCapturedClosure
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Case<FindRecordsTO>(() => toReturn = new FindRecordsTO("", "", index, inserted)),
// ReSharper restore ImplicitlyCapturedClosure
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Default(() => toReturn = null));
// ReSharper restore ImplicitlyCapturedClosure
return toReturn;
}
public void DataMergeDTO_Constructor_FullConstructor_DefaultValues()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
var dataMergeDTO = new DataMergeDTO(string.Empty, null, null, 1, null, null);
//------------Assert Results-------------------------
Assert.AreEqual("Index", dataMergeDTO.MergeType);
Assert.AreEqual(string.Empty, dataMergeDTO.At);
Assert.AreEqual(1, dataMergeDTO.IndexNumber);
Assert.AreEqual(string.Empty, dataMergeDTO.Padding);
Assert.AreEqual("Left", dataMergeDTO.Alignment);
Assert.IsNotNull(dataMergeDTO.Errors);
}
public static IDev2TOFn CreateNewDTO(IDev2TOFn dto, int index, bool inserted, string initializeWith)
{
IDev2TOFn toReturn = null;
TypeSwitch.Do(dto,
TypeSwitch.Case <ActivityDTO>(x => toReturn = new ActivityDTO(initializeWith, "", index, inserted)),
TypeSwitch.Case <DataSplitDTO>(x =>
{
if (dto is DataSplitDTO dataSplitDto)
{
toReturn = new DataSplitDTO(initializeWith, dataSplitDto.SplitType, dataSplitDto.At, index, false, inserted);
}
}),
TypeSwitch.Case <DataMergeDTO>(x =>
{
if (dto is DataMergeDTO dataMergeDto)
{
toReturn = new DataMergeDTO(initializeWith, dataMergeDto.MergeType, dataMergeDto.At, index, dataMergeDto.Padding, dataMergeDto.Alignment, inserted);
}
}),
TypeSwitch.Case <CaseConvertTO>(x =>
{
if (dto is CaseConvertTO caseConvertTO)
{
toReturn = CaseConverterFactory.CreateCaseConverterTO(initializeWith, caseConvertTO.ConvertType, caseConvertTO.Result, index);
}
}),
TypeSwitch.Case <BaseConvertTO>(x =>
{
if (dto is BaseConvertTO baseConvertTO)
{
toReturn = new BaseConvertTO(initializeWith, baseConvertTO.FromType, baseConvertTO.ToType, baseConvertTO.ToExpression, index, inserted);
}
}),
TypeSwitch.Case <GatherSystemInformationTO>(x => toReturn =
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.FullDateTime,
initializeWith, index, inserted)),
TypeSwitch.Case <XPathDTO>(x => toReturn = new XPathDTO(initializeWith, "", index, inserted)),
TypeSwitch.Case <FindRecordsTO>(() => toReturn = new FindRecordsTO("", "", index, inserted)),
TypeSwitch.Case <DecisionTO>(() => toReturn = new DecisionTO(initializeWith, "", "", index, inserted)),
TypeSwitch.Case <JsonMappingTo>(() => toReturn = new JsonMappingTo(initializeWith, index, inserted)),
TypeSwitch.Case <SharepointSearchTo>(() => toReturn = new SharepointSearchTo(initializeWith, "=", "", index, inserted)),
TypeSwitch.Case <SharepointReadListTo>(() => toReturn = new SharepointReadListTo("", initializeWith, "", "")),
TypeSwitch.Case <AssignObjectDTO>(x => toReturn = new AssignObjectDTO(initializeWith, "", index, inserted)),
TypeSwitch.Default(() => toReturn = null));
return(toReturn);
}
public void DataMergeDTO_GetRuleSet_AtExpressionIsInvalid_ValidateRulesReturnsFalse()
{
//------------Setup for test--------------------------
var dto = new DataMergeDTO { InputVariable = "[[a]]", At = "h]]" };
//------------Execute Test---------------------------
Verify_RuleSet(dto, "At", "Invalid expression: opening and closing brackets don't match");
}
public void DataMergeDTO_CanRemove_WithNewLineInputTypeAndVar_ReturnFalse()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
var dataMergeDTO = new DataMergeDTO("s", "NewLine", null, 1, null, null);
//------------Assert Results-------------------------
Assert.IsFalse(dataMergeDTO.CanRemove());
}
public void DataMergeDesignerViewModel_ValidateCollectionItem_ValidatesPropertiesOfDTO()
{
//------------Setup for test--------------------------
var mi = ModelItemUtils.CreateModelItem(new DsfDataMergeActivity());
mi.SetProperty("DisplayName", "Merge");
var dto = new DataMergeDTO("a&]]", DataMergeDTO.MergeTypeIndex, "", 0, "ab", "Left");
// ReSharper disable PossibleNullReferenceException
var miCollection = mi.Properties["MergeCollection"].Collection;
var dtoModelItem = miCollection.Add(dto);
// ReSharper restore PossibleNullReferenceException
var viewModel = new DataMergeDesignerViewModel(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(4, viewModel.Errors.Count);
StringAssert.Contains(viewModel.Errors[0].Message, "'Input' - Invalid expression: opening and closing brackets don't match.");
Verify_IsFocused(dtoModelItem, viewModel.Errors[0].Do, "IsFieldNameFocused");
StringAssert.Contains(viewModel.Errors[1].Message, "'Using' cannot be empty");
Verify_IsFocused(dtoModelItem, viewModel.Errors[1].Do, "IsAtFocused");
}
public void DataMergeDTO_GetRuleSetOutputVariable_ExpressionIsInvalid_ValidateRulesReturnsFalse()
{
//------------Setup for test--------------------------
var dto = new DataMergeDTO { InputVariable = "[[ddd&]]", MergeType = DataMergeDTO.MergeTypeNone, Alignment = "Right", At = "1", Padding = " " };
//------------Execute Test---------------------------
Verify_RuleSet(dto, "Input", "Variable name [[ddd&]] contains invalid character(s)");
}
void Verify_IsEmpty(string mergeType)
{
//------------Setup for test--------------------------
var dto = new DataMergeDTO { MergeType = mergeType };
//------------Execute Test---------------------------
var actual = dto.IsEmpty();
//------------Assert Results-------------------------
Assert.IsTrue(actual);
}
static void Verify_RuleSet(DataMergeDTO 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 DataMergeDTO_IsEmpty_PropertiesAreNotEmpty_False()
{
//------------Setup for test--------------------------
var dto = new DataMergeDTO { InputVariable = "xxx" };
//------------Execute Test---------------------------
var actual = dto.IsEmpty();
//------------Assert Results-------------------------
Assert.IsFalse(actual);
}
public void DataMergeDTO_GetRuleSet_AtIsNotPositiveNumber_ValidateRulesReturnsFalse()
{
//------------Setup for test--------------------------
var dto = new DataMergeDTO { InputVariable = "[[a]]", At = "-1" };
//------------Execute Test---------------------------
Verify_RuleSet(dto, "At", "must be a real number");
}
public void DataMergeDTO_GetRuleSet_AtIsPositiveNumber_ValidateRulesReturnsTrue()
{
//------------Setup for test--------------------------
var dto = new DataMergeDTO { InputVariable = "[[a]]", At = "1" };
//------------Execute Test---------------------------
Verify_RuleSet(dto, "At", null);
}
public void DataMergeDTO_GetRuleSet_AtExpressionIsValid_ValidateRulesReturnsTrue()
{
//------------Setup for test--------------------------
var dto = new DataMergeDTO { InputVariable = "[[a]]", At = "[[h]]" };
//------------Execute Test---------------------------
Verify_RuleSet(dto, "At", null);
}
public void DataMergeDTO_GetRuleSet_AtIsNullOrEmpty_ValidateRulesReturnsFalse()
{
//------------Setup for test--------------------------
var dto = new DataMergeDTO { InputVariable = "[[a]]", At = "" };
//------------Execute Test---------------------------
Verify_RuleSet(dto, "At", "cannot be empty");
}
public void DataMergeDTO_ClearRow_PropertiesAreEmpty()
{
//------------Setup for test--------------------------
var dto = new DataMergeDTO { InputVariable = "xxx", MergeType = DataMergeDTO.MergeTypeNone, Alignment = "Right", At = "1", Padding = " " };
Assert.IsFalse(dto.IsEmpty());
//------------Execute Test---------------------------
dto.ClearRow();
//------------Assert Results-------------------------
Assert.IsTrue(dto.IsEmpty());
}
public void DataMergeDTO_GetRuleSet_IsEmptyIsTrue_ValidateRulesReturnsTrue()
{
//------------Setup for test--------------------------
var dto = new DataMergeDTO();
//------------Execute Test---------------------------
Verify_RuleSet(dto, "Padding", null);
Verify_RuleSet(dto, "At", null);
}
public void DataMergeDTO_GetRuleSet_PaddingIsEmpty_ValidateRulesReturnsTrue()
{
//------------Setup for test--------------------------
var dto = new DataMergeDTO { Padding = "", At = "1" };
//------------Execute Test---------------------------
Verify_RuleSet(dto, "Padding", null);
}
public void DataMergeDTO_GetRuleSet_PaddingIsNotSingleChar_ValidateRulesReturnsFalse()
{
//------------Setup for test--------------------------
var dto = new DataMergeDTO { Padding = "aa", At = "1" };
//------------Execute Test---------------------------
Verify_RuleSet(dto, "Padding", "must be a single character");
}
public void DataMergeDTO_GetRuleSet_PaddingExpressionIsInvalid_ValidateRulesReturnsFalse()
{
//------------Setup for test--------------------------
var dto = new DataMergeDTO { Padding = "h]]", At = "1" };
//------------Execute Test---------------------------
Verify_RuleSet(dto, "Padding", "Invalid expression: opening and closing brackets don't match");
}