Update tests and fix implementation for more cases

Author: captainsafia

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

@@ -3,6 +3,9 @@
 
 using System.ComponentModel.DataAnnotations;
 using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
+using System.Text.Json;
+using System.Text.Json.Serialization;
 
 namespace Microsoft.AspNetCore.Http.Validation;
 
@@ -33,7 +36,7 @@ protected ValidatablePropertyInfo(
     /// <summary>
     /// Gets the member type.
     /// </summary>
-    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)]
+    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicConstructors)]
     internal Type DeclaringType { get; }
 
     /// <summary>
@@ -65,24 +68,23 @@ public virtual async Task ValidateAsync(object? value, ValidateContext context,
         var validationAttributes = GetValidationAttributes();
 
         // Calculate and save the current path
+        var memberName = GetJsonPropertyName(Name, property, context.SerializerOptions?.PropertyNamingPolicy);
         var originalPrefix = context.CurrentValidationPath;
         if (string.IsNullOrEmpty(originalPrefix))
         {
-            context.CurrentValidationPath = Name;
+            context.CurrentValidationPath = memberName;
         }
         else
         {
-            context.CurrentValidationPath = $"{originalPrefix}.{Name}";
+            context.CurrentValidationPath = $"{originalPrefix}.{memberName}";
         }
 
-        context.ValidationContext.DisplayName = DisplayName;
-        
-        // 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);
-        }
+        // Format the display name and member name according to JsonPropertyName attribute first, then naming policy
+        // If the property has a [Display] attribute (either on property or record parameter), use DisplayName directly without formatting
+        var hasDisplayAttribute = HasDisplayAttribute(property);
+        context.ValidationContext.DisplayName = hasDisplayAttribute
+            ? DisplayName
+            : GetJsonPropertyName(DisplayName, property, context.SerializerOptions?.PropertyNamingPolicy);
         context.ValidationContext.MemberName = memberName;
 
         // Check required attribute first
@@ -177,4 +179,61 @@ void ValidateValue(object? val, string errorPrefix, ValidationAttribute[] valida
             }
         }
     }
+
+    /// <summary>
+    /// Gets the effective member name for JSON serialization, considering JsonPropertyName attribute and naming policy.
+    /// </summary>
+    /// <param name="targetValue">The target value to get the name for.</param>
+    /// <param name="property">The property info to get the name for.</param>
+    /// <param name="namingPolicy">The JSON naming policy to apply if no JsonPropertyName attribute is present.</param>
+    /// <returns>The effective property name for JSON serialization.</returns>
+    private static string GetJsonPropertyName(string targetValue, PropertyInfo property, JsonNamingPolicy? namingPolicy)
+    {
+        var jsonPropertyName = property.GetCustomAttribute<JsonPropertyNameAttribute>()?.Name;
+
+        if (jsonPropertyName is not null)
+        {
+            return jsonPropertyName;
+        }
+
+        if (namingPolicy is not null)
+        {
+            return namingPolicy.ConvertName(targetValue);
+        }
+
+        return targetValue;
+    }
+
+    /// <summary>
+    /// Determines whether the property has a DisplayAttribute, either directly on the property
+    /// or on the corresponding constructor parameter if the declaring type is a record.
+    /// </summary>
+    /// <param name="property">The property to check.</param>
+    /// <returns>True if the property has a DisplayAttribute, false otherwise.</returns>
+    private bool HasDisplayAttribute(PropertyInfo property)
+    {
+        // Check if the property itself has the DisplayAttribute with a valid Name
+        if (property.GetCustomAttribute<DisplayAttribute>() is { Name: not null })
+        {
+            return true;
+        }
+
+        // Look for a constructor parameter matching the property name (case-insensitive)
+        // to account for the record scenario
+        foreach (var constructor in DeclaringType.GetConstructors())
+        {
+            foreach (var parameter in constructor.GetParameters())
+            {
+                if (string.Equals(parameter.Name, property.Name, StringComparison.OrdinalIgnoreCase))
+                {
+                    if (parameter.GetCustomAttribute<DisplayAttribute>() is { Name: not null })
+                    {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
 }

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());
             });
     }
 
