public void Dev2LanuageParser_ParseExpressionIntoParts_WhenMalformedRecordsetWithInvalidIndex_Expect2Errors()
{
//------------Setup for test--------------------------
var dev2LanuageParser = new Dev2DataLanguageParser();
const string data = @"[[rec(&&,.a]]";
const string dl = "<DataList><rec><a/></rec></DataList>";
var compiler = DataListFactory.CreateDataListCompiler();
ErrorResultTO errors;
var dlID = compiler.ConvertTo(DataListFormat.CreateFormat(GlobalConstants._XML_Without_SystemTags), string.Empty.ToStringBuilder(), dl.ToStringBuilder(), out errors);
var bdl = compiler.FetchBinaryDataList(dlID, out errors);
if(bdl != null)
{
var intillisenseParts = bdl.FetchIntellisenseParts();
//------------Execute Test---------------------------
// ReSharper disable once RedundantAssignment
var parts = dev2LanuageParser.ParseExpressionIntoParts(data, intillisenseParts);
parts = dev2LanuageParser.ParseExpressionIntoParts(data, intillisenseParts);
//------------Assert Results-------------------------
Assert.AreEqual(1, parts.Count);
StringAssert.Contains(parts[0].Message, "Recordset name [[rec(&&,]] contains invalid character(s)");
}
else
{
Assert.Fail();
}
}
public void Dev2DataLanguageParser_ParseWithCData()
{
//---------------Set up test pack-------------------
var parser = new Dev2DataLanguageParser();
const string text = @"<![CDATA[[[]]]]>";
var parts = parser.ParseExpressionIntoParts(text, new List <IDev2DataLanguageIntellisensePart>());
Assert.AreEqual(1, parts.Count);
Assert.AreEqual(parts[0].Type, enIntellisenseResultType.Error);
Assert.AreEqual(parts[0].ErrorCode, enIntellisenseErrorCode.SyntaxError);
Assert.AreEqual(parts[0].Message, ErrorResource.VariableIsMissing);
const string textNoBrackets = @"Some text[[";
parts = parser.ParseExpressionIntoParts(textNoBrackets, new List <IDev2DataLanguageIntellisensePart>());
Assert.AreEqual(1, parts.Count);
Assert.AreEqual(parts[0].Type, enIntellisenseResultType.Error);
Assert.AreEqual(parts[0].ErrorCode, enIntellisenseErrorCode.SyntaxError);
Assert.AreEqual(parts[0].Message, ErrorResource.InvalidCloseRegion);
const string textWithAuto = @"[[varName]]";
parts = parser.ParseExpressionIntoParts(textWithAuto, new List <IDev2DataLanguageIntellisensePart>());
Assert.AreEqual(1, parts.Count);
Assert.AreEqual(enIntellisenseResultType.Error, parts[0].Type);
Assert.AreEqual(enIntellisenseErrorCode.ScalarNotFound, parts[0].ErrorCode);
Assert.AreEqual(" [[varName]] does not exist in your variable list", parts[0].Message);
}
public void ParseExpressionIntoParts_GivenExpressionInCache_ShouldReturnFromCache()
{
//---------------Set up test pack-------------------
var parser = new Dev2DataLanguageParser();
var concurrentDictionary = new ConcurrentDictionary <string, IList <IIntellisenseResult> >();
var tryAdd = concurrentDictionary.TryAdd("[[a]]", new List <IIntellisenseResult> {
IntellisenseFactory.CreateErrorResult(1, 2, null, "", enIntellisenseErrorCode.FieldNotFound, false)
});
Assert.IsTrue(tryAdd);
var fieldInfo = typeof(Dev2DataLanguageParser).GetField("_expressionCache", BindingFlags.Static | BindingFlags.NonPublic);
if (fieldInfo != null)
{
fieldInfo.SetValue(parser, concurrentDictionary);
}
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var expressionIntoParts = parser.ParseExpressionIntoParts("[[a]]", new List <IDev2DataLanguageIntellisensePart>());
//---------------Test Result -----------------------
Assert.AreEqual(1, expressionIntoParts.Count);
var error = expressionIntoParts.SingleOrDefault(result => !string.IsNullOrEmpty(result.Message));
Assert.IsNull(error);
}
public void ParseExpressionIntoParts_GivenEmptyExpression_ShouldReturnEmptyParts()
{
//---------------Set up test pack-------------------
var parser = new Dev2DataLanguageParser();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var expressionIntoParts = parser.ParseExpressionIntoParts("", new List <IDev2DataLanguageIntellisensePart>());
//---------------Test Result -----------------------
Assert.AreEqual(0, expressionIntoParts.Count);
var error = expressionIntoParts.SingleOrDefault(result => !string.IsNullOrEmpty(result.Message));
Assert.IsNull(error);
}
public void Dev2DataLanguageParser_ParseExpressionIntoParts_DataListPartsIsNull_NoIntellisenseResult()
{
//------------Setup for test--------------------------
var dev2LanuageParser = new Dev2DataLanguageParser();
//------------Execute Test---------------------------
var parts = dev2LanuageParser.ParseExpressionIntoParts("[[var]]", null);
//------------Assert Results-------------------------
Assert.AreEqual(0, parts.Count);
}
public void Dev2DataLanguageParser_ParseExpressionIntoParts_ExpressionIsEmpty_NoIntellisenseResult()
{
//------------Setup for test--------------------------
var dev2LanuageParser = new Dev2DataLanguageParser();
//------------Execute Test---------------------------
var parts = dev2LanuageParser.ParseExpressionIntoParts("", new List<IDev2DataLanguageIntellisensePart>());
//------------Assert Results-------------------------
Assert.AreEqual(0, parts.Count);
}
public void Dev2LanuageParser_ParseExpressionIntoParts_WhenMissingVariable_Expect1Error()
{
//------------Setup for test--------------------------
var dev2LanuageParser = new Dev2DataLanguageParser();
const string data = @"[[]]";
const string dl = "<DataList><rec><a/></rec></DataList>";
var compiler = DataListFactory.CreateDataListCompiler();
ErrorResultTO errors;
var dlID = compiler.ConvertTo(DataListFormat.CreateFormat(GlobalConstants._XML_Without_SystemTags), string.Empty.ToStringBuilder(), dl.ToStringBuilder(), out errors);
var bdl = compiler.FetchBinaryDataList(dlID, out errors);
if(bdl != null)
{
var intillisenseParts = bdl.FetchIntellisenseParts();
//------------Execute Test---------------------------
var parts = dev2LanuageParser.ParseExpressionIntoParts(data, intillisenseParts);
//------------Assert Results-------------------------
Assert.AreEqual(1, parts.Count);
StringAssert.Contains(parts[0].Message, "Variable [[]] is missing a name");
}
else
{
Assert.Fail();
}
}
public void Dev2LanuageParser_ParseExpressionIntoParts_WhenInValid_ExpectNoCache()
{
//------------Setup for test--------------------------
var dev2LanuageParser = new Dev2DataLanguageParser();
PrivateType p = new PrivateType(typeof(Dev2DataLanguageParser));
var cache = p.GetStaticField("_payloadCache") as ConcurrentDictionary<Tuple<string, string>, IList<IIntellisenseResult>>;
Assert.IsNotNull(cache);
cache.Clear();
Assert.AreEqual(cache.Count, 0);
const string data = @"[[rec(*123).a]]";
const string dl = "<DataList><rec><a/></rec></DataList>";
var compiler = DataListFactory.CreateDataListCompiler();
ErrorResultTO errors;
var dlID = compiler.ConvertTo(DataListFormat.CreateFormat(GlobalConstants._XML_Without_SystemTags), string.Empty.ToStringBuilder(), dl.ToStringBuilder(), out errors);
var bdl = compiler.FetchBinaryDataList(dlID, out errors);
var intillisenseParts = bdl.FetchIntellisenseParts();
//------------Execute Test---------------------------
dev2LanuageParser.ParseExpressionIntoParts(data, intillisenseParts);
//------------Assert Results-------------------------
Assert.IsNotNull(cache);
Assert.AreEqual(cache.Count, 0);
}
