ReadOnlyCollection support

AgileMapper.UnitTests/Dictionaries/Configuration/WhenConfiguringSourceDictionaryMapping.cs

@@ -94,7 +94,7 @@ public void ShouldUseACustomMemberNameDictionaryKeyForANestedMember()
         }
 
         [Fact]
-        public void ShouldUseACustomMemberNameDictionaryKeyForANestedEnumerableMember()
+        public void ShouldUseACustomMemberNameDictionaryKeyForANestedArrayMember()
         {
             using (var mapper = Mapper.CreateNew())
             {

AgileMapper.UnitTests/WhenMappingCircularReferences.cs

@@ -2,6 +2,7 @@
 {
     using System;
     using System.Collections.Generic;
+    using System.Collections.ObjectModel;
     using AgileMapper.Extensions;
     using Shouldly;
     using TestClasses;
@@ -260,6 +261,49 @@ public void ShouldMapMultiplyRecursiveRelationships()
             }
         }
 
+        [Fact]
+        public void ShouldMapNestedMultiplyRecursiveRelationships()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                mapper.WhenMapping
+                    .To<PublicField<ReadOnlyCollection<MultipleRecursor>>>()
+                    .TrackMappedObjects();
+
+                var recursorOne = new MultipleRecursor { Name = "One" };
+                var recursorTwo = new MultipleRecursor { Name = "Two" };
+
+                recursorOne.ChildRecursor = recursorTwo;
+                recursorTwo.ChildRecursor = recursorOne;
+
+                var source = new PublicField<MultipleRecursor[]>
+                {
+                    Value = new[] { recursorOne, recursorTwo }
+                };
+
+                var result = mapper.Map(source).ToANew<PublicField<ReadOnlyCollection<MultipleRecursor>>>();
+
+                result.ShouldNotBeNull();
+                result.ShouldNotBeSameAs(source);
+                result.Value.Count.ShouldBe(2);
+
+                var resultOne = result.Value.First();
+                resultOne.ShouldNotBeSameAs(recursorOne);
+                resultOne.Name.ShouldBe("One");
+                resultOne.ChildRecursor.ShouldNotBeNull();
+                resultOne.ChildRecursor.ShouldNotBeSameAs(recursorTwo);
+
+                var resultTwo = result.Value.Second();
+                resultTwo.ShouldNotBeSameAs(recursorTwo);
+                resultTwo.Name.ShouldBe("Two");
+                resultTwo.ChildRecursor.ShouldNotBeNull();
+                resultTwo.ChildRecursor.ShouldNotBeSameAs(recursorOne);
+
+                resultOne.ChildRecursor.ShouldBeSameAs(resultTwo);
+                resultTwo.ChildRecursor.ShouldBeSameAs(resultOne);
+            }
+        }
+
         [Fact]
         public void ShouldGenerateAMappingPlanForLinkRelationships()
         {

AgileMapper.UnitTests/WhenMappingOnToEnumerableMembers.cs

@@ -2,6 +2,7 @@
 {
     using System;
     using System.Collections.Generic;
+    using System.Collections.ObjectModel;
     using System.Linq;
     using Shouldly;
     using TestClasses;
@@ -50,6 +51,26 @@ public void ShouldMergeANullableIntArray()
             result.Value.ShouldBe(1, 2, null, 3);
         }
 
+        [Fact]
+        public void ShouldMergeANullableGuidReadOnlyCollection()
+        {
+            var source = new PublicProperty<ICollection<Guid>>
+            {
+                Value = new List<Guid> { Guid.NewGuid() }
+            };
+
+            var target = new PublicField<ReadOnlyCollection<Guid?>>
+            {
+                Value = new ReadOnlyCollection<Guid?>(new[] { Guid.Empty, default(Guid?), Guid.NewGuid() })
+            };
+
+            var originalCollection = target.Value;
+            var result = Mapper.Map(source).OnTo(target);
+
+            result.Value.ShouldNotBeSameAs(originalCollection);
+            result.Value.ShouldBe(target.Value.First(), default(Guid?), target.Value.Third(), source.Value.First());
+        }
+
         [Fact]
         public void ShouldMergeAComplexTypeCollection()
         {
@@ -98,6 +119,34 @@ public void ShouldMergeAnIdentifiableComplexTypeList()
             result.Value.ShouldBe(r => r.ProductId, "Magic", "Science");
         }
 
+        [Fact]
+        public void ShouldMergeAnIdentifiableComplexTypeReadOnlyCollection()
+        {
+            var source = new PublicProperty<Product[]>
+            {
+                Value = new[]
+                {
+                    new Product { ProductId = "Science", Price = 1000.00 }
+                }
+            };
+
+            var target = new PublicField<ReadOnlyCollection<Product>>
+            {
+                Value = new ReadOnlyCollection<Product>(new List<Product>
+                {
+                    new Product { ProductId = "Science" },
+                    new Product { ProductId = "Magic", Price = 1.00 }
+                })
+            };
+
+            var existingProduct = target.Value.First();
+            var result = Mapper.Map(source).OnTo(target);
+
+            result.Value.First().ShouldBeSameAs(existingProduct);
+            result.Value.First().Price.ShouldBe(1000.00);
+            result.Value.ShouldBe(r => r.ProductId, "Science", "Magic");
+        }
+
         [Fact]
         public void ShouldHandleANullSourceMember()
         {

AgileMapper.UnitTests/WhenMappingOnToEnumerables.cs

@@ -2,6 +2,7 @@
 {
     using System;
     using System.Collections.Generic;
+    using System.Collections.ObjectModel;
     using System.Linq;
     using Shouldly;
     using TestClasses;
@@ -17,8 +18,18 @@ public void ShouldMergeARootSimpleTypeArray()
             var result = Mapper.Map(source).OnTo(target);
 
             result.ShouldNotBeNull();
-            result.ShouldNotBeSameAs(source);
-            result.SequenceEqual(target.Concat(source)).ShouldBeTrue();
+            result.ShouldBe(1, 2, 3, 4, 5, 6);
+        }
+
+        [Fact]
+        public void ShouldMergeARootSimpleTypeReadOnlyCollection()
+        {
+            var source = new[] { 2, 3, 4 };
+            var target = new ReadOnlyCollection<string>(new[] { "1", "2" });
+            var result = Mapper.Map(source).OnTo(target);
+
+            result.ShouldNotBeNull();
+            result.ShouldBe("1", "2", "3", "4");
         }
 
         [Fact]
@@ -84,6 +95,24 @@ public void ShouldMergeARootComplexTypeList()
             result.ShouldBe(p => p.Name, "Kate", "Pete");
         }
 
+        [Fact]
+        public void ShouldMergeARootComplexTypeReadOnlyCollection()
+        {
+            var source = new[]
+            {
+                new Product { ProductId = "Pete" }
+            };
+
+            var target = new ReadOnlyCollection<Product>(new[]
+            {
+                new Product { ProductId = "Kate" }
+            });
+
+            var result = Mapper.Map(source).OnTo(target);
+
+            result.ShouldBe(p => p.ProductId, "Kate", "Pete");
+        }
+
         [Fact]
         public void ShouldUpdateAnExistingObject()
         {

AgileMapper.UnitTests/WhenMappingOverEnumerableMembers.cs

@@ -51,6 +51,24 @@ public void ShouldOverwriteAnArray()
             result.Value.ShouldBe(MinusOne, Zero);
         }
 
+        [Fact]
+        public void ShouldOverwriteAReadOnlyCollection()
+        {
+            var source = new PublicProperty<IEnumerable<decimal>>
+            {
+                Value = new[] { MinValue, MaxValue }
+            };
+
+            var target = new PublicField<ReadOnlyCollection<decimal>>
+            {
+                Value = new ReadOnlyCollection<decimal>(new[] { MinusOne, Zero })
+            };
+
+            var result = Mapper.Map(source).Over(target);
+
+            result.Value.ShouldBe(MinValue, MaxValue);
+        }
+
         [Fact]
         public void ShouldOverwriteAComplexTypeCollection()
         {
@@ -138,5 +156,18 @@ public void ShouldOverwriteANonNullReadOnlyNestedCollection()
             result.Value.ShouldBeSameAs(strings);
             result.Value.ShouldBe("One!", "Two!", "Three");
         }
+
+        [Fact]
+        public void ShouldHandleAReadOnlyNestedReadOnlyCollection()
+        {
+            var source = new PublicField<string[]> { Value = new[] { "One!", "Two!" } };
+            var strings = new List<string> { "A", "B", "C" }.AsReadOnly();
+            var target = new PublicReadOnlyField<ReadOnlyCollection<string>>(strings);
+            var result = Mapper.Map(source).Over(target);
+
+            result.Value.ShouldNotBeNull();
+            result.Value.ShouldBeSameAs(strings);
+            result.Value.ShouldBe("A", "B", "C");
+        }
     }
 }