@@ -891,20 +891,17 @@ [new EmailAddressAttribute()])
 
         // Assert
         Assert.NotNull(context.ValidationErrors);
+        // Use [JsonPropertyName] over naming policy
         Assert.Collection(context.ValidationErrors,
-            kvp => 
+            kvp =>
             {
-                // Property key uses camelCase naming policy
                 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 => 
+            kvp =>
             {
-                // Property key uses camelCase naming policy
-                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("email", kvp.Key);
+                Assert.Equal("The email field is not a valid e-mail address.", kvp.Value.First());
             });
     }
 
@@ -1107,13 +1104,13 @@ 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
@@ -1147,7 +1144,7 @@ public void Validate_PreservesCustomErrorMessagesWithPropertyNamingPolicy()
     {
         // Arrange
         var validationOptions = new ValidationOptions();
-        
+
         var model = new TestModel();
         var validationContext = new ValidationContext(model);
         var validateContext = new ValidateContext
@@ -1175,7 +1172,7 @@ public void Validate_PreservesCustomErrorMessagesWithPropertyNamingPolicy()
         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; }

src/Http/Http.Extensions/test/ValidationsGenerator/ValidationsGenerator.ComplexType.cs

@@ -124,8 +124,8 @@ async Task InvalidIntegerWithRangeProducesError(Endpoint endpoint)
                 var problemDetails = await AssertBadRequest(context);
                 Assert.Collection(problemDetails.Errors, kvp =>
                 {
-                    Assert.Equal("IntegerWithRange", kvp.Key);
-                    Assert.Equal("The field IntegerWithRange must be between 10 and 100.", kvp.Value.Single());
+                    Assert.Equal("integerWithRange", kvp.Key);
+                    Assert.Equal("The field integerWithRange must be between 10 and 100.", kvp.Value.Single());
                 });
             }
 
@@ -143,7 +143,7 @@ async Task InvalidIntegerWithRangeAndDisplayNameProducesError(Endpoint endpoint)
                 var problemDetails = await AssertBadRequest(context);
                 Assert.Collection(problemDetails.Errors, kvp =>
                 {
-                    Assert.Equal("IntegerWithRangeAndDisplayName", kvp.Key);
+                    Assert.Equal("integerWithRangeAndDisplayName", kvp.Key);
                     Assert.Equal("The field Valid identifier must be between 10 and 100.", kvp.Value.Single());
                 });
             }
@@ -162,8 +162,8 @@ async Task MissingRequiredSubtypePropertyProducesError(Endpoint endpoint)
                 var problemDetails = await AssertBadRequest(context);
                 Assert.Collection(problemDetails.Errors, kvp =>
                 {
-                    Assert.Equal("PropertyWithMemberAttributes", kvp.Key);
-                    Assert.Equal("The PropertyWithMemberAttributes field is required.", kvp.Value.Single());
+                    Assert.Equal("propertyWithMemberAttributes", kvp.Key);
+                    Assert.Equal("The propertyWithMemberAttributes field is required.", kvp.Value.Single());
                 });
             }
 
@@ -185,13 +185,13 @@ async Task InvalidRequiredSubtypePropertyProducesError(Endpoint endpoint)
                 Assert.Collection(problemDetails.Errors,
                 kvp =>
                 {
-                    Assert.Equal("PropertyWithMemberAttributes.RequiredProperty", kvp.Key);
-                    Assert.Equal("The RequiredProperty field is required.", kvp.Value.Single());
+                    Assert.Equal("propertyWithMemberAttributes.requiredProperty", kvp.Key);
+                    Assert.Equal("The requiredProperty field is required.", kvp.Value.Single());
                 },
                 kvp =>
                 {
-                    Assert.Equal("PropertyWithMemberAttributes.StringWithLength", kvp.Key);
-                    Assert.Equal("The field StringWithLength must be a string with a maximum length of 10.", kvp.Value.Single());
+                    Assert.Equal("propertyWithMemberAttributes.stringWithLength", kvp.Key);
+                    Assert.Equal("The field stringWithLength must be a string with a maximum length of 10.", kvp.Value.Single());
                 });
             }
 
