public void Range_Filter_Should_Convert_Successfully()
{
// Arrange
var filter = "(Age[between]20-30)";
// Act
var stringResults = new FilterParser().Parse(filter);
var typeResults = new FilterParser().ParseAs(filter, new TypeSearchConverter <object>());
// Assert
Assert.NotNull(stringResults);
Assert.NotNull(typeResults);
Assert.NotEmpty(stringResults);
Assert.NotEmpty(typeResults.Criteria);
Assert.Equal(typeof(StringSearch.Filter.RangeCriterion), stringResults.ElementAt(0).GetType());
var stringCriterion = (StringSearch.Filter.RangeCriterion)stringResults.ElementAt(0);
Assert.Equal("Age", stringCriterion.Name);
Assert.Equal(ConditionOperatorType.Between, stringCriterion.Operator);
Assert.Equal("20", stringCriterion.StartValue);
Assert.Equal("30", stringCriterion.EndValue);
Assert.Equal(typeof(CriteriaContainer <object>), typeResults.Criteria.ElementAt(0).GetType());
var typeCriterion = typeResults.Criteria.ElementAt(0);
Assert.NotNull(typeCriterion.RangeCriterion);
var rangeCriterion = typeCriterion.RangeCriterion;
Assert.Equal("Age", rangeCriterion.Name);
Assert.Equal(RangeOperator.Between, rangeCriterion.Operator);
Assert.Equal("20", rangeCriterion.StartValue);
Assert.Equal("30", rangeCriterion.EndValue);
}
public void Nested_Filter_Should_Parse_Second_Tier_Successfully()
{
// Arrange
var filter = "(LastName[eq]Doe)[and]((FirstName[eq]John)[or](FirstName[eq]Jane))";
// Act
var parseResults = new FilterParser().Parse(filter);
// Assert
Assert.NotNull(parseResults);
Assert.NotEmpty(parseResults);
Assert.Equal(typeof(NestedCriterion), parseResults.ElementAt(1).GetType());
var nestedCriterion = (NestedCriterion)parseResults.ElementAt(1);
Assert.Equal(typeof(Criterion), nestedCriterion.Criteria.ElementAt(0).GetType());
var firstCriterion = (Criterion)nestedCriterion.Criteria.ElementAt(0);
Assert.Equal(LogicOperatorType.And, firstCriterion.LogicOperator);
Assert.Equal("FirstName", firstCriterion.Name);
Assert.Equal(ConditionOperatorType.Equals, firstCriterion.Operator);
Assert.Equal("John", firstCriterion.Value);
Assert.Equal(typeof(Criterion), nestedCriterion.Criteria.ElementAt(1).GetType());
var secondCriterion = (Criterion)nestedCriterion.Criteria.ElementAt(1);
Assert.Equal(LogicOperatorType.Or, secondCriterion.LogicOperator);
Assert.Equal("FirstName", secondCriterion.Name);
Assert.Equal(ConditionOperatorType.Equals, secondCriterion.Operator);
Assert.Equal("Jane", secondCriterion.Value);
}
public void Single_Filter_Should_Convert_Successfully()
{
// Arrange
var filter = "(Email[like]@gmail.com)";
// Act
var stringResults = new FilterParser().Parse(filter);
var typeResults = new FilterParser().ParseAs(filter, new TypeSearchConverter <object>());
// Assert
Assert.NotNull(stringResults);
Assert.NotNull(typeResults);
Assert.NotEmpty(stringResults);
Assert.NotEmpty(typeResults.Criteria);
Assert.Equal(typeof(Criterion), stringResults.ElementAt(0).GetType());
var stringCriterion = (Criterion)stringResults.ElementAt(0);
Assert.Equal("Email", stringCriterion.Name);
Assert.Equal(ConditionOperatorType.Like, stringCriterion.Operator);
Assert.Equal("@gmail.com", stringCriterion.Value);
Assert.Equal(typeof(CriteriaContainer <object>), typeResults.Criteria.ElementAt(0).GetType());
var typeCriterion = typeResults.Criteria.ElementAt(0);
Assert.NotNull(typeCriterion.SingleCriterion);
var singleCriterion = typeCriterion.SingleCriterion;
Assert.Equal("Email", singleCriterion.Name);
Assert.Equal(SingleOperator.Like, singleCriterion.Operator);
Assert.Equal("@gmail.com", singleCriterion.Value);
}
public void Nested_Filter_Should_Convert_First_Tier_Successfully()
{
// Arrange
var filter = "(LastName[eq]Doe)[and]((FirstName[eq]John)[or](FirstName[eq]Jane))";
// Act
var stringResults = new FilterParser().Parse(filter);
var typeResults = new FilterParser().ParseAs(filter, new TypeSearchConverter <object>());
// Assert
Assert.NotNull(stringResults);
Assert.NotNull(typeResults);
Assert.NotEmpty(stringResults);
Assert.NotEmpty(typeResults.Criteria);
Assert.Equal(typeof(Criterion), stringResults.ElementAt(0).GetType());
var stringCriterion = (Criterion)stringResults.ElementAt(0);
Assert.Equal("LastName", stringCriterion.Name);
Assert.Equal(ConditionOperatorType.Equals, stringCriterion.Operator);
Assert.Equal("Doe", stringCriterion.Value);
Assert.Equal(typeof(CriteriaContainer <object>), typeResults.Criteria.ElementAt(0).GetType());
var typeCriterion = typeResults.Criteria.ElementAt(0);
Assert.NotNull(typeCriterion.SingleCriterion);
var singleCriterion = typeCriterion.SingleCriterion;
Assert.Equal("LastName", singleCriterion.Name);
Assert.Equal(SingleOperator.Equals, singleCriterion.Operator);
Assert.Equal("Doe", singleCriterion.Value);
}
public void Single_Filter_Should_Parse_Property_Name_Successfully()
{
// Arrange
var filter = "(Email[like]@gmail.com)";
// Act
var parseResults = new FilterParser().Parse(filter);
// Assert
Assert.NotNull(parseResults);
Assert.NotEmpty(parseResults);
Assert.Single(parseResults);
Assert.Equal(typeof(Criterion), parseResults.ElementAt(0).GetType());
Assert.Equal("Email", ((Criterion)parseResults.ElementAt(0)).Name);
}
public void Range_Filter_Should_Parse_Property_Name_Successfully()
{
// Arrange
var filter = "(UserId[between]100-200)";
// Act
var parseResults = new FilterParser().Parse(filter);
// Assert
Assert.NotNull(parseResults);
Assert.NotEmpty(parseResults);
Assert.Single(parseResults);
Assert.Equal(typeof(RangeCriterion), parseResults.ElementAt(0).GetType());
Assert.Equal("UserId", ((RangeCriterion)parseResults.ElementAt(0)).Name);
}
public void Single_Filter_Should_Parse_Custom_Logic_Operator_Successfully()
{
// Arrange
var filter = "(FirstName[eq]John)[oreo](FirstName[eq]Jane)";
var operatorOverrides = new Dictionary <OperatorType, string>()
{
{ OperatorType.Or, "oreo" }
};
// Act
var parseResults = new FilterParser(operatorOverrides).Parse(filter);
// Assert
Assert.NotNull(parseResults);
Assert.NotEmpty(parseResults);
Assert.Equal(typeof(Criterion), parseResults.ElementAt(1).GetType());
Assert.Equal(LogicOperatorType.Or, ((Criterion)parseResults.ElementAt(1)).LogicOperator);
}
public void Range_Filter_Should_Parse_Custom_Logic_Operator_Successfully()
{
// Arrange
var filter = "(UserId[between]100-200)[else](UserId[between]300-400)";
var operatorOverrides = new Dictionary <OperatorType, string>()
{
{ OperatorType.Or, "else" }
};
// Act
var parseResults = new FilterParser(operatorOverrides).Parse(filter);
// Assert
Assert.NotNull(parseResults);
Assert.NotEmpty(parseResults);
Assert.Equal(typeof(RangeCriterion), parseResults.ElementAt(1).GetType());
Assert.Equal(LogicOperatorType.Or, ((RangeCriterion)parseResults.ElementAt(1)).LogicOperator);
}
public void Range_Filter_Should_Parse_Global_Custom_Operator_Successfully()
{
// Arrange
var filter = "(UserId[betwixt]100-200)";
var operatorOverrides = new Dictionary <OperatorType, string>()
{
{ OperatorType.Between, "betwixt" }
};
// Act
var parseResults = new FilterParser(operatorOverrides).Parse(filter);
// Assert
Assert.NotNull(parseResults);
Assert.NotEmpty(parseResults);
Assert.Single(parseResults);
Assert.Equal(typeof(RangeCriterion), parseResults.ElementAt(0).GetType());
Assert.Equal(ConditionOperatorType.Between, ((RangeCriterion)parseResults.ElementAt(0)).Operator);
}
public void Single_Filter_Should_Parse_Global_Custom_Operator_Successfully()
{
// Arrange
var filter = "(Email[%]@gmail.com)";
var operatorOverrides = new Dictionary <OperatorType, string>()
{
{ OperatorType.Like, "%" }
};
// Act
var parseResults = new FilterParser(operatorOverrides).Parse(filter);
// Assert
Assert.NotNull(parseResults);
Assert.NotEmpty(parseResults);
Assert.Single(parseResults);
Assert.Equal(typeof(Criterion), parseResults.ElementAt(0).GetType());
Assert.Equal(ConditionOperatorType.Like, ((Criterion)parseResults.ElementAt(0)).Operator);
}
public void Single_Filter_Should_Parse_Parentheses_Successfully()
{
// Arrange
// "(" and ")" are used to identify groups
var filter = "(Em)()(ail[like](@)(gmail).)((com)))))";
// Act
var parseResults = new FilterParser().Parse(filter);
// Assert
Assert.NotNull(parseResults);
Assert.NotEmpty(parseResults);
Assert.Single(parseResults);
Assert.Equal(typeof(Criterion), parseResults.ElementAt(0).GetType());
var criterion = ((Criterion)parseResults.ElementAt(0));
Assert.Equal("Em)()(ail", criterion.Name);
Assert.Equal(ConditionOperatorType.Like, criterion.Operator);
Assert.Equal("(@)(gmail).)((com))))", criterion.Value);
}
public void Nested_Filter_Should_Parse_Property_Hierarchy_Successfully()
{
// Arrange
var filter = "(LastName[eq]Doe)[and]((FirstName[eq]John)[or](FirstName[eq]Jane))";
// Act
var parseResults = new FilterParser().Parse(filter);
// Assert
Assert.NotNull(parseResults);
Assert.NotEmpty(parseResults);
Assert.Equal(typeof(Criterion), parseResults.ElementAt(0).GetType());
Assert.Equal(typeof(NestedCriterion), parseResults.ElementAt(1).GetType());
var nestedCriterion = (NestedCriterion)parseResults.ElementAt(1);
Assert.Equal(typeof(Criterion), nestedCriterion.Criteria.ElementAt(0).GetType());
Assert.Equal(typeof(Criterion), nestedCriterion.Criteria.ElementAt(1).GetType());
}
public void Single_Filter_Should_Parse_Square_Brackets_Successfully()
{
// Arrange
// "[" and "]" are used to identify operators
var filter = "(Em][][ail[like][@][gmail].][[com]]]])";
// Act
var parseResults = new FilterParser().Parse(filter);
// Assert
Assert.NotNull(parseResults);
Assert.NotEmpty(parseResults);
Assert.Single(parseResults);
Assert.Equal(typeof(Criterion), parseResults.ElementAt(0).GetType());
var criterion = ((Criterion)parseResults.ElementAt(0));
Assert.Equal("Em][][ail", criterion.Name);
Assert.Equal(ConditionOperatorType.Like, criterion.Operator);
Assert.Equal("[@][gmail].][[com]]]]", criterion.Value);
}
public void Range_Filter_Should_Parse_Parentheses_Successfully()
{
// Arrange
// "(" and ")" are used to identify groups
var filter = "(U)s(e)r(Id[between]1(0)0-((200))))";
// Act
var parseResults = new FilterParser().Parse(filter);
// Assert
Assert.NotNull(parseResults);
Assert.NotEmpty(parseResults);
Assert.Single(parseResults);
Assert.Equal(typeof(RangeCriterion), parseResults.ElementAt(0).GetType());
var criterion = ((RangeCriterion)parseResults.ElementAt(0));
Assert.Equal("U)s(e)r(Id", criterion.Name);
Assert.Equal(ConditionOperatorType.Between, criterion.Operator);
Assert.Equal("1(0)0", criterion.StartValue);
Assert.Equal("((200)))", criterion.EndValue);
}
public void Range_Filter_Should_Parse_Square_Brackets_Successfully()
{
// Arrange
// "[" and "]" are used to identify operators
var filter = "(U]s[e]r[Id[between]1[0]0-[[200]]])";
// Act
var parseResults = new FilterParser().Parse(filter);
// Assert
Assert.NotNull(parseResults);
Assert.NotEmpty(parseResults);
Assert.Single(parseResults);
Assert.Equal(typeof(RangeCriterion), parseResults.ElementAt(0).GetType());
var criterion = ((RangeCriterion)parseResults.ElementAt(0));
Assert.Equal("U]s[e]r[Id", criterion.Name);
Assert.Equal(ConditionOperatorType.Between, criterion.Operator);
Assert.Equal("1[0]0", criterion.StartValue);
Assert.Equal("[[200]]]", criterion.EndValue);
}
public void Nested_Filter_Should_Parse_First_Tier_Successfully()
{
// Arrange
var filter = "(LastName[eq]Doe)[and]((FirstName[eq]John)[or](FirstName[eq]Jane))";
// Act
var parseResults = new FilterParser().Parse(filter);
// Assert
Assert.NotNull(parseResults);
Assert.NotEmpty(parseResults);
Assert.Equal(typeof(Criterion), parseResults.ElementAt(0).GetType());
var criterion = (Criterion)parseResults.ElementAt(0);
Assert.Equal("LastName", criterion.Name);
Assert.Equal(ConditionOperatorType.Equals, criterion.Operator);
Assert.Equal("Doe", criterion.Value);
Assert.Equal(typeof(NestedCriterion), parseResults.ElementAt(1).GetType());
}
public void Range_Filter_Should_Parse_Global_And_Local_Custom_Operator_Successfully()
{
// Arrange
var filter = "(UserId[betwixt]100-200)[and](UserId[not_in]300-400)";
var globalOverride = new Dictionary <OperatorType, string>()
{
{ OperatorType.Between, "betwixt" }
};
var localOverride = new Dictionary <OperatorType, string>()
{
{ OperatorType.NotBetween, "not_in" }
};
// Act
var parseResults = new FilterParser(globalOverride).Parse(filter, localOverride);
// Assert
Assert.NotNull(parseResults);
Assert.NotEmpty(parseResults);
Assert.Equal(typeof(RangeCriterion), parseResults.ElementAt(0).GetType());
Assert.Equal(ConditionOperatorType.Between, ((RangeCriterion)parseResults.ElementAt(0)).Operator);
Assert.Equal(typeof(RangeCriterion), parseResults.ElementAt(1).GetType());
Assert.Equal(ConditionOperatorType.NotBetween, ((RangeCriterion)parseResults.ElementAt(1)).Operator);
}
public void Single_Filter_Should_Parse_Global_And_Local_Custom_Operator_Successfully()
{
// Arrange
var filter = "(Email[SimilarTo]@gmail.com)[or](Email[EndsWith]@gmail.com)";
var localOverride = new Dictionary <OperatorType, string>()
{
{ OperatorType.Like, "SimilarTo" }
};
var globalOverride = new Dictionary <OperatorType, string>()
{
{ OperatorType.EndsWith, "EndsWith" }
};
// Act
var parseResults = new FilterParser(globalOverride).Parse(filter, localOverride);
// Assert
Assert.NotNull(parseResults);
Assert.NotEmpty(parseResults);
Assert.Equal(typeof(Criterion), parseResults.ElementAt(0).GetType());
Assert.Equal(ConditionOperatorType.Like, ((Criterion)parseResults.ElementAt(0)).Operator);
Assert.Equal(typeof(Criterion), parseResults.ElementAt(1).GetType());
Assert.Equal(ConditionOperatorType.EndsWith, ((Criterion)parseResults.ElementAt(1)).Operator);
}
public void Nested_Filter_Should_Convert_Second_Tier_Successfully()
{
// Arrange
var filter = "(LastName[eq]Doe)[and]((FirstName[eq]John)[or](FirstName[eq]Jane))";
// Act
var stringResults = new FilterParser().Parse(filter);
var typeResults = new FilterParser().ParseAs(filter, new TypeSearchConverter <object>());
// Assert
Assert.NotNull(stringResults);
Assert.NotNull(typeResults);
Assert.NotEmpty(stringResults);
Assert.NotEmpty(typeResults.Criteria);
// StringSearch
Assert.Equal(typeof(NestedCriterion), stringResults.ElementAt(1).GetType());
var stringNestedCriterion = (NestedCriterion)stringResults.ElementAt(1);
Assert.Equal(typeof(Criterion), stringNestedCriterion.Criteria.ElementAt(0).GetType());
var stringFirstCriterion = (Criterion)stringNestedCriterion.Criteria.ElementAt(0);
Assert.Equal(LogicOperatorType.And, stringFirstCriterion.LogicOperator);
Assert.Equal("FirstName", stringFirstCriterion.Name);
Assert.Equal(ConditionOperatorType.Equals, stringFirstCriterion.Operator);
Assert.Equal("John", stringFirstCriterion.Value);
Assert.Equal(typeof(Criterion), stringNestedCriterion.Criteria.ElementAt(1).GetType());
var stringSecondCriterion = (Criterion)stringNestedCriterion.Criteria.ElementAt(1);
Assert.Equal(LogicOperatorType.Or, stringSecondCriterion.LogicOperator);
Assert.Equal("FirstName", stringSecondCriterion.Name);
Assert.Equal(ConditionOperatorType.Equals, stringSecondCriterion.Operator);
Assert.Equal("Jane", stringSecondCriterion.Value);
// TypeSearch
Assert.Equal(typeof(CriteriaContainer <object>), typeResults.Criteria.ElementAt(1).GetType());
var typeCriterion = typeResults.Criteria.ElementAt(1);
Assert.NotNull(typeCriterion.NestedFilter);
var nestedCriteria = typeCriterion.NestedFilter;
Assert.Equal(typeof(CriteriaContainer <object>), nestedCriteria.Criteria.ElementAt(0).GetType());
var typeNestedCriterion1 = nestedCriteria.Criteria.ElementAt(0);
Assert.NotNull(typeNestedCriterion1.SingleCriterion);
var typeFirstCriterion = typeNestedCriterion1.SingleCriterion;
Assert.Equal(LogicalOperator.And, typeNestedCriterion1.Operator);
Assert.Equal("FirstName", typeFirstCriterion.Name);
Assert.Equal(SingleOperator.Equals, typeFirstCriterion.Operator);
Assert.Equal("John", typeFirstCriterion.Value);
Assert.Equal(typeof(CriteriaContainer <object>), nestedCriteria.Criteria.ElementAt(1).GetType());
var typeNestedCriterion2 = nestedCriteria.Criteria.ElementAt(1);
Assert.NotNull(typeNestedCriterion2.SingleCriterion);
var typeSecondCriterion = typeNestedCriterion2.SingleCriterion;
Assert.Equal(LogicalOperator.Or, typeNestedCriterion2.Operator);
Assert.Equal("FirstName", typeSecondCriterion.Name);
Assert.Equal(SingleOperator.Equals, typeSecondCriterion.Operator);
Assert.Equal("Jane", typeSecondCriterion.Value);
}
