Format validation error messages to respect JSON naming policy

Co-authored-by: captainsafia <[email protected]>

Author: Copilot

src/Http/Http.Abstractions/src/Validation/ValidateContext.cs

@@ -3,6 +3,7 @@
 
 using System.ComponentModel.DataAnnotations;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using System.Text.Json;
 
 namespace Microsoft.AspNetCore.Http.Validation;
@@ -68,29 +69,32 @@ public sealed class ValidateContext
     /// </summary>
     public JsonSerializerOptions? SerializerOptions { get; set; }
 
-    internal void AddValidationError(string key, string[] error)
+    internal void AddValidationError(string key, string[] errors)
     {
         ValidationErrors ??= [];
 
         var formattedKey = FormatKey(key);
-        ValidationErrors[formattedKey] = error;
+        var formattedErrors = errors.Select(FormatErrorMessage).ToArray();
+        ValidationErrors[formattedKey] = formattedErrors;
     }
 
     internal void AddOrExtendValidationErrors(string key, string[] errors)
     {
         ValidationErrors ??= [];
 
         var formattedKey = FormatKey(key);
+        var formattedErrors = errors.Select(FormatErrorMessage).ToArray();
+        
         if (ValidationErrors.TryGetValue(formattedKey, out var existingErrors))
         {
-            var newErrors = new string[existingErrors.Length + errors.Length];
+            var newErrors = new string[existingErrors.Length + formattedErrors.Length];
             existingErrors.CopyTo(newErrors, 0);
-            errors.CopyTo(newErrors, existingErrors.Length);
+            formattedErrors.CopyTo(newErrors, existingErrors.Length);
             ValidationErrors[formattedKey] = newErrors;
         }
         else
         {
-            ValidationErrors[formattedKey] = errors;
+            ValidationErrors[formattedKey] = formattedErrors;
         }
     }
 
@@ -99,13 +103,15 @@ internal void AddOrExtendValidationError(string key, string error)
         ValidationErrors ??= [];
 
         var formattedKey = FormatKey(key);
-        if (ValidationErrors.TryGetValue(formattedKey, out var existingErrors) && !existingErrors.Contains(error))
+        var formattedError = FormatErrorMessage(error);
+        
+        if (ValidationErrors.TryGetValue(formattedKey, out var existingErrors) && !existingErrors.Contains(formattedError))
         {
-            ValidationErrors[formattedKey] = [.. existingErrors, error];
+            ValidationErrors[formattedKey] = [.. existingErrors, formattedError];
         }
         else
         {
-            ValidationErrors[formattedKey] = [error];
+            ValidationErrors[formattedKey] = [formattedError];
         }
     }
 
@@ -146,7 +152,7 @@ private string FormatComplexKey(string key)
                 if (i > lastIndex)
                 {
                     string segment = key.Substring(lastIndex, i - lastIndex);
-                    string formattedSegment = propertyNamingPolicy != null 
+                    string formattedSegment = propertyNamingPolicy is not null 
                         ? propertyNamingPolicy.ConvertName(segment) 
                         : segment;
                     result.Append(formattedSegment);
@@ -175,7 +181,7 @@ private string FormatComplexKey(string key)
                 if (i > lastIndex)
                 {
                     string segment = key.Substring(lastIndex, i - lastIndex);
-                    string formattedSegment = propertyNamingPolicy != null 
+                    string formattedSegment = propertyNamingPolicy is not null 
                         ? propertyNamingPolicy.ConvertName(segment) 
                         : segment;
                     result.Append(formattedSegment);
@@ -191,7 +197,7 @@ private string FormatComplexKey(string key)
         if (lastIndex < key.Length)
         {
             string segment = key.Substring(lastIndex);
-            if (!inBracket && propertyNamingPolicy != null)
+            if (!inBracket && propertyNamingPolicy is not null)
             {
                 segment = propertyNamingPolicy.ConvertName(segment);
             }
@@ -200,4 +206,50 @@ private string FormatComplexKey(string key)
 
         return result.ToString();
     }
+    
+    // Format validation error messages to use the same property naming policy as the keys
+    private string FormatErrorMessage(string errorMessage)
+    {
+        if (SerializerOptions?.PropertyNamingPolicy is null)
+        {
+            return errorMessage;
+        }
+        
+        // Common pattern: "The {PropertyName} field is required."
+        const string pattern = "The ";
+        const string fieldPattern = " field ";
+        
+        int startIndex = errorMessage.IndexOf(pattern, StringComparison.Ordinal);
+        if (startIndex != 0)
+        {
+            return errorMessage; // Does not start with "The "
+        }
+        
+        int endIndex = errorMessage.IndexOf(fieldPattern, pattern.Length, StringComparison.Ordinal);
+        if (endIndex <= pattern.Length)
+        {
+            return errorMessage; // Does not contain " field " or it's too early
+        }
+        
+        // Extract the property name between "The " and " field "
+        // Use ReadOnlySpan<char> for better performance
+        ReadOnlySpan<char> messageSpan = errorMessage.AsSpan();
+        ReadOnlySpan<char> propertyNameSpan = messageSpan.Slice(pattern.Length, endIndex - pattern.Length);
+        string propertyName = propertyNameSpan.ToString();
+        
+        if (string.IsNullOrWhiteSpace(propertyName))
+        {
+            return errorMessage;
+        }
+        
+        // Format the property name with the naming policy
+        string formattedPropertyName = SerializerOptions.PropertyNamingPolicy.ConvertName(propertyName);
+        
+        // Construct the new error message by combining parts
+        return string.Concat(
+            pattern, 
+            formattedPropertyName, 
+            messageSpan.Slice(endIndex).ToString()
+        );
+    }
 }

src/Http/Http.Abstractions/test/Validation/ValidatableTypeInfoTests.cs

@@ -206,12 +206,12 @@ [new RequiredAttribute()])
             kvp =>
             {
                 Assert.Equal(expectedFirstName, kvp.Key);
-                Assert.Equal("The FirstName field is required.", kvp.Value.First());
+                Assert.Equal($"The {expectedFirstName} field is required.", kvp.Value.First());
             },
             kvp =>
             {
                 Assert.Equal(expectedLastName, kvp.Key);
-                Assert.Equal("The LastName field is required.", kvp.Value.First());
+                Assert.Equal($"The {expectedLastName} field is required.", kvp.Value.First());
             });
     }
 
