Extra configured data source checks (#100)

* Erroring if configured value has enumerable - non-enumerable mismatch

* Clearer errors if invalid target members are specified in configuration

Author: SteveWilkes

AgileMapper.UnitTests/Configuration/WhenConfiguringDataSourcesIncorrectly.cs

@@ -1,6 +1,8 @@
 namespace AgileObjects.AgileMapper.UnitTests.Configuration
 {
     using System;
+    using System.Collections.Generic;
+    using System.Linq;
     using AgileMapper.Configuration;
     using Common;
     using TestClasses;
@@ -351,9 +353,81 @@ public void ShouldErrorIfRootTargetSimpleTypeMemberDataSourceConfigured()
             });
 
             configurationException.Message.ShouldContain("PublicProperty<int>.Value");
+            configurationException.Message.ShouldContain("'int' cannot be mapped to target type 'PublicField<long>'");
+        }
 
-            configurationException.Message.ShouldContain(
-                "'int' cannot be mapped to target type 'PublicField<long>'");
+        [Fact]
+        public void ShouldErrorIfRootEnumerableTargetNonEnumerableTypeMemberDataSourceConfigured()
+        {
+            var configurationException = Should.Throw<MappingConfigurationException>(() =>
+            {
+                using (var mapper = Mapper.CreateNew())
+                {
+                    mapper.WhenMapping
+                        .From<PublicProperty<Address>>()
+                        .To<List<Address>>()
+                        .Map(ctx => ctx.Source.Value)
+                        .ToTarget();
+                }
+            });
+
+            configurationException.Message.ShouldContain("Non-enumerable PublicProperty<Address>.Value");
+            configurationException.Message.ShouldContain("cannot be mapped to enumerable target type 'List<Address>'");
+        }
+
+        [Fact]
+        public void ShouldErrorIfRootNonEnumerableTargetEnumerableTypeMemberDataSourceConfigured()
+        {
+            var configurationException = Should.Throw<MappingConfigurationException>(() =>
+            {
+                using (var mapper = Mapper.CreateNew())
+                {
+                    mapper.WhenMapping
+                        .From<PublicField<List<Customer>>>()
+                        .To<PublicProperty<Customer>>()
+                        .Map(ctx => ctx.Source.Value)
+                        .ToTarget();
+                }
+            });
+
+            configurationException.Message.ShouldContain("Enumerable PublicField<List<Customer>>.Value");
+            configurationException.Message.ShouldContain("cannot be mapped to non-enumerable target type 'PublicProperty<Customer>'");
+        }
+
+        [Fact]
+        public void ShouldErrorIfConstantSpecifiedForTargetMember()
+        {
+            var configurationException = Should.Throw<MappingConfigurationException>(() =>
+            {
+                using (var mapper = Mapper.CreateNew())
+                {
+                    mapper.WhenMapping
+                        .From<PublicField<Customer>>()
+                        .To<PublicProperty<Customer>>()
+                        .Map(ctx => "Number!")
+                        .To(ppc => "Number?");
+                }
+            });
+
+            configurationException.Message.ShouldContain("Unable to determine target member from '\"Number?\"'");
+        }
+
+        [Fact]
+        public void ShouldErrorIfProjectionSpecifiedForTargetMember()
+        {
+            var configurationException = Should.Throw<MappingConfigurationException>(() =>
+            {
+                using (var mapper = Mapper.CreateNew())
+                {
+                    mapper.WhenMapping
+                        .From<PublicField<IEnumerable<Customer>>>()
+                        .To<PublicProperty<IEnumerable<Customer>>>()
+                        .Map(ctx => new[] { "One", "Two", "Three" })
+                        .To(ppc => ppc.Value.Select(c => c.Name));
+                }
+            });
+
+            configurationException.Message.ShouldContain("not writeable");
         }
     }
 }

AgileMapper/Api/Configuration/CustomDataSourceTargetMemberSpecifier.cs

