Nested Properties

app/Simpler.Tests/Core/Mocks/MockPerson.cs

@@ -4,6 +4,9 @@ public class MockPerson
     {
         public string Name { get; set; }
         public int? Age { get; set; }
+        public MockPet Pet { get; set; }
+        public MockVehicle[] Vehicles { get; set; }
         public MockEnum MockEnum { get; set; }
+        public dynamic Other { get; set; }
     }
 }

app/Simpler.Tests/Core/Mocks/MockPet.cs

@@ -0,0 +1,8 @@
+namespace Simpler.Tests.Core.Mocks
+{
+    public class MockPet
+    {
+        public string Name { get; set; }
+        public int? Age { get; set; }
+    }
+}

app/Simpler.Tests/Core/Mocks/MockVehicle.cs

@@ -0,0 +1,8 @@
+namespace Simpler.Tests.Core.Mocks
+{
+    public class MockVehicle
+    {
+        public string Make { get; set; }
+        public string Model { get; set; }
+    }
+}

app/Simpler.Tests/Data/PropertyMappingTree/ArrayElementNodeTest.cs

@@ -0,0 +1,63 @@
+using NUnit.Framework;
+using Simpler.Data.PropertyMappingTree;
+using Simpler.Tests.Core.Mocks;
+
+namespace Simpler.Tests.Data.PropertyMappingTree
+{
+    [TestFixture]
+    public class ArrayElementNodeTest
+    {
+        [Test]
+        public void should_set_value_for_array_child_node()
+        {
+            //arrange
+            var array = new MockPet[1];
+            var propertyParseTreeArrayChildNode = new ArrayElementNode
+                {
+                    Name = "0",
+                    PropertyType = typeof (MockPet)
+                };
+
+            // Act
+            propertyParseTreeArrayChildNode.SetValue(array, null);
+
+            // Assert
+            Assert.That(array[0], Is.Not.Null);
+        }
+
+        [Test]
+        public void should_get_value_for_array_child_node()
+        {
+            //arrange
+            var array = new [] { new MockPet {Name = "Doug"} };
+            var propertyParseTreeArrayChildNode = new ArrayElementNode
+                {
+                    Name = "0",
+                    PropertyType = typeof (MockPet)
+                };
+
+            // Act
+            var value = (MockPet)propertyParseTreeArrayChildNode.GetValue(array);
+
+            // Assert
+            Assert.That(value, Is.Not.Null);
+            Assert.That(value.Name, Is.EqualTo("Doug"));
+        }
+
+        [Test]
+        public void should_create_object_for_array_child_node()
+        {
+            //arrange
+            var propertyParseTreeArrayChildNode = new ArrayElementNode
+                {
+                    PropertyType = typeof (MockPet)
+                };
+
+            // Act
+            var value = propertyParseTreeArrayChildNode.CreateObject(null);
+
+            // Assert
+            Assert.That(value, Is.TypeOf(typeof(MockPet)));
+        }
+    }
+}

app/Simpler.Tests/Data/PropertyMappingTree/ArrayNodeTest.cs

@@ -0,0 +1,66 @@
+using NUnit.Framework;
+using Simpler.Data.PropertyMappingTree;
+using Simpler.Tests.Core.Mocks;
+
+namespace Simpler.Tests.Data.PropertyParseTree
+{
+    [TestFixture]
+    public class ArrayNodeTest
+    {
+        [Test]
+        public void should_set_value_for_array_node()
+        {
+            //arrange
+            var obj = new MockPerson();
+            var propertyParseTreeArrayNode = new ArrayNode
+                {
+                    Name = "Vehicles",
+                    PropertyInfo = obj.GetType().GetProperty("Vehicles"),
+                    PropertyType = typeof (MockVehicle[])
+                };
+
+            // Act
+            propertyParseTreeArrayNode.SetValue(obj, null);
+
+            // Assert
+            Assert.That(obj.Vehicles, Is.Not.Null);
+        }
+
+        [Test]
+        public void should_get_value_for_array()
+        {
+            //arrange
+            var obj = new MockPerson {Vehicles = new MockVehicle[0]};
+            var propertyParseTreeArrayNode = new ArrayNode
+                {
+                    Name = "Vehicles",
+                    PropertyInfo = obj.GetType().GetProperty("Vehicles"),
+                    PropertyType = typeof (MockVehicle[])
+                };
+
+            // Act
+            var value = propertyParseTreeArrayNode.GetValue(obj);
+
+            // Assert
+            Assert.That(value, Is.Not.Null);
+            Assert.That(value, Is.EqualTo(obj.Vehicles));
+        }
+
+        [Test]
+        public void should_create_object_for_array()
+        {
+            //arrange
+            var propertyParseTreeArrayNode = new ArrayNode
+                {
+                    PropertyType = typeof (MockVehicle[])
+                };
+
+            // Act
+            var value = propertyParseTreeArrayNode.CreateObject(null);
+
+            // Assert
+            Assert.That(value, Is.Not.Null);
+            Assert.That(value, Is.TypeOf(typeof(MockVehicle[])));
+        }
+    }
+}

app/Simpler.Tests/Data/PropertyMappingTree/DynamicNodeTest.cs

