public void IsValidExpressionRule_Check_VariableIsEmptyString_RaisesNoError() { //------------Setup for test-------------------------- var validator = new IsValidExpressionRule(() => "", "<ADL><rec><field1/></rec><var1/></ADL>"); //------------Execute Test--------------------------- var result = validator.Check(); //------------Assert Results------------------------- Assert.IsNull(result); }
public void IsValidExpressionRule_Check_VariableIsEmptyString_RaisesNoError() { //------------Setup for test-------------------------- var validator = new IsValidExpressionRule(() => "", "<ADL><rec><field1/></rec><var1/></ADL>", new VariableUtils()); //------------Execute Test--------------------------- var result = validator.Check(); //------------Assert Results------------------------- Assert.IsNull(result); }
public void IsValidExpressionRule_Check_MalformedVariable_RaisesAnError() { //------------Setup for test-------------------------- var validator = new IsValidExpressionRule(() => "h]]", "<ADL><rec><field1/></rec><var1/></ADL>"); //------------Execute Test--------------------------- var errorInfo = validator.Check(); //------------Assert Results------------------------- Assert.IsNotNull(errorInfo); Assert.AreEqual("The - Invalid expression: opening and closing brackets don't match.", errorInfo.Message); }
public void IsValidExpressionRule_Check_InvalidVariable_RaisesError() { //------------Setup for test-------------------------- var validator = new IsValidExpressionRule(() => "[[res#]]", "<ADL><rec><field1/></rec><var1/></ADL>"); //------------Execute Test--------------------------- var errorInfo = validator.Check(); //------------Assert Results------------------------- Assert.IsNotNull(errorInfo); Assert.AreEqual("The - Variable name [[res#]] contains invalid character(s)", errorInfo.Message); }
public void IsValidExpressionRule_Check_MalformedVariable_RaisesAnError() { //------------Setup for test-------------------------- var validator = new IsValidExpressionRule(() => "h]]", "<ADL><rec><field1/></rec><var1/></ADL>", new VariableUtils()); //------------Execute Test--------------------------- var errorInfo = validator.Check(); //------------Assert Results------------------------- Assert.IsNotNull(errorInfo); Assert.AreEqual(Warewolf.Resource.Errors.ErrorResource.IsValidExpressionRuleErrorTest, errorInfo.Message); }
public void IsValidExpressionRule_Check_InvalidVariable_RaisesError() { //------------Setup for test-------------------------- var validator = new IsValidExpressionRule(() => "[[res#]]", "<ADL><rec><field1/></rec><var1/></ADL>", new VariableUtils()); //------------Execute Test--------------------------- var errorInfo = validator.Check(); //------------Assert Results------------------------- Assert.IsNotNull(errorInfo); Assert.AreEqual("Variable name [[res#]] contains invalid character(s). Only use alphanumeric _ and - ", errorInfo.Message); }
public void IsValidExpressionRule_Check_VariableExpressionIsValid_ReturnsNoError() { //------------Setup for test-------------------------- const string trueString = "True"; const string noneString = "None"; var datalist = string.Format("<DataList><var Description=\"{0}\" IsEditable=\"\" ColumnIODirection=\"{1}\" /><a Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /><rec Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" ><set Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /></rec></DataList>", trueString, noneString); var rule = new IsValidExpressionRule(() => "[[a]]", datalist, new VariableUtils()) { LabelText = "MyVar" }; //------------Execute Test--------------------------- var errorInfo = rule.Check(); //------------Assert Results------------------------- Assert.IsNull(errorInfo); }
public void IsValidExpressionRule_Check_VaribaleExpressionHasSpecialCharacter_ReturnsAnError() { //------------Setup for test-------------------------- const string trueString = "True"; const string noneString = "None"; var datalist = string.Format("<DataList><var Description=\"{0}\" IsEditable=\"\" ColumnIODirection=\"{1}\" /><a Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /><rec Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" ><set Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /></rec></DataList>", trueString, noneString); var rule = new IsValidExpressionRule(() => "[[a$]]", datalist, new VariableUtils()) { LabelText = "MyVar" }; //------------Execute Test--------------------------- var errorInfo = rule.Check(); //------------Assert Results------------------------- Assert.IsNotNull(errorInfo); Assert.AreEqual("MyVar - Variable name [[a$]] contains invalid character(s). Only use alphanumeric _ and - ", errorInfo.Message); }
public void IsValidExpressionRule_Check_VariableExpressionHasAnUnderscore_ReturnsAnError() { //------------Setup for test-------------------------- const string trueString = "True"; const string noneString = "None"; var datalist = string.Format("<DataList><var Description=\"{0}\" IsEditable=\"\" ColumnIODirection=\"{1}\" /><a Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /><rec Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" ><set Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /></rec></DataList>", trueString, noneString); var rule = new IsValidExpressionRule(() => "[[a_b]]", datalist, new VariableUtils()) { LabelText = "MyVar" }; //------------Execute Test--------------------------- var errorInfo = rule.Check(); //------------Assert Results------------------------- Assert.IsNotNull(errorInfo); Assert.AreEqual("MyVar - [[a_b]] does not exist in your variable list", errorInfo.Message); }
public void IsValidExpressionRule_Check_RecordsetHasAnInvalidIndex_ReturnsAnError() { //------------Setup for test-------------------------- 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}\" /><rec Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" ><set Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /></rec></DataList>", trueString, noneString); var rule = new IsValidExpressionRule(() => "[[rec(**).set]]", datalist, new VariableUtils()) { LabelText = "MyRecSet" }; //------------Execute Test--------------------------- var errorInfo = rule.Check(); //------------Assert Results------------------------- Assert.IsNotNull(errorInfo); Assert.AreEqual("MyRecSet - Recordset index (**) contains invalid character(s)", errorInfo.Message); }
public void IsValidExpressionRule_Check_RecordsetHasANegativeIndex_ReturnsAnError() { //------------Setup for test-------------------------- 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}\" /><rec Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" ><set Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /></rec></DataList>", trueString, noneString); var rule = new IsValidExpressionRule(() => "[[rec(-1).set]]", datalist) { LabelText = "MyRecSet" }; //------------Execute Test--------------------------- var errorInfo = rule.Check(); //------------Assert Results------------------------- Assert.IsNotNull(errorInfo); Assert.AreEqual(Warewolf.Resource.Errors.ErrorResource.IsValidExpressionRuleIndexZeroErrorTest, errorInfo.Message); }
static void ValidateVariable(string fieldName, IDataListCompiler compiler, IDSFDataObject dataObject, out ErrorResultTO errors) { fieldName = DataListUtil.IsValueRecordset(fieldName) ? DataListUtil.ReplaceRecordsetIndexWithBlank(fieldName) : fieldName; var datalist = compiler.ConvertFrom(dataObject.DataListID, DataListFormat.CreateFormat(GlobalConstants._Studio_XML), Dev2.DataList.Contract.enTranslationDepth.Shape, out errors).ToString(); if (!string.IsNullOrEmpty(datalist)) { var isValidExpr = new IsValidExpressionRule(() => fieldName, datalist) { LabelText = fieldName }; var errorInfo = isValidExpr.Check(); if (errorInfo != null) { errors.AddError(errorInfo.Message); } } }
void ValidateInput(string datalist, ErrorResultTO allErrors, string input) { var splitIntoRegions = DataListCleaningUtils.FindAllLanguagePieces(input); foreach (var region in splitIntoRegions) { string region1 = region; var isValidExpr = new IsValidExpressionRule(() => region1, datalist) { LabelText = "Input1" }; var errValid = isValidExpr.Check(); if (errValid != null) { var validationError = new ErrorResultTO(); validationError.AddError(errValid.Message); allErrors.MergeErrors(validationError); } } }
// ReSharper restore RedundantOverridenMember protected override void OnExecute(NativeActivityContext context) { _debugOutputs.Clear(); _debugInputs.Clear(); IDSFDataObject dataObject = context.GetExtension <IDSFDataObject>(); IDataListCompiler compiler = DataListFactory.CreateDataListCompiler(); IDev2DataListUpsertPayloadBuilder <string> toUpsert = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder(false); toUpsert.IsDebug = (dataObject.IsDebugMode()); toUpsert.ResourceID = dataObject.ResourceID; InitializeDebug(dataObject); ErrorResultTO errors = new ErrorResultTO(); ErrorResultTO allErrors = new ErrorResultTO(); Guid executionId = DataListExecutionID.Get(context); try { if (!errors.HasErrors()) { foreach (ActivityDTO t in FieldsCollection) { if (!string.IsNullOrEmpty(t.FieldName)) { var fieldName = t.FieldName; fieldName = DataListUtil.IsValueRecordset(fieldName) ? DataListUtil.ReplaceRecordsetIndexWithBlank(fieldName) : fieldName; var datalist = compiler.ConvertFrom(dataObject.DataListID, DataListFormat.CreateFormat(GlobalConstants._Studio_XML), enTranslationDepth.Shape, out errors).ToString(); if (!string.IsNullOrEmpty(datalist)) { var isValidExpr = new IsValidExpressionRule(() => fieldName, datalist) { LabelText = fieldName }; var errorInfo = isValidExpr.Check(); if (errorInfo != null) { t.FieldName = ""; errors.AddError(errorInfo.Message); } allErrors.MergeErrors(errors); } string eval = t.FieldValue; if (eval.StartsWith("@")) { eval = GetEnviromentVariable(dataObject, context, eval); } toUpsert.Add(t.FieldName, eval); } } compiler.Upsert(executionId, toUpsert, out errors); allErrors.MergeErrors(errors); if (dataObject.IsDebugMode() && !allErrors.HasErrors()) { AddDebugTos(toUpsert, executionId); } allErrors.MergeErrors(errors); } } catch (Exception e) { Dev2Logger.Log.Error(e); allErrors.AddError(e.Message); } finally { // Handle Errors var hasErrors = allErrors.HasErrors(); if (hasErrors) { DisplayAndWriteError("DsfAssignActivity", allErrors); compiler.UpsertSystemTag(dataObject.DataListID, enSystemTag.Dev2Error, allErrors.MakeDataListReady(), out errors); } if (dataObject.IsDebugMode()) { if (hasErrors) { AddDebugTos(toUpsert, executionId); } DispatchDebugState(context, StateType.Before); DispatchDebugState(context, StateType.After); } } }
// ReSharper restore RedundantOverridenMember protected override void OnExecute(NativeActivityContext context) { _debugInputs = new List <DebugItem>(); _debugOutputs = new List <DebugItem>(); IDSFDataObject dataObject = context.GetExtension <IDSFDataObject>(); IDataListCompiler compiler = DataListFactory.CreateDataListCompiler(); IDev2MergeOperations mergeOperations = new Dev2MergeOperations(); ErrorResultTO allErrors = new ErrorResultTO(); ErrorResultTO errorResultTo = new ErrorResultTO(); Guid executionId = DataListExecutionID.Get(context); IDev2DataListUpsertPayloadBuilder <string> toUpsert = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder(true); toUpsert.IsDebug = dataObject.IsDebugMode(); toUpsert.ResourceID = dataObject.ResourceID; InitializeDebug(dataObject); try { CleanArguments(MergeCollection); if (MergeCollection.Count <= 0) { return; } IDev2IteratorCollection iteratorCollection = Dev2ValueObjectFactory.CreateIteratorCollection(); allErrors.MergeErrors(errorResultTo); Dictionary <int, List <IDev2DataListEvaluateIterator> > listOfIterators = new Dictionary <int, List <IDev2DataListEvaluateIterator> >(); #region Create a iterator for each row in the data grid in the designer so that the right iteration happen on the data int dictionaryKey = 0; foreach (DataMergeDTO row in MergeCollection) { IBinaryDataListEntry inputVariableExpressionEntry = compiler.Evaluate(executionId, enActionType.User, row.InputVariable, false, out errorResultTo); allErrors.MergeErrors(errorResultTo); IBinaryDataListEntry atExpressionEntry = compiler.Evaluate(executionId, enActionType.User, row.At, false, out errorResultTo); allErrors.MergeErrors(errorResultTo); IBinaryDataListEntry paddingExpressionEntry = compiler.Evaluate(executionId, enActionType.User, row.Padding, false, out errorResultTo); allErrors.MergeErrors(errorResultTo); var fieldName = row.InputVariable; var splitIntoRegions = DataListCleaningUtils.FindAllLanguagePieces(fieldName); var datalist = compiler.ConvertFrom(dataObject.DataListID, DataListFormat.CreateFormat(GlobalConstants._Studio_XML), enTranslationDepth.Shape, out errorResultTo).ToString(); if (!string.IsNullOrEmpty(datalist)) { foreach (var region in splitIntoRegions) { var r = DataListUtil.IsValueRecordset(region) ? DataListUtil.ReplaceRecordsetIndexWithBlank(region) : region; var isValidExpr = new IsValidExpressionRule(() => r, datalist) { LabelText = fieldName }; var errorInfo = isValidExpr.Check(); if (errorInfo != null) { row.InputVariable = ""; errorResultTo.AddError(errorInfo.Message); } allErrors.MergeErrors(errorResultTo); } } allErrors.MergeErrors(errorResultTo); if (dataObject.IsDebugMode()) { DebugItem debugItem = new DebugItem(); AddDebugItem(new DebugItemStaticDataParams("", (MergeCollection.IndexOf(row) + 1).ToString(CultureInfo.InvariantCulture)), debugItem); AddDebugItem(new DebugItemVariableParams(row.InputVariable, "", inputVariableExpressionEntry, executionId), debugItem); AddDebugItem(new DebugItemStaticDataParams(row.MergeType, "With"), debugItem); AddDebugItem(new DebugItemVariableParams(row.At, "Using", atExpressionEntry, executionId), debugItem); AddDebugItem(new DebugItemVariableParams(row.Padding, "Pad", paddingExpressionEntry, executionId), debugItem); //Old workflows don't have this set. if (row.Alignment == null) { row.Alignment = string.Empty; } AddDebugItem(DataListUtil.IsEvaluated(row.Alignment) ? new DebugItemStaticDataParams("", row.Alignment, "Align") : new DebugItemStaticDataParams(row.Alignment, "Align"), debugItem); _debugInputs.Add(debugItem); } IDev2DataListEvaluateIterator itr = Dev2ValueObjectFactory.CreateEvaluateIterator(inputVariableExpressionEntry); IDev2DataListEvaluateIterator atItr = Dev2ValueObjectFactory.CreateEvaluateIterator(atExpressionEntry); IDev2DataListEvaluateIterator padItr = Dev2ValueObjectFactory.CreateEvaluateIterator(paddingExpressionEntry); iteratorCollection.AddIterator(itr); iteratorCollection.AddIterator(atItr); iteratorCollection.AddIterator(padItr); listOfIterators.Add(dictionaryKey, new List <IDev2DataListEvaluateIterator> { itr, atItr, padItr }); dictionaryKey++; } #endregion #region Iterate and Merge Data if (!allErrors.HasErrors()) { while (iteratorCollection.HasMoreData()) { int pos = 0; foreach (var iterator in listOfIterators) { var val = iteratorCollection.FetchNextRow(iterator.Value[0]); var at = iteratorCollection.FetchNextRow(iterator.Value[1]); var pad = iteratorCollection.FetchNextRow(iterator.Value[2]); if (val != null) { if (at != null) { if (pad != null) { if (MergeCollection[pos].MergeType == "Index") { if (string.IsNullOrEmpty(at.TheValue)) { allErrors.AddError("The 'Using' value cannot be blank."); } int atValue; if (!Int32.TryParse(at.TheValue, out atValue) || atValue < 0) { allErrors.AddError("The 'Using' value must be a real number."); } if (pad.TheValue.Length > 1) { allErrors.AddError("'Padding' must be a single character"); } } else { if (MergeCollection[pos].MergeType == "Chars" && string.IsNullOrEmpty(at.TheValue)) { allErrors.AddError("The 'Using' value cannot be blank."); } } mergeOperations.Merge(val.TheValue, MergeCollection[pos].MergeType, at.TheValue, pad.TheValue, MergeCollection[pos].Alignment); pos++; } } } } } if (!allErrors.HasErrors()) { if (string.IsNullOrEmpty(Result)) { AddDebugOutputItem(new DebugItemStaticDataParams("", "")); } else { var rule = new IsSingleValueRule(() => Result); var single = rule.Check(); if (single != null) { allErrors.AddError(single.Message); } else { toUpsert.Add(Result, mergeOperations.MergeData.ToString()); toUpsert.FlushIterationFrame(); compiler.Upsert(executionId, toUpsert, out errorResultTo); allErrors.MergeErrors(errorResultTo); if (dataObject.IsDebugMode() && !allErrors.HasErrors()) { foreach (var debugOutputTo in toUpsert.DebugOutputs) { if (debugOutputTo.LeftEntry != null && debugOutputTo.TargetEntry != null) { AddDebugOutputItem(new DebugItemVariableParams(debugOutputTo)); } } } } } } } #endregion Iterate and Merge Data } catch (Exception e) { Dev2Logger.Log.Error("DSFDataMerge", e); allErrors.AddError(e.Message); } finally { #region Handle Errors if (allErrors.HasErrors()) { if (dataObject.IsDebugMode()) { AddDebugOutputItem(new DebugItemStaticDataParams("", Result, "")); } DisplayAndWriteError("DsfDataMergeActivity", allErrors); compiler.UpsertSystemTag(dataObject.DataListID, enSystemTag.Dev2Error, allErrors.MakeDataListReady(), out errorResultTo); compiler.Upsert(executionId, Result, (string)null, out errorResultTo); } if (dataObject.IsDebugMode()) { DispatchDebugState(context, StateType.Before); DispatchDebugState(context, StateType.After); } #endregion } }
// ReSharper restore RedundantOverridenMember /// <summary> /// The execute method that is called when the activity is executed at run time and will hold all the logic of the activity /// </summary> protected override void OnExecute(NativeActivityContext context) { _debugInputs = new List <DebugItem>(); _debugOutputs = new List <DebugItem>(); _indexCounter = 0; IDSFDataObject dataObject = context.GetExtension <IDSFDataObject>(); IDataListCompiler compiler = DataListFactory.CreateDataListCompiler(); ErrorResultTO allErrors = new ErrorResultTO(); ErrorResultTO errors; Guid executionId = DataListExecutionID.Get(context); IDev2DataListUpsertPayloadBuilder <string> toUpsert = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder(false); InitializeDebug(dataObject); try { CleanArgs(); toUpsert.IsDebug = dataObject.IsDebugMode(); foreach (var item in ConvertCollection) { try { _indexCounter++; // Travis.Frisinger - This needs to be in the ViewModel not here ;) if (item.ToExpression == string.Empty) { item.ToExpression = item.FromExpression; } IsSingleValueRule.ApplyIsSingleValueRule(item.FromExpression, allErrors); var fieldName = item.FromExpression; fieldName = DataListUtil.IsValueRecordset(fieldName) ? DataListUtil.ReplaceRecordsetIndexWithBlank(fieldName) : fieldName; var datalist = compiler.ConvertFrom(dataObject.DataListID, DataListFormat.CreateFormat(GlobalConstants._Studio_XML), Dev2.DataList.Contract.enTranslationDepth.Shape, out errors); if (!datalist.IsNullOrEmpty()) { var isValidExpr = new IsValidExpressionRule(() => fieldName, datalist.ToString()) { LabelText = fieldName }; var errorInfo = isValidExpr.Check(); if (errorInfo != null) { item.FromExpression = ""; errors.AddError(errorInfo.Message); } allErrors.MergeErrors(errors); } IBinaryDataListEntry tmp = compiler.Evaluate(executionId, enActionType.User, item.FromExpression, false, out errors); if (dataObject.IsDebugMode()) { AddDebugInputItem(item.FromExpression, tmp, executionId, item.FromType, item.ToType); } allErrors.MergeErrors(errors); if (tmp != null) { IDev2DataListEvaluateIterator itr = Dev2ValueObjectFactory.CreateEvaluateIterator(tmp); IBaseConverter from = _fac.CreateConverter((enDev2BaseConvertType)Dev2EnumConverter.GetEnumFromStringDiscription(item.FromType, typeof(enDev2BaseConvertType))); IBaseConverter to = _fac.CreateConverter((enDev2BaseConvertType)Dev2EnumConverter.GetEnumFromStringDiscription(item.ToType, typeof(enDev2BaseConvertType))); IBaseConversionBroker broker = _fac.CreateBroker(from, to); // process result information while (itr.HasMoreRecords()) { IList <IBinaryDataListItem> cols = itr.FetchNextRowData(); foreach (IBinaryDataListItem c in cols) { // set up live flushing iterator details if (c.IsDeferredRead) { if (toUpsert != null) { toUpsert.HasLiveFlushing = true; toUpsert.LiveFlushingLocation = executionId; } } int indexToUpsertTo = c.ItemCollectionIndex; string val = string.IsNullOrEmpty(c.TheValue) ? "" : broker.Convert(c.TheValue); string expression = item.ToExpression; if (DataListUtil.IsValueRecordset(item.ToExpression) && DataListUtil.GetRecordsetIndexType(item.ToExpression) == enRecordsetIndexType.Star) { expression = item.ToExpression.Replace(GlobalConstants.StarExpression, indexToUpsertTo.ToString(CultureInfo.InvariantCulture)); } toUpsert.Add(expression, val); if (toUpsert != null && toUpsert.HasLiveFlushing) { toUpsert.FlushIterationFrame(); toUpsert = null; } } } } } catch (Exception e) { Dev2Logger.Log.Error("DSFBaseConvert", e); allErrors.AddError(e.Message); } finally { if (allErrors.HasErrors()) { toUpsert.Add(item.ToExpression, null); } } } if (toUpsert != null && toUpsert.HasLiveFlushing) { try { toUpsert.FlushIterationFrame(); } catch (Exception e) { Dev2Logger.Log.Error("DSFBaseConvert", e); allErrors.AddError(e.Message); } } else { compiler.Upsert(executionId, toUpsert, out errors); allErrors.MergeErrors(errors); } if (!allErrors.HasErrors() && toUpsert != null) { var outIndex = 1; foreach (var debugOutputTo in toUpsert.DebugOutputs) { var debugItem = new DebugItem(); AddDebugItem(new DebugItemStaticDataParams("", outIndex.ToString(CultureInfo.InvariantCulture)), debugItem); AddDebugItem(new DebugItemVariableParams(debugOutputTo), debugItem); _debugOutputs.Add(debugItem); outIndex++; } } } catch (Exception e) { Dev2Logger.Log.Error("DSFBaseConvert", e); allErrors.AddError(e.Message); } finally { // Handle Errors var hasErrors = allErrors.HasErrors(); if (hasErrors) { DisplayAndWriteError("DsfBaseConvertActivity", allErrors); compiler.UpsertSystemTag(dataObject.DataListID, enSystemTag.Dev2Error, allErrors.MakeDataListReady(), out errors); } if (dataObject.IsDebugMode()) { DispatchDebugState(context, StateType.Before); DispatchDebugState(context, StateType.After); } } }
public void IsValidExpressionRule_Check_VariableExpressionIsValid_ReturnsNoError() { //------------Setup for test-------------------------- const string trueString = "True"; const string noneString = "None"; var datalist = string.Format("<DataList><var Description=\"{0}\" IsEditable=\"\" ColumnIODirection=\"{1}\" /><a Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /><rec Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" ><set Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /></rec></DataList>", trueString, noneString); var rule = new IsValidExpressionRule(() => "[[a]]", datalist) { LabelText = "MyVar" }; //------------Execute Test--------------------------- var errorInfo = rule.Check(); //------------Assert Results------------------------- Assert.IsNull(errorInfo); }
public void IsValidExpressionRule_Check_VariableExpressionHasAnUnderscore_ReturnsAnError() { //------------Setup for test-------------------------- const string trueString = "True"; const string noneString = "None"; var datalist = string.Format("<DataList><var Description=\"{0}\" IsEditable=\"\" ColumnIODirection=\"{1}\" /><a Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /><rec Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" ><set Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /></rec></DataList>", trueString, noneString); var rule = new IsValidExpressionRule(() => "[[a_b]]", datalist) { LabelText = "MyVar" }; //------------Execute Test--------------------------- var errorInfo = rule.Check(); //------------Assert Results------------------------- Assert.IsNotNull(errorInfo); Assert.AreEqual("MyVar - [[a_b]] does not exist in your variable list", errorInfo.Message); }
private IDev2Tokenizer CreateSplitPattern(ref string stringToSplit, IEnumerable <DataSplitDTO> args, IDataListCompiler compiler, Guid dlId, out ErrorResultTO errors) { Dev2TokenizerBuilder dtb = new Dev2TokenizerBuilder { ToTokenize = stringToSplit, ReverseOrder = ReverseOrder }; errors = new ErrorResultTO(); foreach (DataSplitDTO t in args) { var fieldName = t.OutputVariable; t.At = t.At ?? ""; if (!string.IsNullOrEmpty(_datalistString)) { var isValidExpr = new IsValidExpressionRule(() => fieldName, _datalistString) { LabelText = fieldName }; var errorInfo = isValidExpr.Check(); if (errorInfo != null) { errors.AddError(errorInfo.Message); continue; } } IBinaryDataListEntry entry; string error; switch (t.SplitType) { case "Index": try { entry = compiler.Evaluate(dlId, enActionType.User, t.At, false, out errors); string index = DataListUtil.GetValueAtIndex(entry, 1, out error); int indexNum = Convert.ToInt32(index); if (indexNum > 0) { dtb.AddIndexOp(indexNum); } } catch (Exception ex) { errors.AddError(ex.Message); } break; case "End": dtb.AddEoFOp(); break; case "Space": dtb.AddTokenOp(" ", t.Include); break; case "Tab": dtb.AddTokenOp("\t", t.Include); break; case "New Line": if (stringToSplit.Contains("\r\n")) { dtb.AddTokenOp("\r\n", t.Include); } else if (stringToSplit.Contains("\n")) { dtb.AddTokenOp("\n", t.Include); } else if (stringToSplit.Contains("\r")) { dtb.AddTokenOp("\r", t.Include); } break; case "Chars": if (!string.IsNullOrEmpty(t.At)) { entry = compiler.Evaluate(dlId, enActionType.User, t.At, false, out errors); string val = DataListUtil.GetValueAtIndex(entry, 1, out error); string escape = t.EscapeChar; if (!String.IsNullOrEmpty(escape)) { entry = compiler.Evaluate(dlId, enActionType.User, t.EscapeChar, false, out errors); escape = DataListUtil.GetValueAtIndex(entry, 1, out error); } dtb.AddTokenOp(val, t.Include, escape); } break; } _indexCounter++; } return(string.IsNullOrEmpty(dtb.ToTokenize) || errors.HasErrors() ? null : dtb.Generate()); }
public void IsValidExpressionRule_Check_RecordsetHasAnInvalidIndex_ReturnsAnError() { //------------Setup for test-------------------------- 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}\" /><rec Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" ><set Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /></rec></DataList>", trueString, noneString); var rule = new IsValidExpressionRule(() => "[[rec(**).set]]", datalist) { LabelText = "MyRecSet" }; //------------Execute Test--------------------------- var errorInfo = rule.Check(); //------------Assert Results------------------------- Assert.IsNotNull(errorInfo); Assert.AreEqual("MyRecSet - Recordset index (**) contains invalid character(s)", errorInfo.Message); }