@@ -283,6 +283,7 @@ private ConfiguredDataSourceFactory CreateForCtorParam<TParam>(ParameterInfo par
         public IMappingConfigContinuation<TSource, TTarget> ToTarget()
         {
             ThrowIfSimpleSource(typeof(TTarget));
+            ThrowIfEnumerableSourceAndTargetMismatch(typeof(TTarget));
 
             return RegisterDataSource<TTarget>(() => new ConfiguredDataSourceFactory(
                 _configInfo,
@@ -299,27 +300,65 @@ private void ThrowIfSimpleSource(Type targetMemberType)
                 return;
             }
 
-            string sourceValue;
+            var sourceValue = GetSourceValue(customValue);
 
-            if (customValue.NodeType == ExpressionType.MemberAccess)
+            throw new MappingConfigurationException(string.Format(
+                CultureInfo.InvariantCulture,
+                "{0}'{1}' cannot be mapped to target type '{2}'",
+                sourceValue,
+                customValue.Type.GetFriendlyName(),
+                targetMemberType.GetFriendlyName()));
+        }
+
+        private void ThrowIfEnumerableSourceAndTargetMismatch(Type targetMemberType)
+        {
+            var customValue = _customValueLambda.Body;
+
+            if ((targetMemberType.IsDictionary() || customValue.Type.IsDictionary()) ||
+                (targetMemberType.IsEnumerable() == customValue.Type.IsEnumerable()))
             {
-                var rootSourceMember = _configInfo.MapperContext.QualifiedMemberFactory.RootSource<TSource, TTarget>();
-                var sourceMember = customValue.ToSourceMember(_configInfo.MapperContext);
-                sourceValue = sourceMember.GetFriendlyMemberPath(rootSourceMember) + " of type ";
+                return;
+            }
+
+            string sourceEnumerableState, targetEnumerableState;
+
+            if (targetMemberType.IsEnumerable())
+            {
+                sourceEnumerableState = "Non-enumerable";
+                targetEnumerableState = "enumerable";
             }
             else
             {
-                sourceValue = "Source type ";
+                sourceEnumerableState = "Enumerable";
+                targetEnumerableState = "non-enumerable";
             }
 
+            var sourceValue = GetSourceValue(customValue);
+
             throw new MappingConfigurationException(string.Format(
                 CultureInfo.InvariantCulture,
-                "{0}'{1}' cannot be mapped to target type '{2}'",
+                "{0} {1}'{2}' cannot be mapped to {3} target type '{4}'",
+                sourceEnumerableState,
                 sourceValue,
                 customValue.Type.GetFriendlyName(),
+                targetEnumerableState,
                 targetMemberType.GetFriendlyName()));
         }
 
+        private string GetSourceValue(Expression customValue)
+        {
+            if (customValue.NodeType != ExpressionType.MemberAccess)
+            {
+                return "Source type ";
+            }
+
+            var rootSourceMember = _configInfo.MapperContext.QualifiedMemberFactory.RootSource<TSource, TTarget>();
+            var sourceMember = customValue.ToSourceMember(_configInfo.MapperContext);
+            var sourceValue = sourceMember.GetFriendlyMemberPath(rootSourceMember) + " of type ";
+
+            return sourceValue;
+        }
+
         private MappingConfigContinuation<TSource, TTarget> RegisterDataSource<TTargetValue>(
             Func<ConfiguredDataSourceFactory> factoryFactory)
         {

AgileMapper/Configuration/UserConfiguredItemBase.cs

@@ -26,7 +26,17 @@ protected UserConfiguredItemBase(MappingConfigInfo configInfo, LambdaExpression
 
         private static QualifiedMember GetTargetMemberOrThrow(LambdaExpression lambda, MappingConfigInfo configInfo)
         {
-            var targetMember = lambda.ToTargetMember(configInfo.MapperContext);
+            QualifiedMember targetMember;
+
+            try
+            {
+                targetMember = lambda.ToTargetMember(configInfo.MapperContext);
+            }
+            catch (NotSupportedException)
+            {
+                throw new MappingConfigurationException(
+                    $"Unable to determine target member from '{lambda.Body.ToReadableString()}'");
+            }
 
             if (targetMember == null)
             {

AgileMapper/Members/MemberExtensions.cs

@@ -282,7 +282,7 @@ public static QualifiedMember ToTargetMember(this LambdaExpression memberAccess,
                 mapperContext);
         }
 
-        internal static QualifiedMember CreateMember(
+        private static QualifiedMember CreateMember(
             Expression memberAccessExpression,
             Func<Type, Member> rootMemberFactory,
             Func<Type, IList<Member>> membersFactory,