Example #1
0
        public void Apply_FiltersItemsByIgnoringCase()
        {
            Expression <Func <GridModel, String> > expression = (model) => model.Name;
            StringStartsWithFilter filter = new StringStartsWithFilter();

            filter.Value = "Test";

            IQueryable <GridModel> items = new[]
            {
                new GridModel {
                    Name = null
                },
                new GridModel {
                    Name = "Tes"
                },
                new GridModel {
                    Name = "test"
                },
                new GridModel {
                    Name = "Test"
                },
                new GridModel {
                    Name = "TTEST2"
                }
            }.AsQueryable();

            IQueryable expected = items.Where(model => model.Name != null && model.Name.ToUpper().StartsWith("TEST"));
            IQueryable actual   = Filter(items, filter.Apply(expression.Body), expression);

            Assert.Equal(expected, actual);
        }
        public void Process_FiltersItemsWithCaseInsensitiveComparison()
        {
            StringStartsWithFilter <GridModel>     filter     = new StringStartsWithFilter <GridModel>();
            Expression <Func <GridModel, String> > expression = (model) => model.Name;

            filter.FilteredExpression = expression;
            filter.Value = "Test";

            IQueryable <GridModel> models = new[]
            {
                new GridModel {
                    Name = null
                },
                new GridModel {
                    Name = "Tes"
                },
                new GridModel {
                    Name = "test"
                },
                new GridModel {
                    Name = "Test"
                },
                new GridModel {
                    Name = "TTEST2"
                }
            }.AsQueryable();

            IQueryable expected = models.Where(model => model.Name != null && model.Name.ToUpper().StartsWith("TEST"));
            IQueryable actual   = filter.Process(models);

            CollectionAssert.AreEqual(expected, actual);
        }
        public void Apply_FiltersMultipleItems()
        {
            StringStartsWithFilter filter = new StringStartsWithFilter {
                Method = "starts-with", Values = new[] { "Test", "tt" }
            };
            Expression <Func <GridModel, String> > expression = (model) => model.Name;

            IQueryable <GridModel> items = new[]
            {
                new GridModel {
                    Name = null
                },
                new GridModel {
                    Name = "Tes"
                },
                new GridModel {
                    Name = "test"
                },
                new GridModel {
                    Name = "TEST"
                },
                new GridModel {
                    Name = "TTEST2"
                }
            }.AsQueryable();

            IQueryable expected = items.Where(model => model.Name != null && (model.Name.ToUpper().StartsWith("TT") || model.Name.ToUpper().StartsWith("TEST")));
            IQueryable actual   = items.Where(expression, filter);

            Assert.Equal(expected, actual);
        }
        public void Apply_FiltersItemsByIgnoringCase()
        {
            Expression<Func<GridModel, String>> expression = (model) => model.Name;
            StringStartsWithFilter filter = new StringStartsWithFilter();
            filter.Value = "Test";

            IQueryable<GridModel> items = new[]
            {
                new GridModel { Name = null },
                new GridModel { Name = "Tes" },
                new GridModel { Name = "test" },
                new GridModel { Name = "Test" },
                new GridModel { Name = "TTEST2" }
            }.AsQueryable();

            IQueryable expected = items.Where(model => model.Name != null && model.Name.ToUpper().StartsWith("TEST"));
            IQueryable actual = Filter(items, filter.Apply(expression.Body), expression);

            Assert.Equal(expected, actual);
        }