Struct support

AgileMapper.UnitTests/AgileMapper.UnitTests.csproj

@@ -90,6 +90,18 @@
     <Compile Include="Dictionaries\WhenCreatingRootDictionaryMembers.cs" />
     <Compile Include="MapperCloning\WhenCloningMapperObjectFactories.cs" />
     <Compile Include="SimpleTypeConversion\WhenConvertingToCharacters.cs" />
+    <Compile Include="Structs\Configuration\WhenConfiguringStructCreationCallbacks.cs" />
+    <Compile Include="Structs\Configuration\WhenConfiguringStructDataSources.cs" />
+    <Compile Include="Structs\Configuration\WhenConfiguringStructMappingCallbacks.cs" />
+    <Compile Include="Structs\Dictionaries\WhenMappingFromDictionariesToStructs.cs" />
+    <Compile Include="Structs\WhenMappingOnToStructMembers.cs" />
+    <Compile Include="Structs\WhenMappingOnToStructs.cs" />
+    <Compile Include="Structs\WhenMappingOverStructMembers.cs" />
+    <Compile Include="Structs\WhenMappingOverStructs.cs" />
+    <Compile Include="Structs\WhenMappingToStructEnumerables.cs" />
+    <Compile Include="Structs\WhenMappingToUnmappableStructMembers.cs" />
+    <Compile Include="Structs\WhenMappingToNewStructMembers.cs" />
+    <Compile Include="Structs\WhenMappingToNewStructs.cs" />
     <Compile Include="TestClasses\Earthworm.cs" />
     <Compile Include="TestClasses\IPublicInterface.cs" />
     <Compile Include="TestClasses\MegaProduct.cs" />
@@ -125,10 +137,13 @@
     <Compile Include="TestClasses\OrderUs.cs" />
     <Compile Include="TestClasses\PaymentTypeUk.cs" />
     <Compile Include="TestClasses\PaymentTypeUs.cs" />
+    <Compile Include="TestClasses\PublicCtorStruct.cs" />
     <Compile Include="TestClasses\PublicFactoryMethod.cs" />
     <Compile Include="TestClasses\PublicImplementation.cs" />
     <Compile Include="TestClasses\PublicSealed.cs" />
+    <Compile Include="TestClasses\PublicPropertyStruct.cs" />
     <Compile Include="TestClasses\PublicTwoFields.cs" />
+    <Compile Include="TestClasses\PublicTwoFieldsStruct.cs" />
     <Compile Include="TestClasses\PublicTwoParamCtor.cs" />
     <Compile Include="TestClasses\Wedding.cs" />
     <Compile Include="TestClasses\WeddingDto.cs" />
@@ -214,6 +229,7 @@
       <Name>AgileMapper.UnitTests.MoreTestClasses</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
     <PropertyGroup>

AgileMapper.UnitTests/Configuration/WhenConfiguringMappingCallbacks.cs