AgileMapper.UnitTests/WhenMappingOverEnumerables.cs

@@ -22,6 +22,17 @@ public void ShouldOverwriteARootSimpleTypeArray()
             result.ShouldBe(5, 4, 3, 2);
         }
 
+        [Fact]
+        public void ShouldOverwriteARootSimpleTypeReadOnlyCollection()
+        {
+            var source = new[] { '2', '3' };
+            var target = new ReadOnlyCollection<char>(new List<char> { '5', '4' });
+            var result = Mapper.Map(source).Over(target);
+
+            result.ShouldNotBeNull();
+            result.ShouldBe('2', '3');
+        }
+
         [Fact]
         public void ShouldOverwriteARootSimpleTypeList()
         {
@@ -91,7 +102,7 @@ public void ShouldOverwriteARootComplexTypeCollectionElementByRuntimeType()
         }
 
         [Fact]
-        public void ShouldOverwriteAnExistingObject()
+        public void ShouldOverwriteAnExistingObjectById()
         {
             var source = new[]
             {
@@ -112,6 +123,28 @@ public void ShouldOverwriteAnExistingObject()
             result.ShouldBe(p => p.Name, "Lisa", "Bart");
         }
 
+        [Fact]
+        public void ShouldOverwriteAnExistingObjectByIdInAReadOnlyCollection()
+        {
+            var source = new[]
+            {
+                new CustomerViewModel { Id = Guid.NewGuid(), Name = "Homer" }
+            };
+
+            var target = new ReadOnlyCollection<CustomerViewModel>(new List<CustomerViewModel>
+            {
+                new CustomerViewModel { Id = source.First().Id, Name = "Maggie" }
+            });
+
+            var originalObject = target.First();
+            var result = Mapper.Map(source).Over(target);
+
+            result.ShouldNotBeSameAs(target);
+            result.ShouldHaveSingleItem();
+            result.First().ShouldBeSameAs(originalObject);
+            result.First().Name.ShouldBe("Homer");
+        }
+
         [Fact]
         public void ShouldOverwriteUsingAConfiguredDataSource()
         {

AgileMapper.UnitTests/WhenMappingToNewEnumerableMembers.cs

@@ -58,6 +58,49 @@ public void ShouldCreateANewObjectCollection()
             result.Value.Third().ShouldBe(string.Empty);
         }
 
+        [Fact]
+        public void ShouldCreateANewObjectReadOnlyCollection()
+        {
+            var source = new PublicField<object[]>
+            {
+                Value = new object[] { 9, new CustomerViewModel { Name = "Boycee" }, default(string) }
+            };
+            var result = Mapper.Map(source).ToANew<PublicProperty<ReadOnlyCollection<object>>>();
+
+            result.Value.ShouldNotBeNull();
+            result.Value.First().ShouldBe(9);
+            result.Value.Second().ShouldBeOfType<CustomerViewModel>();
+            ((CustomerViewModel)result.Value.Second()).Name.ShouldBe("Boycee");
+            result.Value.Third().ShouldBeNull();
+        }
+
+        [Fact]
+        public void ShouldMapFromAReadOnlyCollection()
+        {
+            var source = new PublicField<ReadOnlyCollection<string>>
+            {
+                Value = new ReadOnlyCollection<string>(new[] { "R", "A", "T", "M" })
+            };
+            var result = Mapper.Map(source).ToANew<PublicProperty<object[]>>();
+
+            result.Value.ShouldNotBeNull();
+            result.Value.ShouldBe("R", "A", "T", "M");
+        }
+
+        [Fact]
+        public void ShouldMapFromAnEmptyReadOnlyCollection()
+        {
+            var source = new PublicField<ReadOnlyCollection<string>>
+            {
+                Value = new ReadOnlyCollection<string>(Enumerable<string>.EmptyArray)
+            };
+            var result = Mapper.Map(source).ToANew<PublicProperty<ReadOnlyCollection<string>>>();
+
+            result.Value.ShouldNotBeNull();
+            result.Value.ShouldNotBeSameAs(source.Value);
+            result.Value.ShouldBeEmpty();
+        }
+
         [Fact]
         public void ShouldCreateANewComplexTypeEnumerable()
         {
@@ -192,7 +235,7 @@ public void ShouldRetainAnExistingCollection()
         }
 
         [Fact]
-        public void ShouldApplyAConfiguredExpressionToAnEnumerable()
+        public void ShouldApplyAConfiguredExpressionToAnArray()
         {
             using (var mapper = Mapper.CreateNew())
             {
@@ -289,6 +332,42 @@ public void ShouldHandleANonNullReadOnlyNestedReadOnlyICollection()
             }
         }
 
+        [Fact]
+        public void ShouldHandleANonNullReadOnlyNestedArray()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                var readOnlyStrings = new[] { "1", "2" };
+
+                mapper.CreateAReadOnlyFieldUsing(readOnlyStrings);
+
+                var source = new PublicField<string[]> { Value = new[] { "3" } };
+                var result = mapper.Map(source).ToANew<PublicReadOnlyField<string[]>>();
+
+                result.Value.ShouldNotBeNull();
+                result.Value.ShouldBeSameAs(readOnlyStrings);
+                result.Value.ShouldBe("1", "2");
+            }
+        }
+
+        [Fact]
+        public void ShouldHandleANonNullReadOnlyNestedReadOnlyCollection()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                var readOnlyInts = new ReadOnlyCollection<int>(new[] { 5, 5, 5 });
+
+                mapper.CreateAReadOnlyPropertyUsing(readOnlyInts);
+
+                var source = new PublicField<string[]> { Value = new[] { "3" } };
+                var result = mapper.Map(source).ToANew<PublicReadOnlyProperty<ReadOnlyCollection<int>>>();
+
+                result.Value.ShouldNotBeNull();
+                result.Value.ShouldBeSameAs(readOnlyInts);
+                result.Value.ShouldBe(5, 5, 5);
+            }
+        }
+
         [Fact]
         public void ShouldPopulateANonNullReadOnlyNestedEnumerable()
         {