Add more dictionary to Poco tests

Author: mythz

src/ServiceStack.Text/AutoMappingUtils.cs

@@ -156,6 +156,9 @@ public static object ConvertTo(this object from, Type toType, bool skipConverter
             if (from is IEnumerable<KeyValuePair<string, object>> objDict)
                 return objDict.FromObjectDictionary(toType);
 
+            if (from is IEnumerable<KeyValuePair<string, string>> strDict)
+                return strDict.ToObjectDictionary().FromObjectDictionary(toType);
+
             var to = toType.CreateInstance();
             return to.PopulateWithNonDefaultValues(from);
         }
@@ -950,6 +953,14 @@ public static object TryConvertCollections(Type fromType, Type toType, object fr
                     return ret ?? fromValue;
                 }
             }
+            else if (fromType.IsClass && 
+                 (typeof(IDictionary).IsAssignableFrom(toType) || 
+                  typeof(IEnumerable<KeyValuePair<string,object>>).IsAssignableFrom(toType) || 
+                  typeof(IEnumerable<KeyValuePair<string,string>>).IsAssignableFrom(toType)))
+            {
+                var fromDict = fromValue.ToObjectDictionary();
+                return TryConvertCollections(fromType.GetType(), toType, fromDict);
+            }
 
             var listResult = TranslateListWithElements.TryTranslateCollections(fromType, toType, fromValue);
             return listResult ?? fromValue;

tests/ServiceStack.Text.Tests/AutoMappingTests.cs

@@ -1147,5 +1147,101 @@ public void Can_convert_between_structs_with_explicit_casts()
             d = c.ConvertTo<D>();
             Assert.That(d.Id, Is.EqualTo(c.Id));
         }
+        
+        [Test]
+        public void Can_Convert_from_ObjectDictionary_Containing_Another_Object_Dictionary()
+        {
+            var map = new Dictionary<string, object>
+            {
+                { "name", "Foo" },
+                { "otherNames", new List<object>
+                    {
+                        new Dictionary<string, object> { { "name", "Fu" } },
+                        new Dictionary<string, object> { { "name", "Fuey" } }
+                    }
+                }
+            };
+
+            var fromDict = map.ConvertTo<AutoMappingObjectDictionaryTests.PersonWithIdentities>();
+
+            Assert.That(fromDict.Name, Is.EqualTo("Foo"));
+            Assert.That(fromDict.OtherNames.Count, Is.EqualTo(2));
+            Assert.That(fromDict.OtherNames.First().Name, Is.EqualTo("Fu"));
+            Assert.That(fromDict.OtherNames.Last().Name, Is.EqualTo("Fuey"));
+
+            var toDict = fromDict.ConvertTo<Dictionary<string,object>>();
+            Assert.That(toDict["Name"], Is.EqualTo("Foo"));
+            Assert.That(toDict["OtherNames"], Is.EqualTo(fromDict.OtherNames));
+
+            var toObjDict = fromDict.ConvertTo<ObjectDictionary>();
+            Assert.That(toObjDict["Name"], Is.EqualTo("Foo"));
+            Assert.That(toObjDict["OtherNames"], Is.EqualTo(fromDict.OtherNames));
+        }
+
+        class Person
+        {
+            public int Id { get; set; }
+            public string Name { get; set; }
+
+            protected bool Equals(Person other) => Id == other.Id && string.Equals(Name, other.Name);
+
+            public override bool Equals(object obj)
+            {
+                if (ReferenceEquals(null, obj)) return false;
+                if (ReferenceEquals(this, obj)) return true;
+                return obj.GetType() == this.GetType() && Equals((Person) obj);
+            }
+
+            public override int GetHashCode()
+            {
+                unchecked
+                {
+                    return (Id * 397) ^ (Name != null ? Name.GetHashCode() : 0);
+                }
+            }
+        }
+
+        [Test]
+        public void Can_convert_between_Poco_and_ObjectDictionary()
+        {
+            var person = new Person { Id = 1, Name = "foo" };
+
+            Assert.That(person.ConvertTo<Dictionary<string, object>>(), Is.EqualTo(new Dictionary<string, object> {
+                {"Id", 1},
+                {"Name", "foo"},
+            })); 
+            Assert.That(new Dictionary<string, object> {
+                {"Id", 1},
+                {"Name", "foo"},
+            }.ConvertTo<Person>(), Is.EqualTo(person));
+
+            Assert.That(person.ConvertTo<ObjectDictionary>(), Is.EqualTo(new ObjectDictionary {
+                {"Id", 1},
+                {"Name", "foo"},
+            })); 
+            Assert.That(new ObjectDictionary {
+                {"Id", 1},
+                {"Name", "foo"},
+            }.ConvertTo<Person>(), Is.EqualTo(person));
+
+            Assert.That(person.ConvertTo<Dictionary<string, string>>(), Is.EqualTo(new Dictionary<string, string> {
+                {"Id", "1"},
+                {"Name", "foo"},
+            })); 
+
+            Assert.That(new Dictionary<string, string> {
+                {"Id", "1"},
+                {"Name", "foo"},
+            }.ConvertTo<Person>(), Is.EqualTo(person)); 
+
+            Assert.That(person.ConvertTo<StringDictionary>(), Is.EqualTo(new StringDictionary {
+                {"Id", "1"},
+                {"Name", "foo"},
+            })); 
+            Assert.That(new StringDictionary {
+                {"Id", "1"},
+                {"Name", "foo"},
+            }.ConvertTo<Person>(), Is.EqualTo(person)); 
+        }
     }
 }