Including target complex type constructability in mapping validation

Author: SteveWilkes

AgileMapper.UnitTests/WhenValidatingMappings.cs

@@ -72,7 +72,7 @@ public void ShouldNotErrorIfCachedMappingMemberIsIgnored()
                     .From<PublicProperty<string>>().To<PublicField<int>>()
                     .Ignore(pf => pf.Value);
 
-                mapper.GetPlanFor<PublicProperty<string>>().OnTo<PublicField<int>>();
+                string plan = mapper.GetPlanFor<PublicProperty<string>>().OnTo<PublicField<int>>();
 
                 Should.NotThrow(() => mapper.ThrowNowIfAnyMappingPlanIsIncomplete());
             }
@@ -106,6 +106,8 @@ public void ShouldErrorIfComplexTypeMemberIsUnconstructable()
                     mapper.ThrowNowIfAnyMappingPlanIsIncomplete());
 
                 validationEx.Message.ShouldContain("PublicField<PublicField<int>> -> PublicProperty<PublicTwoParamCtor<int, int>>");
+                validationEx.Message.ShouldContain("Unconstructable target Types");
+                validationEx.Message.ShouldContain("PublicField<int> -> PublicTwoParamCtor<int, int>");
                 validationEx.Message.ShouldContain("Unmapped target members");
                 validationEx.Message.ShouldContain("PublicProperty<PublicTwoParamCtor<int, int>>.Value");
             }
@@ -145,6 +147,24 @@ public void ShouldErrorIfEnumerableMemberHasNonEnumerableSource()
             }
         }
 
+        [Fact]
+        public void ShouldErrorIfEnumerableMemberHasUnconstructableElements()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                mapper
+                    .GetPlanFor<Address[]>()
+                    .ToANew<PublicCtor<string>[]>();
+
+                var validationEx = Should.Throw<MappingValidationException>(() =>
+                    mapper.ThrowNowIfAnyMappingPlanIsIncomplete());
+
+                validationEx.Message.ShouldContain("Address[] -> PublicCtor<string>[]");
+                validationEx.Message.ShouldContain("Unconstructable target Types");
+                validationEx.Message.ShouldContain("Address -> PublicCtor<string>");
+            }
+        }
+
         [Fact]
         public void ShouldShowMultipleIncompleteCachedMappingPlans()
         {

AgileMapper/Validation/MappingValidator.cs

@@ -8,6 +8,7 @@
     using Extensions.Internal;
     using Members;
     using ObjectPopulation;
+    using ReadableExpressions.Extensions;
 
     internal static class MappingValidator
     {
@@ -62,6 +63,7 @@ private static void VerifyMappingPlanIsComplete(IEnumerable<ObjectMapperData> ma
                 failureMessage
                     .Append(" Rule set: ").AppendLine(rootData.RuleSet.Name).AppendLine();
 
+                AddUnmappableTargetTypesInfo(mappingData.UnmappableTargetTypes, failureMessage);
                 AddUnmappedTargetMembersInfo(mappingData.UnmappedMembers, failureMessage, rootData);
                 AddUnpairedEnumsInfo(mappingData.UnpairedEnums, failureMessage);
             }
@@ -76,18 +78,26 @@ private static ICollection<IncompleteMappingData> GetIncompleteMappingPlanData(
                 .Select(md => new
                 {
                     MapperData = md,
+                    IsUnmappable =
+                        !md.IsRoot &&
+                         md.TargetMember.IsComplex &&
+                         md.DataSourcesByTargetMember.None(),
                     UnmappedMembers = md
                         .DataSourcesByTargetMember
                         .Where(pair => !pair.Value.HasValue)
                         .Select(pair => pair)
                         .ToArray(),
                     UnpairedEnums = EnumMappingMismatchFinder.FindMismatches(md)
                 })
-                .Where(d => d.UnmappedMembers.Any() || d.UnpairedEnums.Any())
+                .Where(d => d.IsUnmappable || d.UnmappedMembers.Any() || d.UnpairedEnums.Any())
                 .GroupBy(d => d.MapperData.GetRootMapperData())
                 .Select(g => new IncompleteMappingData
                 {
                     RootMapperData = g.Key,
+                    UnmappableTargetTypes = g
+                        .Where(d => d.IsUnmappable)
+                        .Select(d => d.MapperData)
+                        .ToList(),
                     UnmappedMembers = g
                         .SelectMany(d => d.UnmappedMembers)
                         .ToDictionary(kvp => kvp.Key, kvp => kvp.Value),
@@ -124,6 +134,30 @@ private static void AddMappingTypeHeaderIfRequired(
             previousRootMapperData = rootData;
         }
 
+        private static void AddUnmappableTargetTypesInfo(
+            ICollection<ObjectMapperData> unmappableTargetTypeData,
+            StringBuilder failureMessage)
+        {
+            if (unmappableTargetTypeData.None())
+            {
+                return;
+            }
+
+            failureMessage
+                .AppendLine(" Unconstructable target Types - fix by ignoring or configuring constructor parameters:")
+                .AppendLine();
+
+            foreach (var unmappableTypeData in unmappableTargetTypeData)
+            {
+                var sourceTypeName = unmappableTypeData.SourceType.GetFriendlyName();
+                var targetTypeName = unmappableTypeData.TargetType.GetFriendlyName();
+
+                failureMessage.Append("  - ").Append(sourceTypeName).Append(" -> ").AppendLine(targetTypeName);
+            }
+
+            failureMessage.AppendLine();
+        }
+
         private static void AddUnmappedTargetMembersInfo(
             Dictionary<QualifiedMember, DataSourceSet> unmappedMembers,
             StringBuilder failureMessage,
@@ -144,6 +178,8 @@ private static void AddUnmappedTargetMembersInfo(
 
                 failureMessage.Append("  - ").AppendLine(targetMemberPath);
             }
+
+            failureMessage.AppendLine();
         }
 
         private static void AddUnpairedEnumsInfo(
@@ -173,16 +209,16 @@ private static void AddUnpairedEnumsInfo(
         }
 
         private static IEnumerable<ObjectMapperData> GetAllMapperDatas(IEnumerable<ObjectMapperData> mapperDatas)
-        {
-            return mapperDatas.SelectMany(md => md.EnumerateAllMapperDatas());
-        }
+            => mapperDatas.SelectMany(md => md.EnumerateAllMapperDatas());
 
         #region Helper Class
 
         private class IncompleteMappingData
         {
             public IMemberMapperData RootMapperData { get; set; }
 
+            public ICollection<ObjectMapperData> UnmappableTargetTypes { get; set; }
+
             public Dictionary<QualifiedMember, DataSourceSet> UnmappedMembers { get; set; }
 
             public ICollection<EnumMappingMismatchSet> UnpairedEnums { get; set; }