@@ -214,18 +214,18 @@ async Task InvalidSubTypeWithInheritancePropertyProducesError(Endpoint endpoint)
                 Assert.Collection(problemDetails.Errors,
                 kvp =>
                 {
-                    Assert.Equal("PropertyWithInheritance.EmailString", kvp.Key);
-                    Assert.Equal("The EmailString field is not a valid e-mail address.", kvp.Value.Single());
+                    Assert.Equal("propertyWithInheritance.emailString", kvp.Key);
+                    Assert.Equal("The emailString field is not a valid e-mail address.", kvp.Value.Single());
                 },
                 kvp =>
                 {
-                    Assert.Equal("PropertyWithInheritance.RequiredProperty", kvp.Key);
-                    Assert.Equal("The RequiredProperty field is required.", kvp.Value.Single());
+                    Assert.Equal("propertyWithInheritance.requiredProperty", kvp.Key);
+                    Assert.Equal("The requiredProperty field is required.", kvp.Value.Single());
                 },
                 kvp =>
                 {
-                    Assert.Equal("PropertyWithInheritance.StringWithLength", kvp.Key);
-                    Assert.Equal("The field StringWithLength must be a string with a maximum length of 10.", kvp.Value.Single());
+                    Assert.Equal("propertyWithInheritance.stringWithLength", kvp.Key);
+                    Assert.Equal("The field stringWithLength must be a string with a maximum length of 10.", kvp.Value.Single());
                 });
             }
 
@@ -257,18 +257,18 @@ async Task InvalidListOfSubTypesProducesError(Endpoint endpoint)
                 Assert.Collection(problemDetails.Errors,
                 kvp =>
                 {
-                    Assert.Equal("ListOfSubTypes[0].RequiredProperty", kvp.Key);
-                    Assert.Equal("The RequiredProperty field is required.", kvp.Value.Single());
+                    Assert.Equal("listOfSubTypes[0].requiredProperty", kvp.Key);
+                    Assert.Equal("The requiredProperty field is required.", kvp.Value.Single());
                 },
                 kvp =>
                 {
-                    Assert.Equal("ListOfSubTypes[0].StringWithLength", kvp.Key);
-                    Assert.Equal("The field StringWithLength must be a string with a maximum length of 10.", kvp.Value.Single());
+                    Assert.Equal("listOfSubTypes[0].stringWithLength", kvp.Key);
+                    Assert.Equal("The field stringWithLength must be a string with a maximum length of 10.", kvp.Value.Single());
                 },
                 kvp =>
                 {
-                    Assert.Equal("ListOfSubTypes[1].StringWithLength", kvp.Key);
-                    Assert.Equal("The field StringWithLength must be a string with a maximum length of 10.", kvp.Value.Single());
+                    Assert.Equal("listOfSubTypes[1].stringWithLength", kvp.Key);
+                    Assert.Equal("The field stringWithLength must be a string with a maximum length of 10.", kvp.Value.Single());
                 });
             }
 
@@ -286,7 +286,7 @@ async Task InvalidPropertyWithDerivedValidationAttributeProducesError(Endpoint e
                 var problemDetails = await AssertBadRequest(context);
                 Assert.Collection(problemDetails.Errors, kvp =>
                 {
-                    Assert.Equal("IntegerWithDerivedValidationAttribute", kvp.Key);
+                    Assert.Equal("integerWithDerivedValidationAttribute", kvp.Key);
                     Assert.Equal("Value must be an even number", kvp.Value.Single());
                 });
             }
@@ -305,15 +305,15 @@ async Task InvalidPropertyWithMultipleAttributesProducesError(Endpoint endpoint)
                 var problemDetails = await AssertBadRequest(context);
                 Assert.Collection(problemDetails.Errors, kvp =>
                 {
-                    Assert.Equal("PropertyWithMultipleAttributes", kvp.Key);
+                    Assert.Equal("propertyWithMultipleAttributes", kvp.Key);
                     Assert.Collection(kvp.Value,
                     error =>
                     {
-                        Assert.Equal("The field PropertyWithMultipleAttributes is invalid.", error);
+                        Assert.Equal("The field propertyWithMultipleAttributes is invalid.", error);
                     },
                     error =>
                     {
-                        Assert.Equal("The field PropertyWithMultipleAttributes must be between 10 and 100.", error);
+                        Assert.Equal("The field propertyWithMultipleAttributes must be between 10 and 100.", error);
                     });
                 });
             }
