Add async version of TryValidateObjectRecursive method and tests

src/RecursiveDataAnnotationsValidation/IAsyncRecursiveDataAnnotationValidator.cs

@@ -0,0 +1,33 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Threading.Tasks;
+
+namespace RecursiveDataAnnotationsValidation
+{
+    /// <summary>Async interface for the RecursiveDataAnnotationValidator. Useful if you need
+    /// to swap in a different approach, or to mock the methods.</summary>
+    public interface IAsyncRecursiveDataAnnotationValidator
+    {
+        /// <summary>Runs async validation on an object.</summary>
+        /// <param name="obj">The object being validated.</param>
+        /// <param name="validationContext">Validation context.</param>
+        /// <param name="validationResults">A collection that will be populated if validation errors occur.</param>
+        /// <returns>Returns true if all validation passes.</returns>
+        Task<bool> TryValidateObjectRecursiveAsync(
+            object obj,
+            ValidationContext validationContext,
+            List<ValidationResult> validationResults
+            );
+
+        /// <summary>Runs async validation on an object.</summary>
+        /// <param name="obj">The object being validated.</param>
+        /// <param name="validationResults">A collection that will be populated if validation errors occur.</param>
+        /// <param name="validationContextItems">Validation context items.</param>
+        /// <returns>Returns true if all validation passes.</returns>
+        Task<bool> TryValidateObjectRecursiveAsync(
+            object obj,
+            List<ValidationResult> validationResults,
+            IDictionary<object, object> validationContextItems = null
+            );
+    }
+}

src/RecursiveDataAnnotationsValidation/RecursiveDataAnnotationValidator.cs

@@ -2,13 +2,14 @@
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
 using System.Linq;
