Dot net standard

DataAnnotationsValidatorRecursive/DataAnnotationsValidator.Tests/Child.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+
+namespace DataAnnotationsValidator.Tests
+{
+    public class Child : IValidatableObject
+    {
+        [Required(ErrorMessage = "Child Parent is required")]
+        public Parent Parent { get; set; }
+
+        [Required(ErrorMessage = "Child PropertyA is required")]
+        [Range(0, 10, ErrorMessage = "Child PropertyA not within range")]
+        public int? PropertyA { get; set; }
+
+        [Required(ErrorMessage = "Child PropertyB is required")]
+        [Range(0, 10, ErrorMessage = "Child PropertyB not within range")]
+        public int? PropertyB { get; set; }
+
+        public IEnumerable<GrandChild> GrandChildren { get; set; }
+
+        [SaveValidationContext]
+        public bool HasNoRealValidation { get; set; }
+
+        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+        {
+            if (PropertyA.HasValue && PropertyB.HasValue && (PropertyA + PropertyB > 10))
+                yield return new ValidationResult("Child PropertyA and PropertyB cannot add up to more than 10");
+        }
+    }
+}

DataAnnotationsValidatorRecursive/DataAnnotationsValidator.Tests/ClassWithDictionary.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace DataAnnotationsValidator.Tests
+{
+    public class ClassWithDictionary
+    {
+        public List<Dictionary<string, Child>> Objects { get; set; }
+    }
+}

DataAnnotationsValidatorRecursive/DataAnnotationsValidator.Tests/ClassWithNullableEnumeration.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace DataAnnotationsValidator.Tests
+{
+    public class ClassWithNullableEnumeration
+    {
+        public List<Child> Objects { get; set; }
+    }
+}

DataAnnotationsValidatorRecursive/DataAnnotationsValidator.Tests/DataAnnotationsValidator.Tests.csproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="NUnit" Version="3.10.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.15.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\DataAnnotationsValidator\DataAnnotationsValidator.csproj" />
+  </ItemGroup>
+
+</Project>

DataAnnotationsValidatorRecursive/DataAnnotationsValidator.Tests/DataAnnotationsValidatorTests.cs