@@ -15,9 +15,7 @@ public void ShouldExecuteAGlobalPreMappingCallback()
             {
                 var mappedNames = new List<string>();
 
-                mapper
-                    .Before
-                    .MappingBegins
+                mapper.Before.MappingBegins
                     .Call((s, t) => mappedNames.AddRange(new[] { ((Person)s).Name, ((PersonViewModel)t).Name }));
 
                 var source = new Person { Name = "Bernie" };
@@ -36,9 +34,7 @@ public void ShouldExecuteAGlobalPostMappingCallbackConditionally()
             {
                 var mappedNames = new List<string>();
 
-                mapper
-                    .After
-                    .MappingEnds
+                mapper.After.MappingEnds
                     .If((s, t) => t.GetType() != typeof(Address))
                     .Call(ctx => mappedNames.AddRange(new[] { ((PersonViewModel)ctx.Source).Name, ((Person)ctx.Target).Name }));
 

AgileMapper.UnitTests/Configuration/WhenConfiguringObjectCreationCallbacks.cs

@@ -18,59 +18,62 @@ public void ShouldCallAGlobalObjectCreatedCallback()
         {
             using (var mapper = Mapper.CreateNew())
             {
-                var createdInstance = default(PublicProperty<int>);
+                var createdInstance = default(object);
 
                 mapper.After
                     .CreatingInstances
-                    .Call(ctx => createdInstance = (PublicProperty<int>)ctx.CreatedObject);
+                    .Call(ctx => createdInstance = ctx.CreatedObject);
 
                 var source = new PublicField<int>();
                 var result = mapper.Map(source).ToANew<PublicProperty<int>>();
 
                 createdInstance.ShouldNotBeNull();
-                createdInstance.ShouldBe(result);
+                createdInstance.ShouldBeOfType<PublicProperty<int>>();
+                createdInstance.ShouldBeSameAs(result);
             }
         }
 
         [Fact]
         public void ShouldWrapAnObjectCreatedCallbackException()
         {
-            Should.Throw<MappingException>(() =>
+            var createdEx = Should.Throw<MappingException>(() =>
             {
                 using (var mapper = Mapper.CreateNew())
                 {
                     mapper.After
                         .CreatingInstances
-                        .Call(ctx => { throw new InvalidOperationException(); });
+                        .Call(ctx => throw new InvalidOperationException());
 
                     mapper.Map(new PublicProperty<int>()).ToANew<PublicField<int>>();
                 }
             });
+
+            createdEx.ShouldNotBeNull();
+            createdEx.Message.ShouldContain("mapping PublicProperty<int> -> PublicField<int>");
         }
 
         [Fact]
         public void ShouldWrapANestedObjectCreatingCallbackException()
         {
-            var exception = Should.Throw<MappingException>(() =>
+            var createdEx = Should.Throw<MappingException>(() =>
             {
                 using (var mapper = Mapper.CreateNew())
                 {
-                    mapper
-                        .After
+                    mapper.After
                         .CreatingInstancesOf<Address>()
-                        .Call(ctx => { throw new InvalidOperationException("OH NO"); });
+                        .Call(ctx => throw new InvalidOperationException("OH NO"));
 
                     mapper.Map(new PersonViewModel { AddressLine1 = "My House" }).ToANew<Person>();
                 }
             });
 
-            exception.InnerException.ShouldNotBeNull();
-            exception.InnerException.ShouldBeOfType<MappingException>();
+            createdEx.InnerException.ShouldNotBeNull();
+            createdEx.InnerException.ShouldBeOfType<MappingException>();
             // ReSharper disable once PossibleNullReferenceException
-            exception.InnerException.InnerException.ShouldNotBeNull();
-            exception.InnerException.InnerException.ShouldBeOfType<InvalidOperationException>();
+            createdEx.InnerException.InnerException.ShouldNotBeNull();
+            createdEx.InnerException.InnerException.ShouldBeOfType<InvalidOperationException>();
             // ReSharper disable once PossibleNullReferenceException
-            exception.InnerException.InnerException.Message.ShouldBe("OH NO");
+            createdEx.InnerException.InnerException.Message.ShouldBe("OH NO");
         }
 
         [Fact]

AgileMapper.UnitTests/Configuration/WhenIgnoringMembersIncorrectly.cs

@@ -149,7 +149,7 @@ public void ShouldErrorIfReadOnlySimpleTypeMemberSpecified()
                 }
             });
 
-            configurationEx.Message.ShouldContain("not writeable");
+            configurationEx.Message.ShouldContain("not mappable");
         }
 
         [Fact]

AgileMapper.UnitTests/Members/WhenFindingTargetMembers.cs

@@ -70,41 +70,49 @@ public void ShouldFindAPublicReadOnlyComplexTypeProperty()
         }
 
         [Fact]
-        public void ShouldIgnoreANonPublicField()
+        public void ShouldFindAPublicReadOnlyArrayField()
         {
             var member = MemberFinder
-                .GetTargetMembers(typeof(InternalField<List<byte>>))
+                .GetTargetMembers(typeof(PublicReadOnlyField<byte[]>))
                 .FirstOrDefault(m => m.Name == "Value");
 
-            member.ShouldBeNull();
+            member.ShouldNotBeNull();
+            member.Type.ShouldBe(typeof(byte[]));
+            member.ElementType.ShouldBe(typeof(byte));
+            member.IsWriteable.ShouldBeFalse();
         }
 
         [Fact]
-        public void ShouldIgnoreAPublicReadOnlyArrayField()
+        public void ShouldFindAPublicReadOnlySimpleTypeProperty()
         {
             var member = MemberFinder
-                .GetTargetMembers(typeof(PublicReadOnlyField<byte[]>))
+                .GetTargetMembers(typeof(PublicReadOnlyProperty<long>))
                 .FirstOrDefault(m => m.Name == "Value");
 
-            member.ShouldBeNull();
+            member.ShouldNotBeNull();
+            member.Type.ShouldBe(typeof(long));
+            member.IsWriteable.ShouldBeFalse();
         }
 
         [Fact]
-        public void ShouldIgnoreAPublicReadOnlySimpleTypeProperty()
+        public void ShouldFindAReadOnlyArrayProperty()
         {
             var member = MemberFinder
-                .GetTargetMembers(typeof(PublicReadOnlyProperty<long>))
-                .FirstOrDefault(m => m.Name == "Value");
+                .GetTargetMembers(typeof(PublicReadOnlyProperty<long[]>))
+                .FirstOrDefault(m => m.Name.StartsWith("Value"));
 
-            member.ShouldBeNull();
+            member.ShouldNotBeNull();
+            member.Type.ShouldBe(typeof(long[]));
+            member.ElementType.ShouldBe(typeof(long));
+            member.IsWriteable.ShouldBeFalse();
         }
 
         [Fact]
-        public void ShouldIgnoreAReadOnlyArrayProperty()
+        public void ShouldIgnoreANonPublicField()
         {
             var member = MemberFinder
-                .GetTargetMembers(typeof(PublicReadOnlyProperty<long[]>))
-                .FirstOrDefault(m => m.Name.StartsWith("Value"));
+                .GetTargetMembers(typeof(InternalField<List<byte>>))
+                .FirstOrDefault(m => m.Name == "Value");
 
             member.ShouldBeNull();
         }

