Add test case, reuse ImplementsInterface method

Author: oroztocil

src/Validation/gen/Parsers/ValidationsGenerator.TypesParser.cs

@@ -305,15 +305,6 @@ internal static bool HasValidationAttributes(ISymbol symbol, WellKnownTypes well
     internal static bool HasIValidatableObjectInterface(ITypeSymbol typeSymbol, WellKnownTypes wellKnownTypes)
     {
         var validatableObjectSymbol = wellKnownTypes.Get(WellKnownTypeData.WellKnownType.System_ComponentModel_DataAnnotations_IValidatableObject);
-
-        foreach (var inter in typeSymbol.AllInterfaces)
-        {
-            if (SymbolEqualityComparer.Default.Equals(inter, validatableObjectSymbol))
-            {
-                return true;
-            }
-        }
-
-        return false;
+        return typeSymbol.ImplementsInterface(validatableObjectSymbol);
     }
 }

src/Validation/test/Microsoft.Extensions.Validation.GeneratorTests/ValidationsGenerator.IValidatableObject.cs

@@ -187,6 +187,7 @@ public async Task CanValidateIValidatableObject_WithoutPropertyValidations()
 
 app.MapPost("/base", (BaseClass model) => Results.Ok(model));
 app.MapPost("/derived", (DerivedClass model) => Results.Ok(model));
+app.MapPost("/complex", (ComplexClass model) => Results.Ok(model));
 
 app.Run();
 
@@ -206,6 +207,23 @@ public IEnumerable<ValidationResult> Validate(ValidationContext validationContex
 public class DerivedClass : BaseClass
 {
 }
+
+public class ComplexClass
+{
+    public NestedClass? NestedObject { get; set; }
+}
+
+public class NestedClass : IValidatableObject
+{
+    public string? Value { get; set; }
+    public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+    {
+        if (string.IsNullOrEmpty(Value))
+        {
+            yield return new ValidationResult("Value cannot be null or empty.", [nameof(Value)]);
+        }
+    }
+}
 """;
 
         await Verify(source, out var compilation);
@@ -259,6 +277,32 @@ async Task ValidateMethodCalled()
                     });
             }
         });
-    }
 
+        await VerifyEndpoint(compilation, "/complex", async (endpoint, serviceProvider) =>
+        {
+            await ValidateMethodCalled();
+
+            async Task ValidateMethodCalled()
+            {
+                var httpContext = CreateHttpContextWithPayload("""
+                {
+                    "NestedObject": {
+                        "Value": ""
+                    }
+                }
+                """, serviceProvider);
+
+                await endpoint.RequestDelegate(httpContext);
+
+                var problemDetails = await AssertBadRequest(httpContext);
+                Assert.Collection(problemDetails.Errors,
+                    error =>
+                    {
+                        Assert.Equal("NestedObject.Value", error.Key);
+                        Assert.Collection(error.Value,
+                            msg => Assert.Equal("Value cannot be null or empty.", msg));
+                    });
+            }
+        });
+    }
 }

src/Validation/test/Microsoft.Extensions.Validation.GeneratorTests/snapshots/ValidationsGeneratorTests.CanValidateIValidatableObject_WithoutPropertyValidations#ValidatableInfoResolver.g.verified.cs

@@ -87,6 +87,29 @@ public bool TryGetValidatableTypeInfo(global::System.Type type, [global::System.
                 );
                 return true;
             }
+            if (type == typeof(global::NestedClass))
+            {
+                validatableInfo = new GeneratedValidatableTypeInfo(
+                    type: typeof(global::NestedClass),
+                    members: []
+                );
+                return true;
+            }
+            if (type == typeof(global::ComplexClass))
+            {
+                validatableInfo = new GeneratedValidatableTypeInfo(
+                    type: typeof(global::ComplexClass),
+                    members: [
+                        new GeneratedValidatablePropertyInfo(
+                            containingType: typeof(global::ComplexClass),
+                            propertyType: typeof(global::NestedClass),
+                            name: "NestedObject",
+                            displayName: "NestedObject"
+                        ),
+                    ]
+                );
+                return true;
+            }
 
             return false;
         }