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); }