Bugs/issue130

AgileMapper.UnitTests.Orms.EfCore2/AgileMapper.UnitTests.Orms.EfCore2.csproj

@@ -60,9 +60,6 @@
     <Reference Include="Microsoft.Extensions.Caching.Memory, Version=2.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
       <HintPath>..\packages\Microsoft.Extensions.Caching.Memory.2.0.0\lib\netstandard2.0\Microsoft.Extensions.Caching.Memory.dll</HintPath>
     </Reference>
-    <Reference Include="Microsoft.Extensions.Configuration.Abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
-      <HintPath>..\packages\Microsoft.Extensions.Configuration.Abstractions.2.0.0\lib\netstandard2.0\Microsoft.Extensions.Configuration.Abstractions.dll</HintPath>
-    </Reference>
     <Reference Include="Microsoft.Extensions.DependencyInjection, Version=2.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
       <HintPath>..\packages\Microsoft.Extensions.DependencyInjection.2.0.0\lib\netstandard2.0\Microsoft.Extensions.DependencyInjection.dll</HintPath>
     </Reference>

AgileMapper.UnitTests/Configuration/WhenConfiguringDerivedTypes.cs

@@ -1,5 +1,6 @@
 namespace AgileObjects.AgileMapper.UnitTests.Configuration
 {
+    using System;
     using System.Collections.Generic;
     using AgileMapper.Extensions.Internal;
     using Common;
@@ -214,8 +215,8 @@ public void ShouldUseATypedToTarget()
                     .Map(ctx => ctx.Source.Leaf)
                     .ToTarget<Issue123.Leaf>()
                     .AndWhenMapping
-                    .From<Issue123.CompositeDto>().To<Issue123.Leaf>()
-                    .Map((dto, l) => dto.Leaf.Description + "!")
+                    .From<Issue123.LeafDto>().To<Issue123.Leaf>()
+                    .Map((dto, l) => dto.Description + "!")
                     .To(l => l.Description);
 
                 var leafDto = new Issue123.CompositeDto
@@ -233,6 +234,66 @@ public void ShouldUseATypedToTarget()
             }
         }
 
+        [Fact]
+        public void ShouldUseACtorParameterWithATypedToTarget()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                mapper.WhenMapping
+                    .From<Issue129.Source.Wrapper>()
+                    .To<Issue129.Target.ITrafficObj>()
+                    .If(d => d.Source.ConcreteValue == Issue129.Source.Wrapper.ConcreteValueType.Delay)
+                    .Map(d => d.Source.DelayValue)
+                    .ToTarget<Issue129.Target.DelayObject>();
+
+                var delaySource = new Issue129.Source.Wrapper
+                {
+                    ConcreteValue = Issue129.Source.Wrapper.ConcreteValueType.Delay,
+                    DelayValue = new Issue129.Source.DelayObject
+                    {
+                        Name = "Situation Object",
+                        Duration = TimeSpan.FromHours(2).ToString()
+                    }
+                };
+
+                var delayResult = mapper.Map(delaySource).ToANew<Issue129.Target.ITrafficObj>();
+
+                delayResult.ShouldNotBeNull();
+                delayResult.ShouldBeOfType<Issue129.Target.DelayObject>();
+
+                var delayObject = (Issue129.Target.DelayObject)delayResult;
+                delayObject.CurrentClass.ShouldNotBeNull();
+                delayObject.CurrentClass.ShouldBeOfType<Issue129.Target.DelayClass>();
+
+                var delayClass = (Issue129.Target.DelayClass)delayObject.CurrentClass;
+                delayClass.Name.ShouldBe("Delay");
+                delayClass.Duration.ShouldBe(TimeSpan.FromHours(2));
+            }
+        }
+
+        [Fact]
+        public void ShouldHandleANullTypedToTargetSource()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                mapper.WhenMapping
+                    .From<Issue129.Source.Wrapper>()
+                    .To<Issue129.Target.ITrafficObj>()
+                    .If(d => d.Source.ConcreteValue == Issue129.Source.Wrapper.ConcreteValueType.Delay)
+                    .Map(d => d.Source.DelayValue)
+                    .ToTarget<Issue129.Target.DelayObject>();
+
+                var nullDelaySource = new Issue129.Source.Wrapper
+                {
+                    ConcreteValue = Issue129.Source.Wrapper.ConcreteValueType.Delay
+                };
+
+                var delayResult = mapper.Map(nullDelaySource).ToANew<Issue129.Target.ITrafficObj>();
+
+                delayResult.ShouldBeNull();
+            }
+        }
+
         // See https://github.com/agileobjects/AgileMapper/issues/129
         [Fact]
         public void ShouldUseAConfiguredCtorParameterWithATypedToTarget()
