Add ValidateAsync method to use FV async validation (#344)

samples/CarterSample/Features/CastMembers/CastMemberModule.cs

@@ -4,9 +4,9 @@ public class CastMemberModule : ICarterModule
 {
     public void AddRoutes(IEndpointRouteBuilder app)
     {
-        app.MapPost("/castmembers", (HttpRequest req, CastMember castMember) =>
+        app.MapPost("/castmembers", async (HttpRequest req, CastMember castMember) =>
         {
-            var result = req.Validate<CastMember>(castMember);
+            var result = await req.ValidateAsync<CastMember>(castMember);
 
             if (!result.IsValid)
             {

samples/ValidatorOnlyProject/CastMemberValidator.cs

@@ -1,12 +1,17 @@
 namespace ValidatorOnlyProject
 {
+    using System.Threading.Tasks;
     using FluentValidation;
 
     public class CastMemberValidator : AbstractValidator<CastMember>
     {
         public CastMemberValidator()
         {
-            this.RuleFor(x => x.Name).NotEmpty();
+            this.RuleFor(x => x.Name).NotEmpty().MustAsync(async (name, cancellation) =>
+            {
+                await Task.Delay(50);
+                return true;
+            });
         }
     }
 }

src/Carter/ModelBinding/ValidationExtensions.cs

@@ -7,6 +7,7 @@ namespace Carter.ModelBinding;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 
 public static class ValidationExtensions
 {
@@ -26,6 +27,23 @@ public static ValidationResult Validate<T>(this HttpRequest request, T model)
             ? throw new InvalidOperationException($"Cannot find validator for model of type '{typeof(T).Name}'")
             : validator.Validate(new ValidationContext<T>(model));
     }
+
+    /// <summary>
+    /// Performs validation on the specified <paramref name="model"/> instance
+    /// </summary>
+    /// <typeparam name="T">The type of the <paramref name="model"/> that is being validated</typeparam>
+    /// <param name="request">Current <see cref="HttpRequest"/></param>
+    /// <param name="model">The model instance that is being validated</param>
+    /// <returns><see cref="Task{ValidationResult}"/></returns>
+    public static async Task<ValidationResult> ValidateAsync<T>(this HttpRequest request, T model)
+    {
+        var validatorLocator = request.HttpContext.RequestServices.GetRequiredService<IValidatorLocator>();
+        var validator = validatorLocator.GetValidator<T>();
+
+        return validator == null
+            ? throw new InvalidOperationException($"Cannot find validator for model of type '{typeof(T).Name}'")
+            : await validator.ValidateAsync(new ValidationContext<T>(model));
+    }
 
     /// <summary>
     /// Retrieve formatted validation errors

test/Carter.Samples.Tests/FunctionalTests.cs

@@ -14,6 +14,7 @@ namespace Carter.Samples.Tests
     using CarterSample.Features.FunctionalProgramming.UpdateDirector;
     using Microsoft.AspNetCore.Mvc.Testing;
     using Newtonsoft.Json;
+    using ValidatorOnlyProject;
     using Xunit;
 
     public class FunctionalTests
@@ -23,13 +24,7 @@ public class FunctionalTests
         public FunctionalTests()
         {            
             var server = new WebApplicationFactory<Program>()
-                .WithWebHostBuilder(builder =>
-                {
-                    builder.ConfigureServices(services =>
-                    {
-                        //services.AddSingleton<IHelloService, MockHelloService>();
-                    });
-                });
+                .WithWebHostBuilder(builder => { });
 
             this.client = server.CreateClient();
         }
@@ -192,5 +187,18 @@ public async Task Should_return_403_if_user_not_allowed_on_delete()
             //Then
             Assert.Equal(403, (int)res.StatusCode);
         }
+
+        [Fact]
+        public async Task Should_return_422_for_blank_castmember_with_async_validation()
+        {
+
+            //When
+            var res = await this.client.PostAsync("/castmembers",
+                new StringContent(JsonConvert.SerializeObject(new CastMember{ Name = "" }), Encoding.UTF8,
+                    "application/json"));
+
+            //Then
+            Assert.Equal(422, (int)res.StatusCode);
+        }
     }
 }