@@ -894,15 +894,17 @@ [new EmailAddressAttribute()])
         Assert.Collection(context.ValidationErrors,
             kvp => 
             {
-                // Currently uses camelCase naming policy, not JsonPropertyName
+                // Property key uses camelCase naming policy
                 Assert.Equal("userName", kvp.Key);
-                Assert.Equal("The UserName field is required.", kvp.Value.First());
+                // Error message should also use camelCase for property names
+                Assert.Equal("The userName field is required.", kvp.Value.First());
             },
             kvp => 
             {
-                // Currently uses camelCase naming policy, not JsonPropertyName
+                // Property key uses camelCase naming policy
                 Assert.Equal("emailAddress", kvp.Key); 
-                Assert.Equal("The EmailAddress field is not a valid e-mail address.", kvp.Value.First());
+                // Error message should also use camelCase for property names
+                Assert.Equal("The emailAddress field is not a valid e-mail address.", kvp.Value.First());
             });
     }
 
@@ -1105,4 +1107,77 @@ public bool TryGetValidatableParameterInfo(ParameterInfo parameterInfo, [NotNull
             }
         }
     }
+    
+    [Fact]
+    public void Validate_FormatsErrorMessagesWithPropertyNamingPolicy()
+    {
+        // Arrange
+        var validationOptions = new ValidationOptions();
+        
+        var address = new Address();
+        var validationContext = new ValidationContext(address);
+        var validateContext = new ValidateContext
+        {
+            ValidationOptions = validationOptions,
+            ValidationContext = validationContext,
+            SerializerOptions = new JsonSerializerOptions
+            {
+                PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+            }
+        };
+
+        var propertyInfo = CreatePropertyInfo(
+            typeof(Address),
+            typeof(string),
+            "Street",
+            "Street",
+            [new RequiredAttribute()]);
+
+        // Act
+        propertyInfo.ValidateAsync(address, validateContext, CancellationToken.None);
+
+        // Assert
+        var error = Assert.Single(validateContext.ValidationErrors!);
+        Assert.Equal("street", error.Key);
+        Assert.Equal("The street field is required.", error.Value.First());
+    }
+
+    [Fact]
+    public void Validate_PreservesCustomErrorMessagesWithPropertyNamingPolicy()
+    {
+        // Arrange
+        var validationOptions = new ValidationOptions();
+        
+        var model = new TestModel();
+        var validationContext = new ValidationContext(model);
+        var validateContext = new ValidateContext
+        {
+            ValidationOptions = validationOptions,
+            ValidationContext = validationContext,
+            SerializerOptions = new JsonSerializerOptions
+            {
+                PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+            }
+        };
+
+        var propertyInfo = CreatePropertyInfo(
+            typeof(TestModel),
+            typeof(string),
+            "CustomProperty",
+            "CustomProperty",
+            [new RequiredAttribute { ErrorMessage = "Custom message without standard format." }]);
+
+        // Act
+        propertyInfo.ValidateAsync(model, validateContext, CancellationToken.None);
+
+        // Assert
+        var error = Assert.Single(validateContext.ValidationErrors!);
+        Assert.Equal("customProperty", error.Key);
+        Assert.Equal("Custom message without standard format.", error.Value.First()); // Custom message without formatting
+    }
+    
+    private class TestModel
+    {
+        public string? CustomProperty { get; set; }
+    }
 }