@@ -0,0 +1,247 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using NUnit.Framework;
+
+namespace DataAnnotationsValidator.Tests
+{
+    [TestFixture]
+    public class DataAnnotationsValidatorTests
+    {
+        private IDataAnnotationsValidator _validator;
+
+        [SetUp]
+        public void Setup()
+        {
+            SaveValidationContextAttribute.SavedContexts.Clear();
+            _validator = new DataAnnotationsValidator();
+        }
+
+        [Test]
+        public void TryValidateObject_on_valid_parent_returns_no_errors()
+        {
+            var parent = new Parent { PropertyA = 1, PropertyB = 1 };
+            var validationResults = new List<ValidationResult>();
+
+            var result = _validator.TryValidateObject(parent, validationResults);
+
+            Assert.IsTrue(result);
+            Assert.AreEqual(0, validationResults.Count);
+        }
+
+        [Test]
+        public void TryValidateObject_when_missing_required_properties_returns_errors()
+        {
+            var parent = new Parent { PropertyA = null, PropertyB = null };
+            var validationResults = new List<ValidationResult>();
+
+            var result = _validator.TryValidateObject(parent, validationResults);
+
+            Assert.IsFalse(result);
+            Assert.AreEqual(2, validationResults.Count);
+            Assert.AreEqual(1, validationResults.Count(x => x.ErrorMessage == "Parent PropertyA is required"));
+            Assert.AreEqual(1, validationResults.Count(x => x.ErrorMessage == "Parent PropertyB is required"));
+        }
+
+        [Test]
+        public void TryValidateObject_calls_IValidatableObject_method()
+        {
+            var parent = new Parent { PropertyA = 5, PropertyB = 6 };
+            var validationResults = new List<ValidationResult>();
+
+            var result = _validator.TryValidateObject(parent, validationResults);
+
+            Assert.IsFalse(result);
+            Assert.AreEqual(1, validationResults.Count);
+            Assert.AreEqual("Parent PropertyA and PropertyB cannot add up to more than 10", validationResults[0].ErrorMessage);
+        }
+
+        [Test]
+        public void TryValidateObjectRecursive_returns_errors_when_child_class_has_invalid_properties()
+        {
+            var parent = new Parent { PropertyA = 1, PropertyB = 1 };
+            parent.Child = new Child { Parent = parent, PropertyA = null, PropertyB = 5 };
+            var validationResults = new List<ValidationResult>();
+
+            var result = _validator.TryValidateObjectRecursive(parent, validationResults);
+
+            Assert.IsFalse(result);
+            Assert.AreEqual(1, validationResults.Count);
+            Assert.AreEqual("Child PropertyA is required", validationResults[0].ErrorMessage);
+        }
+
+        [Test]
+        public void TryValidateObjectRecursive_ignored_errors_when_child_class_has_SkipRecursiveValidationProperty()
+        {
+            var parent = new Parent { PropertyA = 1, PropertyB = 1 };
+            parent.Child = new Child { Parent = parent, PropertyA = 1, PropertyB = 1 };
+            parent.SkippedChild = new Child { PropertyA = null, PropertyB = 1 };
+            var validationResults = new List<ValidationResult>();
+
+            var result = _validator.TryValidateObjectRecursive(parent, validationResults);
+
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void TryValidateObjectRecursive_calls_IValidatableObject_method_on_child_class()
+        {
+            var parent = new Parent { PropertyA = 1, PropertyB = 1 };
+            parent.Child = new Child { Parent = parent, PropertyA = 5, PropertyB = 6 };
+            var validationResults = new List<ValidationResult>();
+
+            var result = _validator.TryValidateObjectRecursive(parent, validationResults);
+
+            Assert.IsFalse(result);
+            Assert.AreEqual(1, validationResults.Count);
+            Assert.AreEqual("Child PropertyA and PropertyB cannot add up to more than 10", validationResults[0].ErrorMessage);
+        }
+
+        [Test]
+        public void TryValidateObjectRecursive_returns_errors_when_grandchild_class_has_invalid_properties()
+        {
+            var parent = new Parent { PropertyA = 1, PropertyB = 1 };
+            parent.Child = new Child
+            {
+                Parent = parent,
+                PropertyA = 1,
+                PropertyB = 1,
+                GrandChildren = new[] {new GrandChild {PropertyA = 11, PropertyB = 11}}
+            };
+            var validationResults = new List<ValidationResult>();
+
+            var result = _validator.TryValidateObjectRecursive(parent, validationResults);
+
+            Assert.IsFalse(result);
+            Assert.AreEqual(2, validationResults.Count);
+            Assert.AreEqual(1, validationResults.Count(x => x.ErrorMessage == "GrandChild PropertyA not within range"));
+            Assert.AreEqual(1, validationResults.Count(x => x.ErrorMessage == "GrandChild PropertyB not within range"));
+        }
+
+        [Test]
+        public void TryValidateObjectRecursive_passes_validation_context_items_to_all_validation_calls()
+        {
+            var parent = new Parent {Child = new Child {GrandChildren = new[] {new GrandChild()}}};
+            var validationResults = new List<ValidationResult>();
+
+            var contextItems = new Dictionary<object, object> { { "key", 12345 } };
+
+            _validator.TryValidateObjectRecursive(parent, validationResults, contextItems);
+
+            Assert.AreEqual(3, SaveValidationContextAttribute.SavedContexts.Count, "Test expects 3 validated properties in the object graph to have a SaveValidationContextAttribute");
+            Assert.That(SaveValidationContextAttribute.SavedContexts.Select(c => c.Items).All(items => items["key"] == contextItems["key"]));
+        }
+
+        [Test]
+        public void TryValidateObject_calls_grandchild_IValidatableObject_method()
+        {
+            var parent = new Parent { PropertyA = 1, PropertyB = 1 };
+            parent.Child = new Child
+            {
+                Parent = parent,
+                PropertyA = 1,
+                PropertyB = 1,
+                GrandChildren = new[] {new GrandChild {PropertyA = 5, PropertyB = 6}}
+            };
+            var validationResults = new List<ValidationResult>();
+
+            var result = _validator.TryValidateObjectRecursive(parent, validationResults);
+
+            Assert.IsFalse(result);
+            Assert.AreEqual(1, validationResults.Count);
+            Assert.AreEqual(1, validationResults.Count(x => x.ErrorMessage == "GrandChild PropertyA and PropertyB cannot add up to more than 10"));
+        }
+
+        [Test]
+        public void TryValidateObject_includes_errors_from_all_objects()
+        {
+            var parent = new Parent { PropertyA = 5, PropertyB = 6 };
+            parent.Child = new Child
+            {
+                Parent = parent,
+                PropertyA = 5,
+                PropertyB = 6,
+                GrandChildren = new[] {new GrandChild {PropertyA = 5, PropertyB = 6}}
+            };
+            var validationResults = new List<ValidationResult>();
+
+            var result = _validator.TryValidateObjectRecursive(parent, validationResults);
+
+            Assert.IsFalse(result);
+            Assert.AreEqual(3, validationResults.Count);
+            Assert.AreEqual(1, validationResults.Count(x => x.ErrorMessage == "Parent PropertyA and PropertyB cannot add up to more than 10"));
+            Assert.AreEqual(1, validationResults.Count(x => x.ErrorMessage == "Child PropertyA and PropertyB cannot add up to more than 10"));
+            Assert.AreEqual(1, validationResults.Count(x => x.ErrorMessage == "GrandChild PropertyA and PropertyB cannot add up to more than 10"));
+        }
+
+        [Test]
+        public void TryValidateObject_modifies_membernames_for_nested_properties()
+        {
+            var parent = new Parent { PropertyA = 1, PropertyB = 1 };
+            parent.Child = new Child { Parent = parent, PropertyA = null, PropertyB = 5 };
+            var validationResults = new List<ValidationResult>();
+
+            var result = _validator.TryValidateObjectRecursive(parent, validationResults);
+
+            Assert.IsFalse(result);
+            Assert.AreEqual(1, validationResults.Count);
+            Assert.AreEqual("Child PropertyA is required", validationResults[0].ErrorMessage);
+            Assert.AreEqual("Child.PropertyA", validationResults[0].MemberNames.First());
+        }
+
+        [Test]
+        public void TryValidateObject_object_with_dictionary_does_not_fail()
+        {
+            var parent = new Parent { PropertyA = 1, PropertyB = 1 };
+            var classWithDictionary = new ClassWithDictionary
+            {
+                Objects = new List<Dictionary<string, Child>>
+                {
+                    new Dictionary<string, Child>
+                    {
+                        { "key",
+                            new Child
+                            {
+                                Parent = parent,
+                                PropertyA = 1,
+                                PropertyB = 2
+                            }
+                        }
+                    }
+                }
+            };
+            var validationResults = new List<ValidationResult>();
+
+            var result = _validator.TryValidateObjectRecursive(classWithDictionary, validationResults);
+
+            Assert.IsTrue(result);
+            Assert.IsEmpty(validationResults);
+        }
+
+        [Test]
+        public void TryValidateObject_object_with_null_enumeration_values_does_not_fail()
+        {
+            var parent = new Parent { PropertyA = 1, PropertyB = 1 };
+            var classWithNullableEnumeration = new ClassWithNullableEnumeration
+            {
+                Objects = new List<Child>
+                {
+                    null,
+                    new Child
+                    {
+                        Parent = parent,
+                        PropertyA = 1,
+                        PropertyB = 2
+                    }
+                }
+            };
+            var validationResults = new List<ValidationResult>();
+
+            var result = _validator.TryValidateObjectRecursive(classWithNullableEnumeration, validationResults);
+
+            Assert.IsTrue(result);
+            Assert.IsEmpty(validationResults);
+        }
+
+    }
+}

DataAnnotationsValidatorRecursive/DataAnnotationsValidator.Tests/GrandChild.cs

@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+
+namespace DataAnnotationsValidator.Tests
+{
+    public class GrandChild : IValidatableObject
+    {
+        [Required]
+        [Range(0, 10, ErrorMessage = "GrandChild PropertyA not within range")]
+        public int? PropertyA { get; set; }
+
+        [Required]
+        [Range(0, 10, ErrorMessage = "GrandChild PropertyB not within range")]
+        public int? PropertyB { get; set; }
+
+        [SaveValidationContext]
+        public bool HasNoRealValidation { get; set; }
+
+        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+        {
+            if (PropertyA.HasValue && PropertyB.HasValue && (PropertyA + PropertyB > 10))
+                yield return new ValidationResult("GrandChild PropertyA and PropertyB cannot add up to more than 10");
+        }
+    }
+}

DataAnnotationsValidatorRecursive/DataAnnotationsValidator.Tests/Parent.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+
+namespace DataAnnotationsValidator.Tests
+{
+    public class Parent : IValidatableObject
+    {
+        [Required(ErrorMessage = "Parent PropertyA is required")]
+        [Range(0, 10, ErrorMessage = "Parent PropertyA not within range")]
+        public int? PropertyA { get; set; }
+
+        [Required(ErrorMessage = "Parent PropertyB is required")]
+        [Range(0, 10, ErrorMessage = "Parent PropertyB not within range")]
+        public int? PropertyB { get; set; }
+
+        public Child Child { get; set; }
+
+        [SkipRecursiveValidation]
+        public Child SkippedChild { get; set; }
+
+        [SaveValidationContext]
+        public bool HasNoRealValidation { get; set; }
+
+        IEnumerable<ValidationResult> IValidatableObject.Validate(ValidationContext validationContext)
+        {
+            if (PropertyA.HasValue && PropertyB.HasValue && (PropertyA + PropertyB > 10))
+                yield return new ValidationResult("Parent PropertyA and PropertyB cannot add up to more than 10");
+        }
+    }
+}

DataAnnotationsValidatorRecursive/DataAnnotationsValidator.Tests/SaveValidationContextAttribute.cs

@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+
+namespace DataAnnotationsValidator.Tests
+{
+    public class SaveValidationContextAttribute: ValidationAttribute
+    {
+        public static IList<ValidationContext> SavedContexts = new List<ValidationContext>();
+
+        protected override ValidationResult IsValid(object value, ValidationContext validationContext)
+        {
+            SavedContexts.Add(validationContext);
+            return ValidationResult.Success;
+        }
+    }
+}