@@ -248,7 +309,7 @@ public void ShouldUseAConfiguredCtorParameterWithATypedToTarget()
                 mapper.WhenMapping
                     .From<Issue129.Source.ActionObject>()
                     .To<Issue129.Target.ActionObject>()
-                    .Map(new Issue129.Target.ActionClass())
+                    .Map(ctx => new Issue129.Target.ActionClass())
                     .ToCtor<Issue129.Target.ActionClass>();
 
                 mapper.WhenMapping
@@ -261,6 +322,31 @@ public void ShouldUseAConfiguredCtorParameterWithATypedToTarget()
                     .If(d => d.Source.ConcreteValue == Issue129.Source.Wrapper.ConcreteValueType.Situation)
                     .Map(d => d.Source.SituationValue)
                     .ToTarget<Issue129.Target.SituationObject>();
+
+                var situationSource = new Issue129.Source.Wrapper
+                {
+                    ConcreteValue = Issue129.Source.Wrapper.ConcreteValueType.Situation,
+                    SituationValue = new Issue129.Source.SituationObject
+                    {
+                        Name = "Situation Object",
+                        CurrentClass = new Issue129.Source.SituationClass
+                        {
+                            Name = "Situation Class"
+                        }
+                    }
+                };
+
+                var situationResult = mapper.Map(situationSource).ToANew<Issue129.Target.ITrafficObj>();
+
+                situationResult.ShouldNotBeNull();
+                situationResult.ShouldBeOfType<Issue129.Target.SituationObject>();
+
+                var situationObject = (Issue129.Target.SituationObject)situationResult;
+                situationObject.CurrentClass.ShouldNotBeNull();
+                situationObject.CurrentClass.ShouldBeOfType<Issue129.Target.SituationClass>();
+
+                var situationClass = (Issue129.Target.SituationClass)situationObject.CurrentClass;
+                situationClass.Name.ShouldBe("Situation Class");
             }
         }
 
@@ -334,7 +420,7 @@ public class Leaf : ILeaf
             }
         }
 
-        internal class Issue129
+        internal static class Issue129
         {
             public static class Source
             {
@@ -348,22 +434,31 @@ public class SituationObject
                     public string Name { get; set; }
 
                     public SituationClass CurrentClass { get; set; }
-
                 }
+
                 public class ActionObject
                 {
                     public string Name { get; set; }
                 }
 
+                public class DelayObject
+                {
+                    public string Name { get; set; }
+
+                    public string Duration { get; set; }
+                }
+
                 public class Wrapper
                 {
-                    public enum ConcreteValueType { Situation, Action }
+                    public enum ConcreteValueType { Situation, Action, Delay }
 
                     public ConcreteValueType ConcreteValue { get; set; }
 
                     public SituationObject SituationValue { get; set; }
 
                     public ActionObject ActionValue { get; set; }
+
+                    public DelayObject DelayValue { get; set; }
                 }
             }
 
@@ -373,22 +468,49 @@ public interface ITrafficObj { ITrafficClass CurrentClass { get; } }
 
                 public interface ITrafficClass { string Name { get; } }
 
-                public class SituationClass : ITrafficClass { public string Name { get; set; } }
+                public class SituationClass : ITrafficClass
+                {
+                    public string Name { get; set; }
+                }
+
+                public class ActionClass : ITrafficClass
+                {
+                    public string Name { get; set; }
+                }
+
+                public class DelayClass : ITrafficClass
+                {
+                    public string Name { get; set; }
 
-                public class ActionClass : ITrafficClass { public string Name { get; set; } }
+                    public TimeSpan Duration { get; set; }
+                }
 
                 public class SituationObject : ITrafficObj
                 {
                     public SituationObject(SituationClass clazz) { CurrentClass = clazz; }
 
-                    public ITrafficClass CurrentClass { get; private set; }
+                    public ITrafficClass CurrentClass { get; }
                 }
 
                 public class ActionObject : ITrafficObj
                 {
                     public ActionObject(ActionClass clazz) { CurrentClass = clazz; }
 
-                    public ITrafficClass CurrentClass { get; private set; }
+                    public ITrafficClass CurrentClass { get; }
+                }
+
+                public class DelayObject : ITrafficObj
+                {
+                    public DelayObject(TimeSpan duration)
+                    {
+                        CurrentClass = new DelayClass
+                        {
+                            Name = "Delay",
+                            Duration = duration
+                        };
+                    }
+
+                    public ITrafficClass CurrentClass { get; }
                 }
             }
         }

