test: enumeration support

Author: yv989c

tests/QueryableValues.SqlServer.Tests/Integration/DbContextFixture.cs

@@ -66,7 +66,8 @@ private async Task Seed()
                     StringUnicodeValue = "你好！",
                     DateTimeValue = dateTimeOffset.DateTime,
                     DateTimeOffsetValue = dateTimeOffset,
-                    GuidValue = Guid.Parse("df2c9bfe-9d83-4331-97ce-2876d5dc6576")
+                    GuidValue = Guid.Parse("df2c9bfe-9d83-4331-97ce-2876d5dc6576"),
+                    EnumValue = TestEnum.Value1000
                 },
                 new TestDataEntity
                 {
@@ -85,6 +86,7 @@ private async Task Seed()
                     DateTimeValue = DateTime.MaxValue,
                     DateTimeOffsetValue = DateTimeOffset.MaxValue,
                     GuidValue = Guid.Parse("f6379213-750f-42df-91b9-73756f28c4b6"),
+                    EnumValue = TestEnum.Value3,
                     ChildEntity = new List<ChildEntity>
                     {
                         new ChildEntity()

tests/QueryableValues.SqlServer.Tests/Integration/MyDbContextBase.cs

@@ -133,6 +133,7 @@ public class TestDataEntity
         public DateTime DateTimeValue { get; set; }
         public DateTimeOffset DateTimeOffsetValue { get; set; }
         public Guid GuidValue { get; set; }
+        public TestEnum EnumValue { get; set; }
         public ICollection<ChildEntity> ChildEntity { get; set; } = default!;
     }
 
@@ -141,5 +142,14 @@ public class ChildEntity
         public int Id { get; set; }
         public int TestDataEntityId { get; set; }
     }
+
+    public enum TestEnum
+    {
+        None = 0,
+        Value1 = 1,
+        Value2 = 2,
+        Value3 = 3,
+        Value1000 = 1000
+    }
 }
 #endif

tests/QueryableValues.SqlServer.Tests/Integration/SimpleTypeTests.cs

@@ -362,6 +362,110 @@ public async Task MustMatchSequenceOfGuid()
             Assert.Equal(expected, actual);
         }
 
+        enum MyByteEnum : byte
+        {
+            None,
+            A,
+            B,
+            C
+        }
+
+        enum MyInt16Enum : short
+        {
+            None,
+            A,
+            B,
+            C
+        }
+
+        enum MyInt32Enum
+        {
+            None,
+            A,
+            B,
+            C
+        }
+
+        enum MyInt64Enum : long
+        {
+            None,
+            A,
+            B,
+            C
+        }
+
+        [Fact]
+        public async Task MustMatchSequenceOfEnumByte()
+        {
+            var expected = new[]
+            {
+                MyByteEnum.None,
+                MyByteEnum.A,
+                MyByteEnum.A,
+                MyByteEnum.B,
+                MyByteEnum.C,
+                MyByteEnum.A
+            };
+
+            var actual = await _db.AsQueryableValues(expected).ToListAsync();
+
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public async Task MustMatchSequenceOfEnumInt16()
+        {
+            var expected = new[]
+            {
+                MyInt16Enum.None,
+                MyInt16Enum.A,
+                MyInt16Enum.A,
+                MyInt16Enum.B,
+                MyInt16Enum.C,
+                MyInt16Enum.A
+            };
+
+            var actual = await _db.AsQueryableValues(expected).ToListAsync();
+
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public async Task MustMatchSequenceOfEnumInt32()
+        {
+            var expected = new[]
+            {
+                MyInt32Enum.A,
+                MyInt32Enum.A,
+                MyInt32Enum.B,
+                MyInt32Enum.C,
+                MyInt32Enum.A,
+                MyInt32Enum.None
+            };
+
+            var actual = await _db.AsQueryableValues(expected).ToListAsync();
+
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public async Task MustMatchSequenceOfEnumInt64()
+        {
+            var expected = new[]
+            {
+                MyInt64Enum.A,
+                MyInt64Enum.A,
+                MyInt64Enum.B,
+                MyInt64Enum.C,
+                MyInt64Enum.A,
+                MyInt64Enum.None
+            };
+
+            var actual = await _db.AsQueryableValues(expected).ToListAsync();
+
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public async Task QueryEntityByte()
         {
@@ -662,6 +766,27 @@ select i.Id
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public async Task QueryEntityEnum()
+        {
+            var values = new[] {
+                TestEnum.None,
+                TestEnum.Value1000
+            };
+
+            var expected = new[] { 1, 2 };
+
+            var actual = await (
+                from i in _db.TestData
+                join v in _db.AsQueryableValues(values) on i.EnumValue equals v
+                orderby i.Id
+                select i.Id
+                )
+                .ToArrayAsync();
+
+            Assert.Equal(expected, actual);
+        }
+
 
         [Fact]
         public async Task MustBeEmpty()
@@ -694,6 +819,29 @@ async Task AssertEmpty<T>()
             }
         }
 
+        [Fact]
+        public async Task MustBeEmptyEnum()
+        {
+            var testCounter = 0;
+
+            await AssertEmpty<MyByteEnum>();
+            await AssertEmpty<MyInt16Enum>();
+            await AssertEmpty<MyInt32Enum>();
+            await AssertEmpty<MyInt64Enum>();
+
+            // Coverage check.
+            var expectedTestCount = 4;
+            Assert.Equal(expectedTestCount, testCounter);
+
+            async Task AssertEmpty<T>()
+                where T : struct, Enum
+            {
+                testCounter++;
+                var actual = await _db.AsQueryableValues<T>(Array.Empty<T>()).ToListAsync();
+                Assert.Empty(actual);
+            }
+        }
+
         [Fact]
         public async Task MustMatchCount()
         {
@@ -729,6 +877,32 @@ async Task AssertCount<T>(Func<int, T> getValue)
             }
         }
 
+        [Fact]
+        public async Task MustMatchCountEnum()
+        {
+            const int expectedItemCount = 2500;
+
+            var testCounter = 0;
+
+            await AssertCount(i => (MyByteEnum)(i % 4));
+            await AssertCount(i => (MyInt16Enum)(i % 4));
+            await AssertCount(i => (MyInt32Enum)(i % 4));
+            await AssertCount(i => (MyInt64Enum)(i % 4));
+
+            // Coverage check.
+            var expectedTestCount = 4;
+            Assert.Equal(expectedTestCount, testCounter);
+
+            async Task AssertCount<T>(Func<int, T> getValue)
+                where T : struct, Enum
+            {
+                testCounter++;
+                var values = Enumerable.Range(0, expectedItemCount).Select(i => getValue(i));
+                var actualItemCount = await _db.AsQueryableValues<T>(values).CountAsync();
+                Assert.Equal(expectedItemCount, actualItemCount);
+            }
+        }
+
         [Fact]
         public async Task JoinWithInclude()
         {