Fix member name formatting in validation errors

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

Author: Copilot

src/Http/Http.Abstractions/src/Validation/ValidatableParameterInfo.cs

@@ -66,7 +66,14 @@ public virtual async Task ValidateAsync(object? value, ValidateContext context,
         }
 
         context.ValidationContext.DisplayName = DisplayName;
-        context.ValidationContext.MemberName = Name;
+        
+        // Format member name according to naming policy if available
+        var memberName = Name;
+        if (context.SerializerOptions?.PropertyNamingPolicy is not null)
+        {
+            memberName = context.SerializerOptions.PropertyNamingPolicy.ConvertName(Name);
+        }
+        context.ValidationContext.MemberName = memberName;
 
         var validationAttributes = GetValidationAttributes();
 

src/Http/Http.Abstractions/src/Validation/ValidatablePropertyInfo.cs

@@ -76,7 +76,14 @@ public virtual async Task ValidateAsync(object? value, ValidateContext context,
         }
 
         context.ValidationContext.DisplayName = DisplayName;
-        context.ValidationContext.MemberName = Name;
+        
+        // Format member name according to naming policy if available
+        var memberName = Name;
+        if (context.SerializerOptions?.PropertyNamingPolicy is not null)
+        {
+            memberName = context.SerializerOptions.PropertyNamingPolicy.ConvertName(Name);
+        }
+        context.ValidationContext.MemberName = memberName;
 
         // Check required attribute first
         if (_requiredAttribute is not null || validationAttributes.TryGetRequiredAttribute(out _requiredAttribute))

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

@@ -215,41 +215,65 @@ private string FormatErrorMessage(string errorMessage)
             return errorMessage;
         }
 
-        // Common pattern: "The {PropertyName} field is required."
-        const string pattern = "The ";
-        const string fieldPattern = " field ";
+        // Pattern 1: "The {PropertyName} field is required."
+        const string pattern1Start = "The ";
+        const string pattern1Middle = " field ";
 
-        int startIndex = errorMessage.IndexOf(pattern, StringComparison.Ordinal);
-        if (startIndex != 0)
-        {
-            return errorMessage; // Does not start with "The "
-        }
+        // Pattern 2: "The field {PropertyName} must be between X and Y."
+        const string pattern2 = "The field ";
 
-        int endIndex = errorMessage.IndexOf(fieldPattern, pattern.Length, StringComparison.Ordinal);
-        if (endIndex <= pattern.Length)
+        // Try Pattern 1 first
+        if (errorMessage.StartsWith(pattern1Start, StringComparison.Ordinal))
         {
-            return errorMessage; // Does not contain " field " or it's too early
+            int endIndex = errorMessage.IndexOf(pattern1Middle, pattern1Start.Length, StringComparison.Ordinal);
+            if (endIndex > pattern1Start.Length)
+            {
+                // Extract the property name between "The " and " field "
+                ReadOnlySpan<char> messageSpan = errorMessage.AsSpan();
+                ReadOnlySpan<char> propertyNameSpan = messageSpan.Slice(pattern1Start.Length, endIndex - pattern1Start.Length);
+                string propertyName = propertyNameSpan.ToString();
+                
+                if (!string.IsNullOrWhiteSpace(propertyName))
+                {
+                    // 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(
+                        pattern1Start, 
+                        formattedPropertyName, 
+                        messageSpan.Slice(endIndex).ToString()
+                    );
+                }
+            }
         }
-        
-        // 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))
+        // Try Pattern 2
+        else if (errorMessage.StartsWith(pattern2, StringComparison.Ordinal))
         {
-            return errorMessage;
+            // Find the word after "The field " and before " must"
+            const string pattern2End = " must";
+            int startPos = pattern2.Length;
+            int endPos = errorMessage.IndexOf(pattern2End, startPos, StringComparison.Ordinal);
+            
+            if (endPos > startPos)
+            {
+                string propertyName = errorMessage.Substring(startPos, endPos - startPos);
+                if (!string.IsNullOrWhiteSpace(propertyName))
+                {
+                    // Format the property name with the naming policy
+                    string formattedPropertyName = SerializerOptions.PropertyNamingPolicy.ConvertName(propertyName);
+                    
+                    // Reconstruct the message
+                    ReadOnlySpan<char> errorSpan = errorMessage.AsSpan();
+                    return string.Concat(
+                        pattern2, 
+                        formattedPropertyName, 
+                        errorSpan.Slice(endPos));
+                }
+            }
         }
 
-        // 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()
-        );
+        // Return the original message if no patterns matched or formatting failed
+        return errorMessage;
     }
 }

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

@@ -139,7 +139,7 @@ [new RequiredAttribute()])
             kvp =>
             {
                 Assert.Equal("name", kvp.Key);
-                Assert.Equal("The Name field is required.", kvp.Value.First());
+                Assert.Equal("The name field is required.", kvp.Value.First());
             },
             kvp =>
             {
@@ -149,12 +149,12 @@ [new RequiredAttribute()])
             kvp =>
             {
                 Assert.Equal("address.street", kvp.Key);
-                Assert.Equal("The Street field is required.", kvp.Value.First());
+                Assert.Equal("The street field is required.", kvp.Value.First());
             },
             kvp =>
             {
                 Assert.Equal("address.city", kvp.Key);
-                Assert.Equal("The City field is required.", kvp.Value.First());
+                Assert.Equal("The city field is required.", kvp.Value.First());
             });
     }
 
@@ -281,7 +281,7 @@ [new RangeAttribute(1, 100)])
             kvp =>
             {
                 Assert.Equal("items[0].quantity", kvp.Key);
-                Assert.Equal("The field quantity must be between 1 and 100.", kvp.Value.First());
+                Assert.Equal("The field Quantity must be between 1 and 100.", kvp.Value.First());
             });
     }