Esempio n. 1
0
        public void InheritanceTest()
        {
            var filter = new Filter
            {
                Field    = nameof(Track.Composer),
                Operator = FilterOperator.Contains,
                Value    = "e"
            };

            var request = new PageAndFilterAndSortRequest
            {
                PageNumber = 3,
                PageSize   = 5,
                Logic      = FilterLogic.And,
                Filters    = new IFilter[]
                {
                    filter
                },
                Sorts = new ISort[]
                {
                    new Sort
                    {
                        Field     = nameof(Track.TrackId),
                        Direction = SortDirection.Ascending
                    },
                    new Sort
                    {
                        Field     = nameof(Track.Composer),
                        Direction = SortDirection.Ascending
                    }
                }
            };

            using (var dbContext = new TestDataContext())
            {
                //var items = dbContext.Tracks.ToList();
                var filtered  = dbContext.Tracks.Filter(request);
                var queryable = filtered
                                .Sort(request)
                                .Page(request);
                var sql  = "";//((DbQuery<Customer>)queryable).Sql;
                var list = queryable.ToList();

                Debug.WriteLine(sql);

                Assert.AreEqual(request.PageSize, list.Count);
                Assert.IsTrue(list.All(x => x.Composer.Contains(filter.Value)));
            }
        }
Esempio n. 2
0
        public void CombinedTest()
        {
            var request = new PageAndFilterAndSortRequest
            {
                PageNumber = 3,
                PageSize   = 25,
                Logic      = FilterLogic.And,
                Filters    = new IFilter[]
                {
                    new Filter
                    {
                        Field    = nameof(Student.LastName),
                        Operator = FilterOperator.Contains,
                        Value    = "e"
                    },
                    new Filter
                    {
                        Field    = nameof(Student.FirstName),
                        Operator = FilterOperator.StartsWith,
                        Value    = "F"
                    }
                },
                Sorts = new ISort[]
                {
                    new Sort
                    {
                        Field     = nameof(Student.FirstName),
                        Direction = SortDirection.Descending
                    },
                    new Sort
                    {
                        Field     = nameof(Student.LastName),
                        Direction = SortDirection.Ascending
                    }
                }
            };

            using (var dbContext = new TestDataContext())
            {
                var items    = dbContext.Students.ToList();
                var filtered = dbContext.Students.Filter(request);
                var paged    = filtered
                               .Sort(request)
                               .Page(request);
                var list = paged.ToList();
            }
        }
Esempio n. 3
0
        public void CombinedTest()
        {
            var request = new PageAndFilterAndSortRequest
            {
                PageNumber = 3,
                PageSize   = 25,
                Logic      = FilterLogic.And,
                Filters    = new IFilter[]
                {
                    new Filter
                    {
                        Field    = nameof(Track.Name),
                        Operator = FilterOperator.Contains,
                        Value    = "e"
                    },
                    new Filter
                    {
                        Field    = nameof(Track.Name),
                        Operator = FilterOperator.StartsWith,
                        Value    = "F"
                    }
                },
                Sorts = new ISort[]
                {
                    new Sort
                    {
                        Field     = nameof(Track.Milliseconds),
                        Direction = SortDirection.Descending
                    }
                }
            };

            using (var dbContext = new TestDataContext())
            {
                var items     = dbContext.Tracks.ToList();
                var filtered  = dbContext.Tracks.Filter(request);
                var queryable = filtered
                                .Sort(request)
                                .Page(request);
                var sql  = ((DbQuery <Track>)queryable).Sql;
                var list = queryable.ToList();

                Debug.WriteLine(sql);

                Assert.AreEqual(request.PageSize, list.Count);
                foreach (var filter in request.Filters)
                {
                    switch (filter.Operator)
                    {
                    case FilterOperator.StartsWith:
                        Assert.IsTrue(list.All(x => x.Name.StartsWith(filter.Value)));
                        break;

                    case FilterOperator.Contains:
                        Assert.IsTrue(list.All(x => x.Name.Contains(filter.Value)));
                        break;
                    }
                }
                Assert.AreEqual(list.Max(x => x.Milliseconds), list.First().Milliseconds);
            }
        }