private static Expression <Func <T, bool> > GetContainsPredicateFromSearchQueryRule(SearchQueryRule <T> searchQueryRule, object value)
{
Expression <Func <T, bool> > predicate;
// There are 3 cases that needs to be handled:
// 1) The property is of type String: Perform a 'Contains' operation on the string property
// 2) The property is of type IEnumerable<>: Perform a 'Contains' operation on the IEnumerable<> property
// 3) The property is a general type, like ID or Guid: Perform an 'Equals' operation on the property
Type propertyTypeFromPropertySelector =
ExpressionUtils.GetPropertyTypeFromPropertySelector(searchQueryRule.PropertySelector);
if (propertyTypeFromPropertySelector == typeof(string))
{
predicate = ExpressionConversionService.ToContains(searchQueryRule.PropertySelector, (string)value);
}
else if (typeof(IEnumerable).IsAssignableFrom(propertyTypeFromPropertySelector))
{
predicate = ExpressionConversionService.ToEnumerableContains(searchQueryRule.PropertySelector, value);
}
else
{
predicate = ExpressionConversionService.ToEquals(searchQueryRule.PropertySelector, value);
}
return(predicate);
}
public void ToBetween_PropertySelectorTypeAndMinAndMaxValuesAreNotOfMatchingType_ThrowsException(string propertyName, object minValue, object maxValue)
{
// Arrange
var propertySelector = ExpressionUtils.GetPropertySelector <TestIndexableEntity, object>(propertyName);
// Act
Action act = () => ExpressionConversionService.ToBetween(propertySelector, minValue, maxValue);
// Assert
act.ShouldThrow <InvalidOperationException>();
}
public void ToLessThanOrEqual_PropertySelectorIsNull_ThrowsException()
{
// Arrange
Expression <Func <TestIndexableEntity, object> > propertySelector = null;
// Act
Action act = () => ExpressionConversionService.ToLessThanOrEqual(propertySelector, 1);
// Assert
act.ShouldThrow <ArgumentNullException>();
}
public void ToBetween_PropertySelectorIsNull_ThrowsException()
{
// Arrange
Expression <Func <TestIndexableEntity, object> > propertySelector = null;
// Act
Action act = () => ExpressionConversionService.ToBetween(propertySelector, string.Empty, string.Empty);
// Assert
act.ShouldThrow <ArgumentNullException>();
}
public void ToContains_PropertySelectorIsNotOfTypeString_ThrowsException()
{
// Arrange
Expression <Func <TestIndexableEntity, object> > propertySelector = x => x.SomeInteger;
// Act
Action act = () => ExpressionConversionService.ToContains(propertySelector, string.Empty);
// Assert
act.ShouldThrow <ArgumentException>();
}
public void ToGreaterThanOrEqual_ValueIsNull_ThrowsException()
{
// Arrange
object value = null;
Expression <Func <TestIndexableEntity, object> > propertySelector = x => x.SomeInteger;
// Act
Action act = () => ExpressionConversionService.ToGreaterThanOrEqual(propertySelector, value);
// Assert
act.ShouldThrow <ArgumentNullException>();
}
public void ToGreaterThanOrEqual_PropertySelectorIsNotNullAndValueIsSet_ReturnsPropertyGreaterThanOrEqualsValueExpression()
{
// Arrange
var value = 1;
var indexableEntity = new TestIndexableEntity();
Expression <Func <TestIndexableEntity, bool> > expected = x => x.SomeInteger >= value;
// Act
var actual = ExpressionConversionService.ToGreaterThanOrEqual <TestIndexableEntity>(x => x.SomeInteger, value);
// Assert
Assert.Equal(actual.Compile().Invoke(indexableEntity),
expected.Compile().Invoke(indexableEntity));
}
public void ToContains_PropertySelectorIsNotNullAndValueIsSet_ReturnsPropertyContainsValueExpression()
{
// Arrange
var value = "Foo";
var indexableEntity = new TestIndexableEntity {
Name = value
};
Expression <Func <TestIndexableEntity, bool> > expected = x => x.Name.Contains(value);
// Act
var actual = ExpressionConversionService.ToContains <TestIndexableEntity>(x => x.Name, value);
// Assert
Assert.Equal(actual.Compile().Invoke(indexableEntity),
expected.Compile().Invoke(indexableEntity));
}
public void ToEnumerableContains_PropertySelectorIsNotNullAndValueIsSet_ReturnsEnumerablePropertyContainsValueExpression()
{
// Arrange
var value = new ID(Guid.Empty);
var indexableEntity = new TestIndexableEntity {
Paths = new List <ID> {
value
}
};
Expression <Func <TestIndexableEntity, object> > expected = x => x.Paths.Contains(value);
// Act
var actual = ExpressionConversionService.ToEnumerableContains <TestIndexableEntity>(x => x.Paths, value);
// Assert
Assert.Equal(actual.Compile().Invoke(indexableEntity),
expected.Compile().Invoke(indexableEntity));
}
public void ToBetween_PropertySelectorIsNotNullAndLowerAndUpperValuesAreSet_ReturnsPropertyBetweenLowerAndUpperValuesExpression(string propertyName, object minValue, object maxValue, Inclusion inclusion)
{
// Arrange
var propertySelector = ExpressionUtils.GetPropertySelector <TestIndexableEntity, object>(propertyName);
var indexableEntity = new TestIndexableEntity
{
SomeInteger = 1,
SomeFloat = 1f,
SomeDouble = 100,
CreatedDate = DateTime.Now
};
Expression <Func <TestIndexableEntity, object> > expected = x => propertySelector.Between(minValue, maxValue, inclusion);
// Act
var actual = ExpressionConversionService.ToBetween(propertySelector, minValue, maxValue, inclusion);
// Assert
Assert.Equal(actual.Compile().Invoke(indexableEntity),
expected.Compile().Invoke(indexableEntity));
}
private static Expression <Func <T, bool> > GetPredicateFromSearchQueryRule(SearchQueryRule <T> searchQueryRule, object value)
{
Expression <Func <T, bool> > predicate;
switch (searchQueryRule.ComparisonOperator)
{
case ComparisonOperator.GreaterThanOrEqual:
predicate = ExpressionConversionService.ToGreaterThanOrEqual(searchQueryRule.PropertySelector, value);
break;
case ComparisonOperator.LessThanOrEqual:
predicate = ExpressionConversionService.ToLessThanOrEqual(searchQueryRule.PropertySelector, value);
break;
case ComparisonOperator.Equal:
predicate = ExpressionConversionService.ToEquals(searchQueryRule.PropertySelector, value);
break;
case ComparisonOperator.Contains:
predicate = GetContainsPredicateFromSearchQueryRule(searchQueryRule, value);
break;
case ComparisonOperator.Between:
var rangeValue = (RangeValue)value;
predicate = ExpressionConversionService.ToBetween(searchQueryRule.PropertySelector, rangeValue.LowerValue, rangeValue.UpperValue);
break;
case ComparisonOperator.GreaterThan:
case ComparisonOperator.LessThan:
case ComparisonOperator.NotEqual:
case ComparisonOperator.NotContains:
case ComparisonOperator.NotBetween:
default:
throw new NotSupportedException();
}
return(predicate);
}