@@ -0,0 +1,68 @@
+using System.Dynamic;
+using NUnit.Framework;
+using Simpler.Data.PropertyMappingTree;
+using Simpler.Tests.Core.Mocks;
+
+namespace Simpler.Tests.Data.PropertyParseTree
+{
+    [TestFixture]
+    public class DynamicNodeTest
+    {
+        [Test]
+        public void should_set_value_for_dynamic_node()
+        {
+            //arrange
+            var obj = new MockPerson();
+            var propertyParseTreeArrayNode = new DynamicNode()
+                {
+                    Name = "Other",
+                    PropertyInfo = obj.GetType().GetProperty("Other"),
+                    PropertyType = typeof (object)
+                };
+
+            // Act
+            propertyParseTreeArrayNode.SetValue(obj, null);
+
+            // Assert
+            Assert.That(obj.Other, Is.Not.Null);
+        }
+
+        [Test]
+        public void should_get_value_for_dynamic_node()
+        {
+            //arrange
+            var obj = new MockPerson{Other = new ExpandoObject()};
+            var propertyParseTreeArrayNode = new DynamicNode()
+            {
+                Name = "Other",
+                PropertyInfo = obj.GetType().GetProperty("Other"),
+                PropertyType = typeof(object)
+            };
+
+            // Act
+            var value = propertyParseTreeArrayNode.GetValue(obj);
+
+            // Assert
+            Assert.That(value, Is.Not.Null);
+            Assert.That(value, Is.EqualTo(obj.Other));
+        }
+
+        [Test]
+        public void should_create_object_for_dynamic_node()
+        {
+            //arrange
+            var propertyParseTreeArrayNode = new DynamicNode()
+            {
+                Name = "Other",
+                PropertyType = typeof(object)
+            };
+
+            // Act
+            var value = propertyParseTreeArrayNode.CreateObject();
+
+            // Assert
+            Assert.That(value, Is.Not.Null);
+            Assert.That(value, Is.TypeOf(typeof(ExpandoObject)));
+        }
+    }
+}

app/Simpler.Tests/Data/PropertyMappingTree/DynamicPropertyNodeTest.cs

@@ -0,0 +1,65 @@
+using System.Dynamic;
+using NUnit.Framework;
+using Simpler.Data.PropertyMappingTree;
+
+namespace Simpler.Tests.Data.PropertyParseTree
+{
+    [TestFixture]
+    public class DynamicPropertyNodeTest
+    {
+        [Test]
+        public void should_set_value_for_dynamic_node()
+        {
+            //arrange
+            dynamic obj = new ExpandoObject();
+            var propertyParseTreeArrayNode = new DynamicPropertyNode()
+                {
+                    Name = "City",
+                    PropertyType = typeof (string)
+                };
+
+            // Act
+            propertyParseTreeArrayNode.SetValue(obj, "Anchorage");
+
+            // Assert
+            Assert.That(obj.City, Is.EqualTo("Anchorage"));
+        }
+
+        [Test]
+        public void should_get_value_for_dynamic_node()
+        {
+            //arrange
+            dynamic obj = new ExpandoObject();
+            obj.City = "Anchorage";
+            var propertyParseTreeArrayNode = new DynamicPropertyNode()
+            {
+                Name = "City",
+                PropertyType = typeof(string)
+            };
+
+            // Act
+            var value = propertyParseTreeArrayNode.GetValue(obj);
+
+            // Assert
+            Assert.That(value, Is.Not.Null);
+            Assert.That(value, Is.EqualTo(obj.City));
+        }
+
+        [Test]
+        public void should_create_object_for_dynamic_node()
+        {
+            //arrange
+            var propertyParseTreeArrayNode = new DynamicPropertyNode()
+            {
+                Name = "City",
+                PropertyType = typeof(string)
+            };
+
+            // Act
+            var value = propertyParseTreeArrayNode.CreateObject("Anchorage");
+
+            // Assert
+            Assert.That(value, Is.EqualTo("Anchorage"));
+        }
+    }
+}

app/Simpler.Tests/Data/PropertyMappingTree/ObjectNodeTest.cs

@@ -0,0 +1,65 @@
+using NUnit.Framework;
+using Simpler.Data.PropertyMappingTree;
+using Simpler.Tests.Core.Mocks;
+
+namespace Simpler.Tests.Data.PropertyParseTree
+{
+    [TestFixture]
+    public class ObjectNodeTest
+    {
+        [Test]
+        public void should_set_value_for_object_node()
+        {
+            //arrange
+            var obj = new MockPerson();
+            var propertyParseTreeObjectNode = new ObjectNode()
+                {
+                    Name = "Name",
+                    PropertyInfo = obj.GetType().GetProperty("Name"),
+                    PropertyType = typeof(string)
+                };
+
+            // Act
+            propertyParseTreeObjectNode.SetValue(obj, "Richard");
+
+            // Assert
+            Assert.That(obj.Name, Is.EqualTo("Richard"));
+        }
+
+        [Test]
+        public void should_get_value_for_object_node()
+        {
+            //arrange
+            var obj = new MockPerson{ Name = "Richard" };
+            var propertyParseTreeObjectNode = new ObjectNode()
+                {
+                    Name = "Name",
+                    PropertyInfo = obj.GetType().GetProperty("Name"),
+                    PropertyType = typeof(string)
+                };
+
+            // Act
+            var value = propertyParseTreeObjectNode.GetValue(obj);
+
+            // Assert
+            Assert.That(value, Is.EqualTo("Richard"));
+        }
+
+        [Test]
+        public void should_create_object_for_object_node()
+        {
+            //arrange
+            var propertyParseTreeObjectNode = new ObjectNode()
+            {
+                Name = "Name",
+                PropertyType = typeof(string)
+            };
+
+            // Act
+            var value = propertyParseTreeObjectNode.CreateObject("Richard");
+
+            // Assert
+            Assert.That(value, Is.EqualTo("Richard"));
+        }
+    }
+}