AgileMapper.UnitTests/Configuration/WhenConfiguringMappingCallbacks.cs

@@ -2,6 +2,7 @@
 {
     using System;
     using System.Collections.Generic;
+    using AgileMapper.Extensions.Internal;
     using Common;
     using TestClasses;
 #if !NET35
@@ -355,5 +356,116 @@ public void ShouldPopulateAChildTargetObjectInAPostMappingCallback()
                 result.Value.Value.ShouldBe("Hello!");
             }
         }
+
+        [Fact]
+        public void ShouldExecuteAPreMappingCallbackInARootToTargetMapping()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                var callbackCalled = false;
+
+                mapper.WhenMapping
+                    .From<PublicTwoFields<PublicField<int>, int>>()
+                    .To<PublicField<int>>()
+                    .Map(ctx => ctx.Source.Value1)
+                    .ToTarget();
+
+                mapper.WhenMapping
+                    .From<PublicField<int>>()
+                    .To<PublicField<int>>()
+                    .Before.MappingBegins
+                    .Call(md => callbackCalled = true);
+
+                var source = new PublicTwoFields<PublicField<int>, int>
+                {
+                    Value1 = new PublicField<int> { Value = 123 },
+                    Value2 = 456
+                };
+
+                var result = mapper.Map(source).ToANew<PublicField<int>>();
+
+                result.Value.ShouldBe(123);
+                callbackCalled.ShouldBeTrue();
+            }
+        }
+
+        [Fact]
+        public void ShouldExecuteAPreMappingCallbackInAChildToTargetMapping()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                var callbackCalled = false;
+
+                mapper.WhenMapping
+                    .From<PublicTwoFields<PublicField<int>, int>>()
+                    .To<PublicField<int>>()
+                    .Map(ctx => ctx.Source.Value1)
+                    .ToTarget();
+
+                mapper.WhenMapping
+                    .From<PublicField<int>>()
+                    .To<PublicField<int>>()
+                    .After.MappingEnds
+                    .Call(md => callbackCalled = true);
+
+                var source = new PublicProperty<PublicTwoFields<PublicField<int>, int>>
+                {
+                    Value = new PublicTwoFields<PublicField<int>, int>
+                    {
+                        Value1 = new PublicField<int> { Value = 456 },
+                        Value2 = 123
+                    }
+                };
+
+                var result = mapper.Map(source).ToANew<PublicSetMethod<PublicField<int>>>();
+
+                result.Value.ShouldNotBeNull();
+                result.Value.Value.ShouldBe(456);
+                callbackCalled.ShouldBeTrue();
+            }
+        }
+
+        [Fact]
+        public void ShouldExecuteAPreMappingCallbackInAnElementToTargetMapping()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                var callbackCount = 0;
+
+                mapper.WhenMapping
+                    .From<PublicTwoFields<int, PublicField<int>>>()
+                    .To<PublicField<int>>()
+                    .Map(ctx => ctx.Source.Value2)
+                    .ToTarget();
+
+                mapper.WhenMapping
+                    .From<PublicField<int>>()
+                    .To<PublicField<int>>()
+                    .After.MappingEnds
+                    .Call(md => ++callbackCount);
+
+                var source = new[]
+                {
+                    new PublicTwoFields<int, PublicField<int>>
+                    {
+                        Value1 = 111,
+                        Value2 = new PublicField<int> { Value = 222 },
+                    },
+                    new PublicTwoFields<int, PublicField<int>>
+                    {
+                        Value1 = 333,
+                        Value2 = new PublicField<int> { Value = 444 },
+                    }
+                };
+
+                var result = mapper.Map(source).ToANew<PublicField<int>[]>();
+
+                result.ShouldNotBeNull();
+                result.Length.ShouldBe(2);
+                result.First().Value.ShouldBe(222);
+                result.Second().Value.ShouldBe(444);
+                callbackCount.ShouldBe(2);
+            }
+        }
     }
 }