@@ -333,7 +333,7 @@ async Task InvalidPropertyWithCustomValidationProducesError(Endpoint endpoint)
                 var problemDetails = await AssertBadRequest(context);
                 Assert.Collection(problemDetails.Errors, kvp =>
                 {
-                    Assert.Equal("IntegerWithCustomValidation", kvp.Key);
+                    Assert.Equal("integerWithCustomValidation", kvp.Key);
                     var error = Assert.Single(kvp.Value);
                     Assert.Equal("Can't use the same number value in two properties on the same class.", error);
                 });

src/Http/Http.Extensions/test/ValidationsGenerator/ValidationsGenerator.IValidatableObject.cs

@@ -128,23 +128,24 @@ async Task ValidateMethodCalledIfPropertyValidationsFail()
                 Assert.Collection(problemDetails.Errors,
                     error =>
                     {
-                        Assert.Equal("Value2", error.Key);
+                        Assert.Equal("value2", error.Key);
                         Assert.Collection(error.Value,
-                            msg => Assert.Equal("The Value2 field is required.", msg));
+                            msg => Assert.Equal("The value2 field is required.", msg));
                     },
                     error =>
                     {
-                        Assert.Equal("SubType.RequiredProperty", error.Key);
-                        Assert.Equal("The RequiredProperty field is required.", error.Value.Single());
+                        Assert.Equal("subType.requiredProperty", error.Key);
+                        Assert.Equal("The requiredProperty field is required.", error.Value.Single());
                     },
                     error =>
                     {
-                        Assert.Equal("SubType.Value3", error.Key);
+                        Assert.Equal("subType.value3", error.Key);
                         Assert.Equal("The field ValidatableSubType must be 'some-value'.", error.Value.Single());
                     },
                     error =>
                     {
-                        Assert.Equal("Value1", error.Key);
+                        Assert.Equal("value1", error.Key);
+                        // The error message is generated using nameof(Value1) in the IValidateObject implementation
                         Assert.Equal("The field Value1 must be between 10 and 100.", error.Value.Single());
                     });
             }
@@ -169,12 +170,12 @@ async Task ValidateForSubtypeInvokedFirst()
                 Assert.Collection(problemDetails.Errors,
                     error =>
                     {
-                        Assert.Equal("SubType.Value3", error.Key);
+                        Assert.Equal("subType.value3", error.Key);
                         Assert.Equal("The field ValidatableSubType must be 'some-value'.", error.Value.Single());
                     },
                     error =>
                     {
-                        Assert.Equal("Value1", error.Key);
+                        Assert.Equal("value1", error.Key);
                         Assert.Equal("The field Value1 must be between 10 and 100.", error.Value.Single());
                     });
             }
@@ -199,7 +200,7 @@ async Task ValidateForTopLevelInvoked()
                 Assert.Collection(problemDetails.Errors,
                     error =>
                     {
-                        Assert.Equal("Value1", error.Key);
+                        Assert.Equal("value1", error.Key);
                         Assert.Equal("The field Value1 must be between 10 and 100.", error.Value.Single());
                     });
             }

src/Http/Http.Extensions/test/ValidationsGenerator/ValidationsGenerator.NoOp.cs

@@ -170,8 +170,8 @@ await VerifyEndpoint(compilation, "/complex-type", async (endpoint, serviceProvi
             var problemDetails = await AssertBadRequest(context);
             Assert.Collection(problemDetails.Errors, kvp =>
             {
-                Assert.Equal("IntegerWithRange", kvp.Key);
-                Assert.Equal("The field IntegerWithRange must be between 10 and 100.", kvp.Value.Single());
+                Assert.Equal("integerWithRange", kvp.Key);
+                Assert.Equal("The field integerWithRange must be between 10 and 100.", kvp.Value.Single());
             });
         });
     }