public void VisitSearchQueryGrouping_WithRules_ReturnExpression(
            SearchQueryPredicateBuilder <TestIndexableEntity> sut)
        {
            // Arrange
            Expression <Func <TestIndexableEntity, bool> > expected = x => (x.SomeInteger == 1 || x.SomeBoolean == false);

            var indexableEntity = new TestIndexableEntity();

            var integerEqualsRule = new SearchQueryRule <TestIndexableEntity>(
                x => x.SomeInteger, ComparisonOperator.Equal, null, "1"
                );
            var booleanEqualsRule = new SearchQueryRule <TestIndexableEntity>(
                x => x.SomeBoolean, ComparisonOperator.Equal, null, "false"
                );

            var searchQueryGrouping = new SearchQueryGrouping <TestIndexableEntity>(LogicalOperator.Or);

            searchQueryGrouping.SearchQueryElements.Add(integerEqualsRule);
            searchQueryGrouping.SearchQueryElements.Add(booleanEqualsRule);

            sut.SearchQueryValueProvider.GetValueForSearchQueryRule(integerEqualsRule).Returns(1);
            sut.SearchQueryValueProvider.GetValueForSearchQueryRule(booleanEqualsRule).Returns(false);

            // Act
            searchQueryGrouping.Accept(sut);
            Expression <Func <TestIndexableEntity, bool> > actual = sut.GetOutput();

            // Assert
            Assert.Equal(actual.Compile().Invoke(indexableEntity),
                         expected.Compile().Invoke(indexableEntity));
        }
        private void VisitSearchQueryRule_PropertyOfType_ReturnsExpression(Expression <Func <TestIndexableEntity, object> > propertySelector,
                                                                           TestIndexableEntity indexableEntity,
                                                                           object value,
                                                                           Expression <Func <TestIndexableEntity, bool> > expected)
        {
            // Arrange
            var searchQueryRule = new SearchQueryRule <TestIndexableEntity>(propertySelector, ComparisonOperator.Contains);

            var searchRootItem = new SearchQueryGrouping <TestIndexableEntity>(LogicalOperator.And);

            searchRootItem.SearchQueryElements.Add(searchQueryRule);

            var valueProviderMock = Substitute.For <ISearchQueryValueProvider>();

            valueProviderMock.GetValueForSearchQueryRule(searchQueryRule).Returns(value);

            var sut = new SearchQueryPredicateBuilder <TestIndexableEntity>(valueProviderMock);

            // Act
            searchRootItem.Accept(sut);
            var actual = sut.GetOutput();

            // Assert
            Assert.Equal(actual.Compile().Invoke(indexableEntity), expected.Compile().Invoke(indexableEntity));
        }
        public void VisitSearchQueryRule_DefaultOrDynamicValueFound_ReturnsExpression(
            SearchQueryPredicateBuilder <TestIndexableEntity> sut)
        {
            // Arrange
            var value = 1;
            Expression <Func <TestIndexableEntity, bool> > expected = x => (x.SomeInteger == value);

            var indexableEntity = new TestIndexableEntity();
            var searchQueryRule = new SearchQueryRule <TestIndexableEntity>(x => x.SomeInteger, ComparisonOperator.Equal);
            var searchRootItem  = new SearchQueryGrouping <TestIndexableEntity>(LogicalOperator.And);

            searchRootItem.SearchQueryElements.Add(searchQueryRule);

            sut
            .SearchQueryValueProvider
            .GetValueForSearchQueryRule(searchQueryRule)
            .Returns(x => value);

            // Act
            searchRootItem.Accept(sut);
            Expression <Func <TestIndexableEntity, bool> > actual = sut.GetOutput();

            // Assert
            Assert.Equal(actual.Compile().Invoke(indexableEntity), expected.Compile().Invoke(indexableEntity));
        }
        public void VisitSearchQueryGrouping_EmptySearchQueryGrouping_ReturnExpression(
            SearchQueryPredicateBuilder <TestIndexableEntity> sut)
        {
            // Arrange
            Expression <Func <TestIndexableEntity, bool> > expected = x => true;

            var indexableEntity     = new TestIndexableEntity();
            var searchQueryGrouping = new SearchQueryGrouping <TestIndexableEntity>(LogicalOperator.And);

            // Act
            searchQueryGrouping.Accept(sut);
            Expression <Func <TestIndexableEntity, bool> > actual = sut.GetOutput();

            // Assert
            Assert.Equal(actual.Compile().Invoke(indexableEntity), expected.Compile().Invoke(indexableEntity));
        }
示例#5
0
        public void VisitSearchQueryGroupingBegin(SearchQueryGrouping <T> searchQueryGrouping)
        {
            Assert.ArgumentNotNull(searchQueryGrouping, "searchQueryGrouping");

            Expression <Func <T, bool> > predicate;

            switch (searchQueryGrouping.LogicalOperator)
            {
            case LogicalOperator.And:
                predicate = PredicateBuilder.True <T>();
                break;

            case LogicalOperator.Or:
                predicate = PredicateBuilder.False <T>();
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }

            var builderContext = new PredicateBuilderContext(predicate, searchQueryGrouping.LogicalOperator);

            _predicateBuilderContext.Push(builderContext);
        }
 public void VisitSearchQueryGroupingBegin(SearchQueryGrouping <T> searchQueryGrouping)
 {
     throw new NotImplementedException();
 }