Increasing MapperConfiguration test coverage / Creating single service dictionary for all MapperConfigurations

Author: SteveWilkes

AgileMapper.UnitTests.MoreTestClasses/ServiceDictionaryMapperConfiguration.cs

@@ -7,7 +7,7 @@ public class ServiceDictionaryMapperConfiguration : MapperConfiguration
     {
         protected override void Configure()
         {
-            var mappersByName = GetServiceOrNull<Dictionary<string, IMapper>>();
+            var mappersByName = GetServiceOrThrow<Dictionary<string, IMapper>>();
 
             var mapper1 = CreateNewMapper();
 

AgileMapper.UnitTests/Configuration/WhenApplyingMapperConfigurations.cs

@@ -107,6 +107,27 @@ public void ShouldFilterMapperConfigurationsFromGivenAssemblies()
             });
         }
 
+        [Fact]
+        public void ShouldApplyMapperConfigurationCallbacks()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                var data = new Dictionary<string, object>();
+
+                mapper.WhenMapping
+                    .UseConfigurations.From<CallbacksMapperConfiguration>(data);
+
+                var source = new Address { Line1 = "One", Line2 = "Two" };
+                var result = mapper.DeepClone(source);
+
+                result.Line1.ShouldBe("One");
+                result.Line2.ShouldBe("Two");
+
+                data["SourceAddress"].ShouldBe(source);
+                data["TargetAddress"].ShouldBe(result);
+            }
+        }
+
         #region Helper Classes
 
         public class PfiToPfsMapperConfiguration : MapperConfiguration
@@ -154,6 +175,28 @@ public static void VerifyConfigured(IMapper mapper)
             }
         }
 
+        public class CallbacksMapperConfiguration : MapperConfiguration
+        {
+            protected override void Configure()
+            {
+                var dataByKey = GetServiceOrNull<Dictionary<string, object>>();
+
+                if (dataByKey == null)
+                {
+                    return;
+                }
+
+                WhenMapping
+                    .From<Address>()
+                    .To<Address>()
+                    .Before.MappingBegins
+                    .Call(ctx => dataByKey["SourceAddress"] = ctx.Source)
+                    .And
+                    .After.MappingEnds
+                    .Call(ctx => dataByKey["TargetAddress"] = ctx.Target);
+            }
+        }
+
         #endregion
     }
 }

AgileMapper/Api/Configuration/MapperConfigurationSpecifier.cs

@@ -14,6 +14,8 @@
     /// </summary>
     public class MapperConfigurationSpecifier
     {
+        private static readonly IDictionary<Type, object> _noServices = new Dictionary<Type, object>();
+
         private readonly IMapper _mapper;
 
         internal MapperConfigurationSpecifier(IMapper mapper)
@@ -39,7 +41,7 @@ public MapperConfigurationSpecifier From<TConfiguration>(params object[] service
         {
             var configuration = new TConfiguration();
 
-            Apply(configuration, services);
+            Apply(configuration, CreateServiceCache(services));
             return this;
         }
 
@@ -127,17 +129,36 @@ private void ApplyConfigurationsIn(Assembly assembly, ICollection<object> servic
                 .Filter(t => !t.IsAbstract() && t.IsDerivedFrom(typeof(MapperConfiguration)))
                 .Project(t => (MapperConfiguration)Activator.CreateInstance(t));
 
+            var servicesByType = CreateServiceCache(services);
+
             foreach (var configuration in configurations)
             {
-                Apply(configuration, services);
+                Apply(configuration, servicesByType);
+            }
+        }
+
+        private static IDictionary<Type, object> CreateServiceCache(ICollection<object> services)
+        {
+            if (services.None())
+            {
+                return _noServices;
+            }
+
+            var serviceCache = new Dictionary<Type, object>(services.Count);
+
+            foreach (var service in services)
+            {
+                serviceCache[service.GetType()] = service;
             }
+
+            return serviceCache;
         }
 
-        private void Apply(MapperConfiguration configuration, ICollection<object> services)
+        private void Apply(MapperConfiguration configuration, IDictionary<Type, object> servicesByType)
         {
             try
             {
-                configuration.ApplyTo(_mapper, services);
+                configuration.ApplyTo(_mapper, servicesByType);
             }
             catch (Exception ex)
             {

AgileMapper/Configuration/MapperConfiguration.cs

@@ -5,46 +5,42 @@
     using System.Linq;
     using Api;
     using Api.Configuration;
-    using Extensions.Internal;
     using Queryables.Api;
+    using ReadableExpressions.Extensions;
 
     /// <summary>
     /// Base class for multiple, dedicated mapper configuration classes.
     /// </summary>
     public abstract class MapperConfiguration
     {
-        private Dictionary<Type, object> _servicesByType;
+        private IDictionary<Type, object> _servicesByType;
         private IMapper _mapper;
 
-        internal void ApplyTo(IMapper mapper, ICollection<object> services)
+        internal void ApplyTo(IMapper mapper, IDictionary<Type, object> servicesByType)
         {
             _mapper = mapper;
-
-            if (services.Any())
-            {
-                _servicesByType = CreateServiceCache(services);
-            }
+            _servicesByType = servicesByType;
 
             Configure();
         }
 
-        private static Dictionary<Type, object> CreateServiceCache(ICollection<object> services)
-        {
-            var serviceCache = new Dictionary<Type, object>(services.Count);
-
-            foreach (var service in services)
-            {
-                serviceCache[service.GetType()] = service;
-            }
-
-            return serviceCache;
-        }
-
         /// <summary>
         /// Configure how mappings should be performed.
         /// </summary>
         protected abstract void Configure();
 
+        /// <summary>
+        /// Get the registered <typeparamref name="TService"/> instance to assist with mapper configuration.
+        /// </summary>
+        /// <typeparam name="TService">The type of the service to retrieve.</typeparam>
+        /// <returns>The registered <typeparamref name="TService"/> instance, or null if none is registered.</returns>
+        protected TService GetServiceOrThrow<TService>()
+            where TService : class
+        {
+            return GetServiceOrNull<TService>()
+                ?? throw new MappingConfigurationException($"No service of type {typeof(TService).GetFriendlyName()} is available");
+        }
+
         /// <summary>
         /// Get the registered <typeparamref name="TService"/> instance to assist with mapper configuration.
         /// </summary>