public void GetCombinedSearchExpressionShouldReturnTheSingleSearchExpressionIfOnlyThatExpressionIsEnteredToTheConstructor()
        {
            // arrange
            var columnMock = new Mock <IColumn>();

            columnMock.SetupGet(model => model.Field).Returns(nameof(TestModel.IntProp));

            var searchMock = new Mock <ISearch>();

            searchMock.SetupGet(search => search.IsRegex).Returns(false);
            searchMock.SetupGet(search => search.Value).Returns("1");

            var parameterExpression = Expression.Parameter(typeof(TestModel));

            var expression = Expression.Lambda <Func <TestModel, bool> >(Expression.Constant(true), parameterExpression);

            var testSearchExpression = new FilterExpression <TestModel>(columnMock.Object, searchMock.Object, expression);
            var searchExpressions    = new List <FilterExpression <TestModel> >()
            {
                testSearchExpression
            };

            var queryableExpression = new QueryableExpressions <TestModel>(searchExpressions, null, null);

            // act
            var resultingExpression = queryableExpression.GetCombinedSearchExpression();

            // assert
            Assert.Equal(testSearchExpression.Expression, resultingExpression);
        }
        public void GetCombinedSearchExpressionShouldReturnNullIfAllConstructorParametersAreNull()
        {
            // arrange
            var queryableExpression = new QueryableExpressions <TestModel>(null, null, null);

            // act
            var resultingExpression = queryableExpression.GetCombinedSearchExpression();

            // assert
            Assert.Null(resultingExpression);
        }
        public void GetCombinedSearchExpressionShouldReturnItemsOrderedByTheGivenExpression()
        {
            // arrange
            var columnMock = new Mock <IColumn>();

            columnMock.SetupGet(model => model.Field).Returns(nameof(TestModel.IntProp));

            var sortMock = new Mock <ISort>();

            sortMock.SetupGet(order => order.Direction).Returns(SortDirection.Ascending);

            var parameterExpression = Expression.Parameter(typeof(TestModel));

            var expression1 = Expression.Lambda <Func <TestModel, object> >(Expression.Convert(Expression.Property(parameterExpression, nameof(TestModel.IntProp)), typeof(object)), parameterExpression);

            var testColumnFilterExpression = new OrderExpression <TestModel>(columnMock.Object, sortMock.Object, expression1);
            var orderExpressions           = new List <OrderExpression <TestModel> >()
            {
                testColumnFilterExpression
            };

            var queryableExpression = new QueryableExpressions <TestModel>(null, null, orderExpressions);

            var testList = new List <TestModel>()
            {
                new TestModel()
                {
                    IntProp = 3
                },
                new TestModel()
                {
                    IntProp = 1
                },
                new TestModel()
                {
                    IntProp = 2
                }
            };

            // act
            var resultingExpression = queryableExpression.SortExpressions.First();

            var actualResults = testList.OrderBy(resultingExpression.Expression.Compile());

            // assert
            Assert.Collection(actualResults,
                              item => Assert.Equal(1, item.IntProp),
                              item => Assert.Equal(2, item.IntProp),
                              item => Assert.Equal(3, item.IntProp));
        }
        public void GetCombinedSearchExpressionShouldReturnTheAndAlsoResultOfAColumnFilterExpressionsAndASearchExpression(bool expression1Result, bool expression2Result, int expectedResultCount)
        {
            // arrange
            var columnMock = new Mock <IColumn>();

            columnMock.SetupGet(model => model.Field).Returns(nameof(TestModel.IntProp));

            var searchMock = new Mock <ISearch>();

            searchMock.SetupGet(search => search.IsRegex).Returns(false);

            var parameterExpression = Expression.Parameter(typeof(TestModel));

            var expression1 = Expression.Lambda <Func <TestModel, bool> >(Expression.Constant(expression1Result), parameterExpression);
            var expression2 = Expression.Lambda <Func <TestModel, bool> >(Expression.Constant(expression2Result), parameterExpression);

            var testColumnFilterExpression = new FilterExpression <TestModel>(columnMock.Object, searchMock.Object, expression1);
            var columnFilterExpressions    = new List <FilterExpression <TestModel> >()
            {
                testColumnFilterExpression
            };

            var testSearchExpression = new FilterExpression <TestModel>(columnMock.Object, searchMock.Object, expression2);
            var searchExpressions    = new List <FilterExpression <TestModel> >()
            {
                testSearchExpression
            };

            var queryableExpression = new QueryableExpressions <TestModel>(searchExpressions, columnFilterExpressions, null);

            var testList = new List <TestModel>()
            {
                new TestModel()
                {
                    IntProp = 1
                }
            };

            // act
            var resultingExpression = queryableExpression.GetCombinedSearchExpression();

            var actualResults = testList.Where(resultingExpression.Compile());

            // assert
            Assert.Equal(expectedResultCount, actualResults.Count());
        }