Tolerate null ValidationContext in validation resolver APIs

Author: captainsafia

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

@@ -3,7 +3,6 @@
 
 using System.Collections;
 using System.ComponentModel.DataAnnotations;
-using System.Diagnostics;
 
 namespace Microsoft.AspNetCore.Http.Validation;
 
@@ -58,14 +57,17 @@ protected ValidatableParameterInfo(
     /// </remarks>
     public virtual async Task ValidateAsync(object? value, ValidateContext context, CancellationToken cancellationToken)
     {
-        Debug.Assert(context.ValidationContext is not null);
-
         // Skip validation if value is null and parameter is optional
         if (value == null && ParameterType.IsNullable())
         {
             return;
         }
 
+        // ValidationContext requires a non-null value although the invocation pattern that we use
+        // calls `GetValidationResult` and passes the value there. `GetValidationResult` tolerates
+        // null values so we only need to set a non-null value to the ValidationContext here.
+        context.ValidationContext ??= new ValidationContext(value ?? new object(), displayName: DisplayName, serviceProvider: null, items: null);
+
         context.ValidationContext.DisplayName = DisplayName;
         context.ValidationContext.MemberName = Name;
 

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

@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.ComponentModel.DataAnnotations;
-using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 
 namespace Microsoft.AspNetCore.Http.Validation;
@@ -60,8 +59,6 @@ protected ValidatablePropertyInfo(
     /// <inheritdoc />
     public virtual async Task ValidateAsync(object? value, ValidateContext context, CancellationToken cancellationToken)
     {
-        Debug.Assert(context.ValidationContext is not null);
-
         var property = DeclaringType.GetProperty(Name) ?? throw new InvalidOperationException($"Property '{Name}' not found on type '{DeclaringType.Name}'.");
         var propertyValue = property.GetValue(value);
         var validationAttributes = GetValidationAttributes();
@@ -77,6 +74,8 @@ public virtual async Task ValidateAsync(object? value, ValidateContext context,
             context.CurrentValidationPath = $"{originalPrefix}.{Name}";
         }
 
+        context.ValidationContext ??= new ValidationContext(value ?? new object(), displayName: DisplayName, serviceProvider: null, items: null);
+
         context.ValidationContext.DisplayName = DisplayName;
         context.ValidationContext.MemberName = Name;
 

src/Http/Http.Abstractions/src/Validation/ValidatableTypeInfo.cs

@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.ComponentModel.DataAnnotations;
-using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 
@@ -44,12 +43,15 @@ protected ValidatableTypeInfo(
     /// <inheritdoc />
     public virtual async Task ValidateAsync(object? value, ValidateContext context, CancellationToken cancellationToken)
     {
-        Debug.Assert(context.ValidationContext is not null);
         if (value == null)
         {
             return;
         }
 
+        // Although classes can be annotated with [DisplayName], we only process display names when producing
+        // errors for properties so we can pass the `Type.Name` as the display name for the type here.
+        context.ValidationContext ??= new ValidationContext(value, displayName: Type.Name, serviceProvider: null, items: null);
+
         // Check if we've exceeded the maximum depth
         if (context.CurrentDepth >= context.ValidationOptions.MaxDepth)
         {

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

@@ -285,6 +285,60 @@ public async Task Validate_ExceptionDuringValidation_CapturesExceptionAsError()
         Assert.Equal("Test exception", error.Value.First());
     }
 
+    [Fact]
+    public async Task Validate_WithoutValidationContext_RequiredParameter_AddsErrorAndInitializesValidationContext()
+    {
+        // Arrange
+        var paramInfo = CreateTestParameterInfo(
+            parameterType: typeof(string),
+            name: "testParam",
+            displayName: "Test Parameter",
+            validationAttributes: [new RequiredAttribute()]);
+
+        // Create a ValidateContext without a pre-populated ValidationContext
+        var context = new ValidateContext
+        {
+            ValidationOptions = new TestValidationOptions(new Dictionary<Type, ValidatableTypeInfo>())
+        };
+
+        // Sanity check
+        Assert.Null(context.ValidationContext);
+
+        // Act
+        await paramInfo.ValidateAsync(null, context, default);
+
+        // Assert – a ValidationContext should have been created and the error recorded
+        Assert.NotNull(context.ValidationContext);
+        var errors = context.ValidationErrors;
+        Assert.NotNull(errors);
+        var error = Assert.Single(errors);
+        Assert.Equal("testParam", error.Key);
+        Assert.Equal("The Test Parameter field is required.", error.Value.Single());
+    }
+
+    [Fact]
+    public async Task Validate_WithoutValidationContext_ValidValue_NoErrors()
+    {
+        // Arrange
+        var paramInfo = CreateTestParameterInfo(
+            parameterType: typeof(int),
+            name: "testParam",
+            displayName: "Test Parameter",
+            validationAttributes: [new RangeAttribute(10, 100)]);
+
+        var context = new ValidateContext
+        {
+            ValidationOptions = new TestValidationOptions(new Dictionary<Type, ValidatableTypeInfo>())
+        };
+
+        // Act
+        await paramInfo.ValidateAsync(50, context, default);
+
+        // Assert – ValidationContext initialized, but no errors added
+        Assert.NotNull(context.ValidationContext);
+        Assert.Null(context.ValidationErrors);
+    }
+
     private TestValidatableParameterInfo CreateTestParameterInfo(
         Type parameterType,
         string name,

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

@@ -552,6 +552,69 @@ public async Task Validate_IValidatableObject_WithZeroAndMultipleMemberNames_Beh
             });
     }
 
+    [Fact]
+    public async Task Validate_WithoutValidationContext_AddsErrorAndInitializesValidationContext()
+    {
+        // Arrange
+        var personType = new TestValidatableTypeInfo(
+            typeof(Person),
+            [
+                // Only the Name property is required for this test
+                CreatePropertyInfo(typeof(Person), typeof(string), "Name", "Name",
+                    [new RequiredAttribute()])
+            ]);
+
+        var context = new ValidateContext
+        {
+            ValidationOptions = new TestValidationOptions(new Dictionary<Type, ValidatableTypeInfo>
+            {
+                { typeof(Person), personType }
+            })
+        };
+
+        var person = new Person(); // Name is null → fails validation
+        Assert.Null(context.ValidationContext); // ensure no ValidationContext pre-set
+
+        // Act
+        await personType.ValidateAsync(person, context, default);
+
+        // Assert
+        Assert.NotNull(context.ValidationContext);
+        Assert.NotNull(context.ValidationErrors);
+        var error = Assert.Single(context.ValidationErrors);
+        Assert.Equal("Name", error.Key);
+        Assert.Equal("The Name field is required.", error.Value.First());
+    }
+
+    [Fact]
+    public async Task Validate_WithoutValidationContext_ValidObject_NoErrors()
+    {
+        // Arrange
+        var personType = new TestValidatableTypeInfo(
+            typeof(Person),
+            [
+                CreatePropertyInfo(typeof(Person), typeof(string), "Name", "Name",
+                    [new RequiredAttribute()])
+            ]);
+
+        var context = new ValidateContext
+        {
+            ValidationOptions = new TestValidationOptions(new Dictionary<Type, ValidatableTypeInfo>
+            {
+                { typeof(Person), personType }
+            })
+        };
+
+        var person = new Person { Name = "Alice" };
+
+        // Act
+        await personType.ValidateAsync(person, context, default);
+
+        // Assert
+        Assert.NotNull(context.ValidationContext);
+        Assert.Null(context.ValidationErrors);
+    }
+
     // Returns no member names to validate https://github.com/dotnet/aspnetcore/issues/61739
     private class GlobalErrorObject : IValidatableObject
     {