+using System.Threading.Tasks;
 using RecursiveDataAnnotationsValidation.Attributes;
 using RecursiveDataAnnotationsValidation.Extensions;
 
 namespace RecursiveDataAnnotationsValidation
 {
     /// <summary>Recursive validator for DataAnnotation attribute-based validation.</summary>
-    public class RecursiveDataAnnotationValidator : IRecursiveDataAnnotationValidator
+    public class RecursiveDataAnnotationValidator : IRecursiveDataAnnotationValidator, IAsyncRecursiveDataAnnotationValidator
     {
         /// <summary>Runs validation on an object.</summary>
         /// <param name="obj">The object being validated.</param>
@@ -34,19 +35,56 @@ List<ValidationResult> validationResults
         /// <param name="validationContextItems">Validation context items.</param>
         /// <returns>Returns true if all validation passes.</returns>
         public bool TryValidateObjectRecursive(
-            object obj, 
-            List<ValidationResult> validationResults, 
+            object obj,
+            List<ValidationResult> validationResults,
             IDictionary<object, object> validationContextItems = null
             )
         {
             return TryValidateObjectRecursive(
-                obj, 
-                validationResults, 
-                new HashSet<object>(), 
+                obj,
+                validationResults,
+                new HashSet<object>(),
                 validationContextItems
                 );
         }
 
+        /// <summary>Runs async validation on an object.</summary>
+        /// <param name="obj">The object being validated.</param>
+        /// <param name="validationContext">Validation context.</param>
+        /// <param name="validationResults">A collection that will be populated if validation errors occur.</param>
+        /// <returns>Returns true if all validation passes.</returns>
+        public Task<bool> TryValidateObjectRecursiveAsync(
+            object obj,
+            ValidationContext validationContext,
+            List<ValidationResult> validationResults
+            )
+        {
+            return Task.FromResult(TryValidateObjectRecursive(
+                obj,
+                validationResults,
+                validationContext.Items
+            ));
+        }
+
+        /// <summary>Runs async validation on an object.</summary>
+        /// <param name="obj">The object being validated.</param>
+        /// <param name="validationResults">A collection that will be populated if validation errors occur.</param>
+        /// <param name="validationContextItems">Validation context items.</param>
+        /// <returns>Returns true if all validation passes.</returns>
+        public Task<bool> TryValidateObjectRecursiveAsync(
+            object obj,
+            List<ValidationResult> validationResults,
+            IDictionary<object, object> validationContextItems = null
+            )
+        {
+            return Task.FromResult(TryValidateObjectRecursive(
+                obj,
+                validationResults,
+                new HashSet<object>(),
+                validationContextItems
+            ));
+        }
+
         private bool TryValidateObject(
             object obj, 
             ICollection<ValidationResult> validationResults, 

test/RecursiveDataAnnotationsValidation.Tests/AsyncCollectionTests.cs

@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Threading.Tasks;
+using RecursiveDataAnnotationsValidation.Tests.TestModels;
+using Xunit;
+
+namespace RecursiveDataAnnotationsValidation.Tests
+{
+    public class AsyncCollectionTests
+    {
+        private readonly IAsyncRecursiveDataAnnotationValidator _sut = new RecursiveDataAnnotationValidator();
+
+        [Fact]
+        public async Task Validates_collections_recursively()
+        {
+            var model = new ItemWithListExample
+            {
+                ItemWithListName = "Parent",
+                Claims = new List<string> { "Claim1", "Claim2" }
+            };
+
+            var validationResults = new List<ValidationResult>();
+            var result = await _sut.TryValidateObjectRecursiveAsync(model, validationResults);
+
+            Assert.True(result);
+            Assert.Empty(validationResults);
+        }
+
+        [Fact]
+        public async Task Fails_when_collection_item_has_validation_errors()
+        {
+            var model = new ItemWithListExample
+            {
+                ItemWithListName = "Parent",
+                Claims = new List<string> { null } // This should fail validation due to [Required]
+            };
+
+            var validationResults = new List<ValidationResult>();
+            var result = await _sut.TryValidateObjectRecursiveAsync(model, validationResults);
+
+            Assert.False(result);
+            Assert.NotEmpty(validationResults);
+        }
+    }
+}

test/RecursiveDataAnnotationsValidation.Tests/AsyncRecursionTests.cs

@@ -0,0 +1,75 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Threading.Tasks;
+using RecursiveDataAnnotationsValidation.Tests.TestModels;
+using Xunit;
+
+namespace RecursiveDataAnnotationsValidation.Tests
+{
+    public class AsyncRecursionTests
+    {
+        private readonly IAsyncRecursiveDataAnnotationValidator _sut = new RecursiveDataAnnotationValidator();
+
+        // This test verifies that async version handles recursive structures correctly
+        [Fact]
+        public async Task Handles_recursive_structures_without_infinite_loop()
+        {
+            var recursiveModel = new RecursionExample
+            {
+                Name = "Recursion1-pass",
+                BooleanA = false,
+                Recursion = new RecursionExample
+                {
+                    Name = "Recursion1-pass.Inner1",
+                    BooleanA = true,
+                    Recursion = null
+                }
+            };
+            recursiveModel.Recursion.Recursion = recursiveModel;
+
+            var model = new RecursionExample
+            {
+                Name = "SUT",
+                BooleanA = true,
+                Recursion = recursiveModel
+            };
+
+            var validationResults = new List<ValidationResult>();
+            var result = await _sut.TryValidateObjectRecursiveAsync(model, validationResults);
+
+            Assert.True(result);
+            Assert.Empty(validationResults);
+        }
+
+        [Fact]
+        public async Task Fails_when_recursive_property_has_validation_errors()
+        {
+            var recursiveModel = new RecursionExample
+            {
+                Name = "Recursion1-fail",
+                BooleanA = false,
+                Recursion = new RecursionExample
+                {
+                    Name = "Recursion1-fail.Inner1",
+                    BooleanA = null, // This should fail validation due to [Required]
+                    Recursion = null
+                }
+            };
+            recursiveModel.Recursion.Recursion = recursiveModel;
+
+            var model = new RecursionExample
+            {
+                Name = "SUT",
+                BooleanA = true,
+                Recursion = recursiveModel
+            };
+
+            var validationResults = new List<ValidationResult>();
+            var result = await _sut.TryValidateObjectRecursiveAsync(model, validationResults);
+
+            Assert.False(result);
+            Assert.NotEmpty(validationResults);
+        }
+    }
+}

test/RecursiveDataAnnotationsValidation.Tests/AsyncValidatorTests.cs

@@ -0,0 +1,73 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Threading.Tasks;
+using RecursiveDataAnnotationsValidation.Tests.TestModels;
+using Xunit;
+
+namespace RecursiveDataAnnotationsValidation.Tests
+{
+    public class AsyncValidatorTests
+    {
+        private readonly IAsyncRecursiveDataAnnotationValidator _sut = new RecursiveDataAnnotationValidator();
+
+        [Fact]
+        public async Task Pass_all_validation()
+        {
+            var model = new SimpleExample
+            {
+                IntegerA = 100,
+                StringB = "test-100",
+                BoolC = true,
+                ExampleEnumD = ExampleEnum.ValueB
+            };
+
+            var validationContext = new ValidationContext(model);
+            var validationResults = new List<ValidationResult>();
+            var result = await _sut.TryValidateObjectRecursiveAsync(model, validationContext, validationResults);
+
+            Assert.True(result);
+            Assert.Empty(validationResults);
+        }
+
+        [Fact]
+        public async Task Indicate_that_IntegerA_is_missing()
+        {
+            var model = new SimpleExample
+            {
+                IntegerA = null,
+                StringB = "test-101",
+                BoolC = false,
+                ExampleEnumD = ExampleEnum.ValueC
+            };
+
+            const string fieldName = nameof(SimpleExample.IntegerA);
+            var validationContext = new ValidationContext(model);
+            var validationResults = new List<ValidationResult>();
+            var result = await _sut.TryValidateObjectRecursiveAsync(model, validationContext, validationResults);
+
+            Assert.False(result);
+            Assert.NotEmpty(validationResults);
+            Assert.NotNull(validationResults
+                .FirstOrDefault(x => x.MemberNames.Contains(fieldName)));
+        }
+
+        [Fact]
+        public async Task Pass_all_validation_without_context()
+        {
+            var model = new SimpleExample
+            {
+                IntegerA = 100,
+                StringB = "test-100",
+                BoolC = true,
+                ExampleEnumD = ExampleEnum.ValueB
+            };
+
+            var validationResults = new List<ValidationResult>();
+            var result = await _sut.TryValidateObjectRecursiveAsync(model, validationResults);
+
+            Assert.True(result);
+            Assert.Empty(validationResults);
+        }
+    }
+}