AgileMapper.UnitTests/Reflection/WhenAccessingTypeInformation.cs

@@ -41,11 +41,23 @@ public void ShouldNotEvaluateAStringAsEnumerable()
         #region IsComplex
 
         [Fact]
-        public void ShouldEvaluateAComplexTypeAsComplex()
+        public void ShouldEvaluateAClassAsComplex()
         {
             typeof(Person).IsComplex().ShouldBeTrue();
         }
 
+        [Fact]
+        public void ShouldEvaluateAStructAsComplex()
+        {
+            typeof(PublicCtorStruct<>).IsComplex().ShouldBeTrue();
+        }
+
+        [Fact]
+        public void ShouldEvaluateAnInterfaceAsComplex()
+        {
+            typeof(IPublicInterface<>).IsComplex().ShouldBeTrue();
+        }
+
         [Fact]
         public void ShouldNotEvaluateAnArrayAsComplex()
         {

AgileMapper.UnitTests/Structs/Configuration/WhenConfiguringStructCreationCallbacks.cs

@@ -0,0 +1,112 @@
+namespace AgileObjects.AgileMapper.UnitTests.Structs.Configuration
+{
+    using Shouldly;
+    using TestClasses;
+    using Xunit;
+
+    public class WhenConfiguringStructCreationCallbacks
+    {
+        [Fact]
+        public void ShouldCallAGlobalObjectCreatedCallbackWithAStruct()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                var createdInstance = default(object);
+
+                mapper.After
+                    .CreatingInstances
+                    .Call(ctx => createdInstance = ctx.CreatedObject);
+
+                var source = new PublicField<long> { Value = 123456 };
+                var result = mapper.Map(source).ToANew<PublicCtorStruct<int>>();
+
+                createdInstance.ShouldNotBeNull();
+                createdInstance.ShouldBeOfType<PublicCtorStruct<int>>();
+                result.Value.ShouldBe(123456);
+            }
+        }
+
+        [Fact]
+        public void ShouldCallAnObjectCreatedCallbackForASpecifiedStructType()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                var createdStruct = default(PublicPropertyStruct<int>);
+
+                mapper.After
+                    .CreatingInstancesOf<PublicPropertyStruct<int>>()
+                    .Call((s, t, p) => createdStruct = p);
+
+                var source = new { Value = "12345" };
+                var nonMatchingResult = mapper.Map(source).ToANew<PublicField<int>>();
+
+                createdStruct.ShouldBeDefault();
+                nonMatchingResult.Value.ShouldBe(12345);
+
+                var matchingResult = mapper.Map(source).ToANew<PublicPropertyStruct<int>>();
+
+                createdStruct.ShouldNotBeNull();
+                createdStruct.ShouldBe(matchingResult);
+            }
+        }
+
+        [Fact]
+        public void ShouldCallAnObjectCreatedCallbackForSpecifiedSourceStructType()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                var creationCount = 0;
+
+                mapper.WhenMapping
+                    .From<PublicPropertyStruct<string>>()
+                    .To<Customer>()
+                    .Map(ctx => ctx.Source.Value)
+                    .To(c => c.Name)
+                    .And
+                    .After
+                    .CreatingTargetInstances
+                    .Call(ctx => ++creationCount);
+
+                var nonMatchingSource = new { Name = "Goldblum" };
+                var nonMatchingResult = mapper.Map(nonMatchingSource).ToANew<Customer>();
+
+                creationCount.ShouldBe(0);
+                nonMatchingResult.Name.ShouldBe("Goldblum");
+
+                var matchingSource = new PublicPropertyStruct<string> { Value = "Fishy" };
+                var matchingResult = mapper.Map(matchingSource).ToANew<MysteryCustomer>();
+
+                creationCount.ShouldBe(1);
+                matchingResult.Name.ShouldBe("Fishy");
+            }
+        }
+
+        [Fact]
+        public void ShouldCallAnObjectCreatedCallbackForSpecifiedSourceAndTargetStructTypes()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                var createdStruct = default(PublicCtorStruct<long>);
+
+                mapper.WhenMapping
+                    .From<PublicPropertyStruct<int>>()
+                    .To<PublicCtorStruct<long>>()
+                    .After
+                    .CreatingTargetInstances
+                    .Call(ctx => createdStruct = ctx.CreatedObject);
+
+                var nonMatchingSource = new { Value = "8765" };
+                var nonMatchingResult = mapper.Map(nonMatchingSource).ToANew<PublicCtorStruct<long>>();
+
+                createdStruct.ShouldBeDefault();
+                nonMatchingResult.Value.ShouldBe(8765);
+
+                var matchingSource = new PublicPropertyStruct<int> { Value = 5678 };
+                var matchingResult = mapper.Map(matchingSource).ToANew<PublicCtorStruct<long>>();
+
+                createdStruct.ShouldNotBeNull();
+                createdStruct.ShouldBe(matchingResult);
+            }
+        }
+    }
+}