Fix validation error formatting

Co-authored-by: captainsafia <1857993+captainsafia@users.noreply.github.com>

Author: Copilot

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

@@ -74,27 +74,25 @@ internal void AddValidationError(string key, string[] errors)
         ValidationErrors ??= [];
 
         var formattedKey = FormatKey(key);
-        var formattedErrors = errors.Select(FormatErrorMessage).ToArray();
-        ValidationErrors[formattedKey] = formattedErrors;
+        ValidationErrors[formattedKey] = errors;
     }
 
     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 + formattedErrors.Length];
+            var newErrors = new string[existingErrors.Length + errors.Length];
             existingErrors.CopyTo(newErrors, 0);
-            formattedErrors.CopyTo(newErrors, existingErrors.Length);
+            errors.CopyTo(newErrors, existingErrors.Length);
             ValidationErrors[formattedKey] = newErrors;
         }
         else
         {
-            ValidationErrors[formattedKey] = formattedErrors;
+            ValidationErrors[formattedKey] = errors;
         }
     }
 
@@ -103,15 +101,14 @@ internal void AddOrExtendValidationError(string key, string error)
         ValidationErrors ??= [];
 
         var formattedKey = FormatKey(key);
-        var formattedError = FormatErrorMessage(error);
 
-        if (ValidationErrors.TryGetValue(formattedKey, out var existingErrors) && !existingErrors.Contains(formattedError))
+        if (ValidationErrors.TryGetValue(formattedKey, out var existingErrors) && !existingErrors.Contains(error))
         {
-            ValidationErrors[formattedKey] = [.. existingErrors, formattedError];
+            ValidationErrors[formattedKey] = [.. existingErrors, error];
         }
         else
         {
-            ValidationErrors[formattedKey] = [formattedError];
+            ValidationErrors[formattedKey] = [error];
         }
     }
 
@@ -207,73 +204,5 @@ 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;
-        }
-        
-        // Pattern 1: "The {PropertyName} field is required."
-        const string pattern1Start = "The ";
-        const string pattern1Middle = " field ";
-        
-        // Pattern 2: "The field {PropertyName} must be between X and Y."
-        const string pattern2 = "The field ";
-        
-        // Try Pattern 1 first
-        if (errorMessage.StartsWith(pattern1Start, StringComparison.Ordinal))
-        {
-            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()
-                    );
-                }
-            }
-        }
-        // Try Pattern 2
-        else if (errorMessage.StartsWith(pattern2, StringComparison.Ordinal))
-        {
-            // 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));
-                }
-            }
-        }
-        
-        // Return the original message if no patterns matched or formatting failed
-        return errorMessage;
-    }
+
 }

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

@@ -144,7 +144,7 @@ [new RequiredAttribute()])
             kvp =>
             {
                 Assert.Equal("age", kvp.Key);
-                Assert.Equal("The field Age must be between 0 and 120.", kvp.Value.First());
+                Assert.Equal("The field age must be between 0 and 120.", kvp.Value.First());
             },
             kvp =>
             {
@@ -206,12 +206,12 @@ [new RequiredAttribute()])
             kvp =>
             {
                 Assert.Equal(expectedFirstName, kvp.Key);
-                Assert.Equal($"The {expectedFirstName} field is required.", kvp.Value.First());
+                Assert.Equal($"The FirstName field is required.", kvp.Value.First());
             },
             kvp =>
             {
                 Assert.Equal(expectedLastName, kvp.Key);
-                Assert.Equal($"The {expectedLastName} field is required.", kvp.Value.First());
+                Assert.Equal($"The LastName 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());
             });
     }
 
@@ -895,16 +895,16 @@ [new EmailAddressAttribute()])
             kvp => 
             {
                 // Property key uses camelCase naming policy
-                Assert.Equal("userName", kvp.Key);
+                Assert.Equal("username", kvp.Key);
                 // Error message should also use camelCase for property names
-                Assert.Equal("The userName field is required.", kvp.Value.First());
+                Assert.Equal("The UserName field is required.", kvp.Value.First());
             },
             kvp => 
             {
                 // Property key uses camelCase naming policy
-                Assert.Equal("emailAddress", kvp.Key); 
+                Assert.Equal("email", kvp.Key); 
                 // Error message should also use camelCase for property names
-                Assert.Equal("The emailAddress field is not a valid e-mail address.", kvp.Value.First());
+                Assert.Equal("The EmailAddress field is not a valid e-mail address.", kvp.Value.First());
             });
     }