Erroring if map-to-null conditions are configured for the same type

Author: SteveWilkes

AgileMapper.UnitTests/Configuration/WhenMappingToNull.cs

@@ -1,6 +1,7 @@
 namespace AgileObjects.AgileMapper.UnitTests.Configuration
 {
     using System;
+    using AgileMapper.Configuration;
     using Shouldly;
     using TestClasses;
     using Xunit;
@@ -91,5 +92,27 @@ public void ShouldOverwriteAPropertyToNull()
                 target.Address.ShouldBeNull();
             }
         }
+
+        [Fact]
+        public void ShouldErrorIfConditionsAreConfiguredForTheSameType()
+        {
+            var configEx = Should.Throw<MappingConfigurationException>(() =>
+            {
+                using (var mapper = Mapper.CreateNew())
+                {
+                    mapper.WhenMapping
+                        .To<Address>()
+                        .If((o, a) => a.Line1 == null)
+                        .MapToNull();
+
+                    mapper.WhenMapping
+                        .To<Address>()
+                        .If((o, a) => a.Line1 == string.Empty)
+                        .MapToNull();
+                }
+            });
+
+            configEx.Message.ShouldContain("already has");
+        }
     }
 }

AgileMapper/Configuration/DerivedTypePair.cs

@@ -98,7 +98,7 @@ public override bool AppliesTo(IBasicMapperData mapperData)
         public override string ToString()
         {
             var rootSourceType = ConfigInfo.SourceType.GetFriendlyName();
-            var rootTargetType = ConfigInfo.TargetType.GetFriendlyName();
+            var rootTargetType = TargetTypeName;
             var derivedSourceType = DerivedSourceType.GetFriendlyName();
             var derivedTargetType = DerivedTargetType.GetFriendlyName();
 

AgileMapper/Configuration/MapToNullCondition.cs

@@ -11,6 +11,8 @@ public MapToNullCondition(MappingConfigInfo configInfo)
         {
         }
 
+        protected override bool ConditionsAvoidConflict(UserConfiguredItemBase otherConfiguredItem) => false;
+
         protected override Expression GetConditionOrNull(IMemberMapperData mapperData, CallbackPosition position)
         {
             mapperData.Context.UsesMappingDataObjectAsParameter =

AgileMapper/Configuration/UserConfigurationSet.cs

@@ -60,6 +60,11 @@ public bool DisableObjectTracking(IBasicMapperData basicData)
 
         public void Add(MapToNullCondition condition)
         {
+            ThrowIfConflictingItemExists(
+                condition,
+                _mapToNullConditions,
+                c => "Type " + c.TargetTypeName + " already has a configured map-to-null condition");
+
             _mapToNullConditions.Add(condition);
         }
 
@@ -204,24 +209,28 @@ private void ThrowIfConflictingIgnoredMemberExists<TConfiguredItem>(
             Func<TConfiguredItem, string> messageFactory)
             where TConfiguredItem : UserConfiguredItemBase
         {
-            var conflictingIgnoredMember = _ignoredMembers
-                .FirstOrDefault(im => im.ConflictsWith(configuredItem));
-
-            if (conflictingIgnoredMember != null)
-            {
-                throw new MappingConfigurationException(messageFactory.Invoke(configuredItem));
-            }
+            ThrowIfConflictingItemExists(configuredItem, _ignoredMembers, messageFactory);
         }
 
         internal void ThrowIfConflictingDataSourceExists<TConfiguredItem>(
             TConfiguredItem configuredItem,
             Func<TConfiguredItem, string> messageFactory)
             where TConfiguredItem : UserConfiguredItemBase
         {
-            var conflictingDataSource = _dataSourceFactories
+            ThrowIfConflictingItemExists(configuredItem, _dataSourceFactories, messageFactory);
+        }
+
+        private static void ThrowIfConflictingItemExists<TConfiguredItem, TExistingItem>(
+            TConfiguredItem configuredItem,
+            IEnumerable<TExistingItem> existingItems,
+            Func<TConfiguredItem, string> messageFactory)
+            where TConfiguredItem : UserConfiguredItemBase
+            where TExistingItem : UserConfiguredItemBase
+        {
+            var conflictingItem = existingItems
                 .FirstOrDefault(dsf => dsf.ConflictsWith(configuredItem));
 
-            if (conflictingDataSource != null)
+            if (conflictingItem != null)
             {
                 throw new MappingConfigurationException(messageFactory.Invoke(configuredItem));
             }

AgileMapper/Configuration/UserConfiguredItemBase.cs

@@ -8,6 +8,7 @@
     using Members;
     using ObjectPopulation;
     using ReadableExpressions;
+    using ReadableExpressions.Extensions;
 
     internal abstract class UserConfiguredItemBase : IComparable<UserConfiguredItemBase>
     {
@@ -42,13 +43,15 @@ protected UserConfiguredItemBase(MappingConfigInfo configInfo, QualifiedMember t
 
         protected MappingConfigInfo ConfigInfo { get; }
 
+        public string TargetTypeName => ConfigInfo.TargetType.GetFriendlyName();
+
         public QualifiedMember TargetMember { get; }
 
         public bool HasConfiguredCondition => ConfigInfo.HasCondition;
 
         public virtual bool ConflictsWith(UserConfiguredItemBase otherConfiguredItem)
         {
-            if (HasConfiguredCondition || otherConfiguredItem.HasConfiguredCondition)
+            if (ConditionsAvoidConflict(otherConfiguredItem))
             {
                 return false;
             }
@@ -61,6 +64,9 @@ public virtual bool ConflictsWith(UserConfiguredItemBase otherConfiguredItem)
             return false;
         }
 
+        protected virtual bool ConditionsAvoidConflict(UserConfiguredItemBase otherConfiguredItem)
+            => HasConfiguredCondition || otherConfiguredItem.HasConfiguredCondition;
+
         protected virtual bool MembersConflict(QualifiedMember otherMember)
             => TargetMember.Matches(otherMember);