Exemple #1
0
#pragma warning disable 1998
        public async Task FilterTests()
#pragma warning restore 1998
        {
            var data = TestSource.GetData();

            // filter: entity => entity.ReferenceModel.Name.ToString().Contains("Model") &&
            //                   (entity.Number == 1 || entity.Number == 2) &&
            //                   (new [] {5,6,10}).Contains("Number")
            var filter = new FilterBuilder()
                         .Not(f => f.In <int>("Number", new[] { 5, 6, 10 }))
                         .Build();

            var filter1 = new FilterBuilder()
                          .Contains("Name", "6")
                          .Not(f => f.In <int>("Number", new[] { 5, 6, 10 }))
                          .Build();

            var filter1_0 = new FilterBuilder()
                            .Not(f => f
                                 .Not(d => d.Equal("Number", 3))
                                 .Contains("Name", "l3"))
                            .Build();

            var filter2_0 = new FilterBuilder()
                            .Contains("Name", "testModel")
                            .Build();

            var filter2_1 = new FilterBuilder()
                            .Contains("Name", "testmodel")
                            .Build();

            var filter2_2 = new FilterBuilder()
                            .Contains("Name", "Testmodel")
                            .Build();

            var filter2_3 = new FilterBuilder()
                            .Contains("Name", "TESTMODEL")
                            .Build();

            var expression    = filter.ToLambdaFilter <TestModel>();
            var expression1   = filter1.ToLambdaFilter <TestModel>();
            var expression1_0 = filter1_0.ToLambdaFilter <TestModel>();

            var expression2_0 = filter2_0.ToLambdaFilter <TestModel>();
            var expression2_1 = filter2_1.ToLambdaFilter <TestModel>();
            var expression2_2 = filter2_2.ToLambdaFilter <TestModel>();
            var expression2_3 = filter2_3.ToLambdaFilter <TestModel>();

            var filtered    = data.Where(expression).ToList();
            var filtered1   = data.Where(expression1).ToList();
            var filtered1_0 = data.Where(expression1_0).ToList();

            var filtered2_0 = data.Where(expression2_0).ToList();
            var filtered2_1 = data.Where(expression2_1).ToList();
            var filtered2_2 = data.Where(expression2_2).ToList();
            var filtered2_3 = data.Where(expression2_3).ToList();

            Assert.True(filtered2_0.Count == 500);
            Assert.True(filtered2_1.Count == 500);
            Assert.True(filtered2_2.Count == 500);
            Assert.True(filtered2_3.Count == 500);

            Assert.True(filtered.Count == 498);
            Assert.False(filtered1.All(e => e.Number == 5 || e.Number == 6 || e.Number == 10));
            Assert.True(filtered1_0.Count == 0);

            var filterEqualToDate = new FilterBuilder()
                                    .EqualToDate("Date", new DateTime(2019, 1, 24, 15, 15, 15))
                                    .Build();
            var expressionEqualToDate = filterEqualToDate.ToLambdaFilter <TestModel>();
            var filteredEqualToDate   = data.Where(expressionEqualToDate).ToList();

            Assert.Equal(100, filteredEqualToDate.Count);

            var filterEqualToDateNull = new FilterBuilder()
                                        .EqualToDate("Date", new DateTime())
                                        .Build();
            var expressionEqualToDateNull = filterEqualToDateNull.ToLambdaFilter <TestModel>();
            var filteredEqualToDateNull   = data.Where(expressionEqualToDateNull).ToList();

            Assert.Single(filteredEqualToDateNull); //500
        }