add test FilterRule

src/Versions.props

@@ -1,7 +1,7 @@
 <Project>
     <PropertyGroup>
-        <Version>2.2.0</Version>
-        <Vitorm_Version>[2.2.0, 2.3.0)</Vitorm_Version>
+        <Version>2.2.1</Version>
+        <Vitorm_Version>[2.2.1, 2.3.0)</Vitorm_Version>
     </PropertyGroup>
 
     <PropertyGroup>

test/Vitorm.Excel.MsTest/CommonTest/Query_FilterRule_Test.cs

@@ -13,30 +13,250 @@ namespace Vitorm.MsTest.CommonTest
     {
 
         [TestMethod]
-        public void Test()
+        public void Test_PagedQuery()
         {
             using var dbContext = DataSource.CreateDbContext();
             var userQuery = dbContext.Query<User>();
 
             {
-                var strFilter = "{'field':'id',  'operator': '>',  'value': 1 }".Replace("'", "\"");
+                var strPagedQuery = "{ 'filter':{'field':'id',  'operator': '>',  'value': 1 },  'orders':[{'field':'id','asc':false}],  'page':{'pageSize':2, 'pageIndex':1}  }".Replace("'", "\"");
+                var pagedQuery = Json.Deserialize<PagedQuery>(strPagedQuery);
+
+                var pageData = userQuery.ToPageData(pagedQuery);
+                Assert.AreEqual(5, pageData.totalCount);
+                Assert.AreEqual(6, pageData.items[0].id);
+            }
+
+        }
+
+
+
+        [TestMethod]
+        public void Test_IsNull()
+        {
+            using var dbContext = DataSource.CreateDbContext();
+            var userQuery = dbContext.Query<User>();
+
+            {
+                var strFilter = "{'field':'fatherId',  'operator': 'IsNull' }".Replace("'", "\"");
                 var filter = Json.Deserialize<FilterRule>(strFilter);
 
                 var items = userQuery.Where(filter).OrderByDescending(u => u.id).ToList();
-                Assert.AreEqual(5, items.Count);
-                Assert.AreEqual(6, items[0].id);
+                var ids = items.Select(m => m.id).Distinct().ToList();
+                Assert.AreEqual(3, ids.Count);
+                Assert.AreEqual(0, ids.Except(new int[] { 4, 5, 6 }).Count());
             }
+        }
+
+        [TestMethod]
+        public void Test_IsNotNull()
+        {
+            using var dbContext = DataSource.CreateDbContext();
+            var userQuery = dbContext.Query<User>();
 
             {
-                var strPagedQuery = "{ 'filter':{'field':'id',  'operator': '>',  'value': 1 },  'orders':[{'field':'id','asc':false}],  'page':{'pageSize':2, 'pageIndex':1}  }".Replace("'", "\"");
-                var pagedQuery = Json.Deserialize<PagedQuery>(strPagedQuery);
+                var strFilter = "{'field':'fatherId',  'operator': 'IsNotNull' }".Replace("'", "\"");
+                var filter = Json.Deserialize<FilterRule>(strFilter);
 
-                var pageData = userQuery.ToPageData(pagedQuery);
-                Assert.AreEqual(5, pageData.totalCount);
-                Assert.AreEqual(6, pageData.items[0].id);
+                var items = userQuery.Where(filter).OrderByDescending(u => u.id).ToList();
+                var ids = items.Select(m => m.id).Distinct().ToList();
+                Assert.AreEqual(3, ids.Count);
+                Assert.AreEqual(0, ids.Except(new int[] { 1, 2, 3 }).Count());
+            }
+        }
+
+        [TestMethod]
+        public void Test_In()
+        {
+            using var dbContext = DataSource.CreateDbContext();
+            var userQuery = dbContext.Query<User>();
+
+            {
+                var strFilter = "{'field':'id',  'operator': 'In',  'value': [1,2,3] }".Replace("'", "\"");
+                var filter = Json.Deserialize<FilterRule>(strFilter);
+
+                var items = userQuery.Where(filter).OrderByDescending(u => u.id).ToList();
+                var ids = items.Select(m => m.id).Distinct().ToList();
+                Assert.AreEqual(3, ids.Count);
+                Assert.AreEqual(0, ids.Except(new int[] { 1, 2, 3 }).Count());
+            }
+        }
+
+        [TestMethod]
+        public void Test_NotIn()
+        {
+            using var dbContext = DataSource.CreateDbContext();
+            var userQuery = dbContext.Query<User>();
+
+            {
+                var strFilter = "{'field':'id',  'operator': 'NotIn',  'value': [1,2,3] }".Replace("'", "\"");
+                var filter = Json.Deserialize<FilterRule>(strFilter);
+
+                var items = userQuery.Where(filter).OrderByDescending(u => u.id).ToList();
+                var ids = items.Select(m => m.id).Distinct().ToList();
+                Assert.AreEqual(3, ids.Count);
+                Assert.AreEqual(0, ids.Except(new int[] { 4, 5, 6 }).Count());
+            }
+        }
+
+
+        [TestMethod]
+        public void Test_NumberCompare()
+        {
+            using var dbContext = DataSource.CreateDbContext();
+            var userQuery = dbContext.Query<User>();
+
+            // #1 >
+            {
+                var strFilter = "{'field':'id',  'operator': '>',  'value': 3 }".Replace("'", "\"");
+                var filter = Json.Deserialize<FilterRule>(strFilter);
+
+                var items = userQuery.Where(filter).OrderByDescending(u => u.id).ToList();
+                var ids = items.Select(m => m.id).Distinct().ToList();
+                Assert.AreEqual(3, ids.Count);
+                Assert.AreEqual(0, ids.Except(new int[] { 4, 5, 6 }).Count());
+            }
+
+            // #2 >=
+            {
+                var strFilter = "{'field':'id',  'operator': '>=',  'value': 4 }".Replace("'", "\"");
+                var filter = Json.Deserialize<FilterRule>(strFilter);
+
+                var items = userQuery.Where(filter).OrderByDescending(u => u.id).ToList();
+                var ids = items.Select(m => m.id).Distinct().ToList();
+                Assert.AreEqual(3, ids.Count);
+                Assert.AreEqual(0, ids.Except(new int[] { 4, 5, 6 }).Count());
+            }
+
+            // #3 <
+            {
+                var strFilter = "{'field':'id',  'operator': '<',  'value': 4 }".Replace("'", "\"");
+                var filter = Json.Deserialize<FilterRule>(strFilter);
+
+                var items = userQuery.Where(filter).OrderByDescending(u => u.id).ToList();
+                var ids = items.Select(m => m.id).Distinct().ToList();
+                Assert.AreEqual(3, ids.Count);
+                Assert.AreEqual(0, ids.Except(new int[] { 1, 2, 3 }).Count());
+            }
+
+            // #4 <=
+            {
+                var strFilter = "{'field':'id',  'operator': '<=',  'value': 3 }".Replace("'", "\"");
+                var filter = Json.Deserialize<FilterRule>(strFilter);
+
+                var items = userQuery.Where(filter).OrderByDescending(u => u.id).ToList();
+                var ids = items.Select(m => m.id).Distinct().ToList();
+                Assert.AreEqual(3, ids.Count);
+                Assert.AreEqual(0, ids.Except(new int[] { 1, 2, 3 }).Count());
+            }
+
+            // #5.1  =
+            {
+                var strFilter = "{'field':'id',  'operator': '=',  'value': 3 }".Replace("'", "\"");
+                var filter = Json.Deserialize<FilterRule>(strFilter);
+
+                var items = userQuery.Where(filter).OrderByDescending(u => u.id).ToList();
+                var ids = items.Select(m => m.id).Distinct().ToList();
+                Assert.AreEqual(1, ids.Count);
+                Assert.AreEqual(0, ids.Except(new int[] { 3 }).Count());
+            }
+            // #5.2 =
+            {
+                var strFilter = "{'field':'fatherId',  'operator': '=',  'value': null }".Replace("'", "\"");
+                var filter = Json.Deserialize<FilterRule>(strFilter);
+
+                var items = userQuery.Where(filter).OrderByDescending(u => u.id).ToList();
+                var ids = items.Select(m => m.id).Distinct().ToList();
+                Assert.AreEqual(3, ids.Count);
+                Assert.AreEqual(0, ids.Except(new int[] { 4, 5, 6 }).Count());
+            }
+
+            // #6.1 !=
+            {
+                var strFilter = "{'field':'id',  'operator': '!=',  'value': 3 }".Replace("'", "\"");
+                var filter = Json.Deserialize<FilterRule>(strFilter);
+
+                var items = userQuery.Where(filter).OrderByDescending(u => u.id).ToList();
+                var ids = items.Select(m => m.id).Distinct().ToList();
+                Assert.AreEqual(5, ids.Count);
+                Assert.AreEqual(0, ids.Except(new int[] { 1, 2, 4, 5, 6 }).Count());
             }
 
+            // #6.2 !=
+            {
+                var strFilter = "{'field':'fatherId',  'operator': '!=',  'value': null }".Replace("'", "\"");
+                var filter = Json.Deserialize<FilterRule>(strFilter);
+
+                var items = userQuery.Where(filter).OrderByDescending(u => u.id).ToList();
+                var ids = items.Select(m => m.id).Distinct().ToList();
+                Assert.AreEqual(3, ids.Count);
+                Assert.AreEqual(0, ids.Except(new int[] { 1, 2, 3 }).Count());
+            }
         }
 
+
+        [TestMethod]
+        public void Test_String()
+        {
+            using var dbContext = DataSource.CreateDbContextForWriting();
+            var userQuery = dbContext.Query<User>();
+            var users = new List<User> {
+                User.NewUser(id: 7, forAdd: true),
+                User.NewUser(id: 8, forAdd: true),
+            };
+            users[0].name = "";
+            users[1].name = null;
+            dbContext.AddRange(users);
+            DataSource.WaitForUpdate();
+
+
+            // #1 Contains
+            {
+                var strFilter = "{'field':'name',  'operator': 'Contains',  'value': '46' }".Replace("'", "\"");
+                var filter = Json.Deserialize<FilterRule>(strFilter);
+
+                var items = userQuery.Where(filter).OrderByDescending(u => u.id).ToList();
+                var ids = items.Select(m => m.id).Distinct().ToList();
+                Assert.AreEqual(2, ids.Count);
+                Assert.AreEqual(0, ids.Except(new int[] { 1, 2 }).Count());
+            }
+
+            // #2 NotContain
+            {
+                var strFilter = "{'field':'name',  'operator': 'NotContain',  'value': '46' }".Replace("'", "\"");
+                var filter = Json.Deserialize<FilterRule>(strFilter);
+
+                var items = userQuery.Where(filter).OrderByDescending(u => u.id).ToList();
+                var ids = items.Select(m => m.id).Distinct().ToList();
+                Assert.AreEqual(6, ids.Count);
+                Assert.AreEqual(0, ids.Except(new int[] { 3, 4, 5, 6, 7, 8 }).Count());
+            }
+
+
+            // #3 StartsWith
+            {
+                var strFilter = "{'field':'name',  'operator': 'StartsWith',  'value': 'u14' }".Replace("'", "\"");
+                var filter = Json.Deserialize<FilterRule>(strFilter);
+
+                var items = userQuery.Where(filter).OrderByDescending(u => u.id).ToList();
+                var ids = items.Select(m => m.id).Distinct().ToList();
+                Assert.AreEqual(1, ids.Count);
+                Assert.AreEqual(0, ids.Except(new int[] { 1 }).Count());
+            }
+
+            // #4 EndsWith
+            {
+                var strFilter = "{'field':'name',  'operator': 'EndsWith',  'value': '46' }".Replace("'", "\"");
+                var filter = Json.Deserialize<FilterRule>(strFilter);
+
+                var items = userQuery.Where(filter).OrderByDescending(u => u.id).ToList();
+                var ids = items.Select(m => m.id).Distinct().ToList();
+                Assert.AreEqual(2, ids.Count);
+                Assert.AreEqual(0, ids.Except(new int[] { 1, 2 }).Count());
+            }
+
+        }
+
+
     }
 }

test/Vitorm.Excel.MsTest/DataSource.cs

@@ -56,6 +56,11 @@
 
     public class DataSource
     {
+        static DataSource()
+        {
+            Vit.Linq.FilterRules.FilterService.Instance.checkNullForString = true;
+        }
+
         public static void WaitForUpdate() { }
 
         public static DbContext CreateDbContextForWriting(bool autoInit = true) => CreateDbContext(autoInit);