feat(primitive-collections): including literal types for non-navigation/simple members.

AutoMapper/AutoMapper.Extensions.OData#196

Author: NetanelPersikGoogle

LogicBuilder.Expressions.Utils.Tests/TypeExtensionsTests.cs

@@ -2,8 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
-using System.Text;
-using System.Threading.Tasks;
 using Xunit;
 
 namespace LogicBuilder.Expressions.Utils.Tests
@@ -13,6 +11,7 @@ public class TypeExtensionsTests
         [Theory]
         [InlineData(nameof(DerivedThing.Id), typeof(DerivedThing))]
         [InlineData(nameof(DerivedThing.Name), typeof(BaseThing))]
+        [InlineData(nameof(DerivedThing.DataInBytes), typeof(BaseThing))]
         [InlineData(nameof(DerivedThing.Description), typeof(DerivedThing))]
         public void MemberInfoReflectedTypeMustMatchTheDeclaringType(string propertyName, Type reflectedType)
         {
@@ -26,30 +25,71 @@ public void MemberInfoReflectedTypeMustMatchTheDeclaringType(string propertyName
         [Theory]
         [InlineData(nameof(DerivedThing.Id), typeof(DerivedThing))]
         [InlineData(nameof(DerivedThing.Name), typeof(BaseThing))]
+        [InlineData(nameof(DerivedThing.DataInBytes), typeof(BaseThing))]
         [InlineData(nameof(DerivedThing.Description), typeof(DerivedThing))]
-        public void MemberInfoReflectedTypeMustMatchTheDeclaringTypeForGetSelectedMembers(string propertyName, Type reflectedType)
+        public void MemberInfoReflectedTypeMustMatchTheDeclaringTypeForGetSelectedMembers(string propertyName,
+            Type reflectedType)
         {
             //act
-            MemberInfo memberInfo = typeof(DerivedThing).GetSelectedMembers(new List<string>()).FirstOrDefault(m => m.Name == propertyName);
+            MemberInfo memberInfo = typeof(DerivedThing).GetSelectedMembers(new List<string>())
+                .FirstOrDefault(m => m.Name == propertyName);
 
             //assert
             Assert.Equal(reflectedType.FullName, memberInfo.ReflectedType.FullName);
         }
 
-        public abstract class BaseThing
+        [Theory]
+        [InlineData(typeof(DerivedThing))]
+        [InlineData(typeof(BaseThing))]
+        public void GetSelectedMembers_WhenSelectIsEmpty_MustReturnAllLiteralMembers(Type reflectedType)
+        {
+            // Act
+            var memberInfos = reflectedType.GetSelectedMembers(Enumerable.Empty<string>().ToList());
+
+            // Assert
+            Assert.Multiple(() =>
+            {
+                var names = memberInfos.Select(mi => mi.Name);
+                
+                Assert.DoesNotContain(memberInfos, name => name.Name == nameof(BaseThing.Objects));
+                
+                Assert.Contains(names, name => name == nameof(BaseThing.ParametersArray));
+                Assert.Contains(memberInfos, name => name.Name == nameof(BaseThing.ParametersList));
+                Assert.Contains(memberInfos, name => name.Name == nameof(BaseThing.Ints));
+                Assert.Contains(memberInfos, name => name.Name == nameof(BaseThing.Strings));
+                Assert.Contains(memberInfos, name => name.Name == nameof(BaseThing.Booleans));
+                Assert.Contains(memberInfos, name => name.Name == nameof(BaseThing.DateTimes));
+                Assert.Contains(memberInfos, name => name.Name == nameof(BaseThing.Dates));
+                Assert.Contains(memberInfos, name => name.Name == nameof(BaseThing.Guides));
+                Assert.Contains(memberInfos, name => name.Name == nameof(BaseThing.UnsignedInts));
+            });
+        }
+
+        private abstract class BaseThing
         {
             public string Name { get; set; }
+            public byte[] DataInBytes { get; set; }
+            public string[] ParametersArray { get; set; }
+            public ICollection<string> Strings { get; set; }
+            public List<string> ParametersList { get; set; }
+            public List<bool> Booleans { get; set; }
+            public ISet<DateTime> DateTimes { get; set; }
+            public ISet<DateOnly> Dates { get; set; }
+            public HashSet<Guid> Guides { get; set; }
+            public uint[] UnsignedInts { get; set; }
+            public IEnumerable<int> Ints { get; set; }
+            public List<object> Objects { get; set; }
         }
 
-        public class DerivedThing : BaseThing, IDerivedThing
+        private class DerivedThing : BaseThing, IDerivedThing
         {
             public Guid Id { get; set; }
             public string Description { get; set; }
         }
 
-        public interface IDerivedThing
+        private interface IDerivedThing
         {
             public string Description { get; set; }
         }
     }
-}
+}

LogicBuilder.Expressions.Utils/TypeExtensions.cs

@@ -204,9 +204,22 @@ private static MemberInfo[] GetValueTypeMembers(this Type parentType)
             return parentType.GetMemberInfos().Where
             (
                 info => (info.MemberType == MemberTypes.Field || info.MemberType == MemberTypes.Property)
-                && (info.GetMemberType().IsLiteralType() || info.GetMemberType() == typeof(byte[]))//Need typeof(byte[]) for SQL Server timestamp column
+                && (info.GetMemberType().IsLiteralType() || info.GetMemberType().IsLiteralList())
             ).ToArray();
         }
+        
+        private static bool IsLiteralList(this Type type)
+        {
+            // Check if type is a List
+            if (!type.IsList()) return false;
+
+            // If not generic, check if it's a literal type (i.e. string[])
+            if (!type.IsGenericType) return type.GetElementType().IsLiteralType();
+
+            // Extract the type T from List<T> and check if it's a literal type
+            var firstGenericArgument = type.GetGenericArguments().First();
+            return firstGenericArgument.IsLiteralType();
+        }
 
         private static MemberInfo[] GetMemberInfos(this Type parentType) 
             => parentType.GetMembers(instanceBindingFlags).Select