Identify the root cause: missing return in HttpContextFormValueMapper.Map

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

Author: Copilot

src/Components/Endpoints/test/Binding/FormDataMapperTests.cs

@@ -13,6 +13,7 @@
 using Microsoft.AspNetCore.Components.Forms;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.Primitives;
+using Microsoft.Extensions.Logging.Abstractions;
 
 namespace Microsoft.AspNetCore.Components.Endpoints.FormMapping;
 
@@ -1464,6 +1465,44 @@ public void CanDeserialize_ComplexRecursiveTypes_ThrowsWhenMaxRecursionDepthExce
             });
     }
 
+    [Fact]
+    public void CanDeserialize_SimpleRecursiveModel_WithOnlyNameProperty()
+    {
+        // This reproduces the issue from GitHub #61341
+        // A model with a recursive property that has no form data provided
+        var data = new Dictionary<string, StringValues>()
+        {
+            ["Name"] = "Test Name"
+            // Note: No data for Parent property
+        };
+
+        var reader = CreateFormDataReader(data, CultureInfo.InvariantCulture);
+        var options = new FormDataMapperOptions();
+
+        // Act
+        var result = FormDataMapper.Map<MyModel>(reader, options);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Equal("Test Name", result.Name);
+        Assert.Null(result.Parent);
+    }
+
+    [Fact]
+    public void ComplexTypeConverterFactory_CanConvert_RecursiveType()
+    {
+        // Test if ComplexTypeConverterFactory can convert recursive types
+        // This tests the exact scenario from GitHub issue #61341
+        var options = new FormDataMapperOptions();
+        var factory = new ComplexTypeConverterFactory(options, new NullLoggerFactory());
+
+        // Act
+        var canConvert = factory.CanConvert(typeof(MyModel), options);
+
+        // Assert
+        Assert.True(canConvert, "ComplexTypeConverterFactory should be able to convert recursive types");
+    }
+
     [Fact]
     public void CanDeserialize_ComplexRecursiveCollectionTypes_RecursiveTree()
     {
@@ -2449,6 +2488,12 @@ internal class RecursiveDictionaryTree
 
 internal record ClassRecordType(string Key, int Value);
 
+internal class MyModel
+{
+    public string Name { get; set; }
+    public MyModel Parent { get; set; }
+}
+
 internal record struct StructRecordType(string Key, int Value);
 
 internal class DataMemberAttributesType

src/Components/Endpoints/test/HttpContextFormValueMapperTest.cs

@@ -42,4 +42,26 @@ public void CanMap_MatchesOnScopeAndFormName(bool expectedResult, string incomin
         var canMap = mapper.CanMap(typeof(string), scopeName, formNameOrNull);
         Assert.Equal(expectedResult, canMap);
     }
+
+    [Fact]
+    public void CanMap_SimpleRecursiveModel_ReturnsTrue()
+    {
+        // Test that CanMap works correctly for recursive types (GitHub issue #61341)
+        var formData = new HttpContextFormDataProvider();
+        formData.SetFormData("test-form", new Dictionary<string, StringValues>
+        {
+            ["Name"] = "Test Name"
+        }, new FormFileCollection());
+
+        var mapper = new HttpContextFormValueMapper(formData, Options.Create<RazorComponentsServiceOptions>(new()));
+
+        var canMap = mapper.CanMap(typeof(MyModel), "", null);
+        Assert.True(canMap);
+    }
+}
+
+internal class MyModel
+{
+    public string Name { get; set; }
+    public MyModel Parent { get; set; }
 }

src/Components/Web/test/Forms/Mapping/SupplyParameterFromFormTest.cs

@@ -4,6 +4,7 @@
 using Microsoft.AspNetCore.Components.Forms.Mapping;
 using Microsoft.AspNetCore.Components.Test.Helpers;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.AspNetCore.Components.Endpoints.FormMapping;
 
 namespace Microsoft.AspNetCore.Components.Forms.PostHandling;
 
@@ -58,6 +59,26 @@ public async Task FindCascadingParameters_HandlesSupplyParameterFromFormValues_W
         Assert.Equal(formMappingScope, supplier.ValueSupplier);
     }
 
+    [Fact]
+    public async Task FindCascadingParameters_HandlesRecursiveModelTypes()
+    {
+        // This test reproduces GitHub issue #61341
+        // Arrange
+        var renderer = CreateRendererWithFormValueModelBinder();
+        var formComponent = new RecursiveFormParametersComponent();
+
+        // Act
+        var componentId = renderer.AssignRootComponentId(formComponent);
+        await renderer.RenderRootComponentAsync(componentId);
+        var formComponentState = renderer.GetComponentState(formComponent);
+
+        var result = CascadingParameterState.FindCascadingParameters(formComponentState, out _);
+
+        // Assert
+        var supplier = Assert.Single(result);
+        Assert.IsType<SupplyParameterFromFormValueProvider>(supplier.ValueSupplier);
+    }
+
     static TestRenderer CreateRendererWithFormValueModelBinder()
     {
         var services = new ServiceCollection();
@@ -78,6 +99,17 @@ class FormParametersComponentWithName : TestComponentBase
         [SupplyParameterFromForm(FormName = "handler-name")] public string FormParameter { get; set; }
     }
 
+    class RecursiveFormParametersComponent : TestComponentBase
+    {
+        [SupplyParameterFromForm] public MyModel FormParameter { get; set; }
+    }
+
+    class MyModel
+    {
+        public string Name { get; set; }
+        public MyModel Parent { get; set; }
+    }
+
     class TestFormModelValueBinder(string IncomingScopeQualifiedFormName = "") : IFormValueMapper
     {
         public void Map(FormValueMappingContext context) { }
@@ -95,6 +127,40 @@ public bool CanMap(Type valueType, string mappingScopeName, string formName)
         }
     }
 
+    class TestFormValueMapperWithRealBinding : IFormValueMapper
+    {
+        public void Map(FormValueMappingContext context) 
+        {
+            // Create a minimal FormDataMapperOptions to test type resolution
+            var options = new FormDataMapperOptions();
+            try
+            {
+                var converter = options.ResolveConverter(context.ValueType);
+                if (converter != null)
+                {
+                    context.SetResult(Activator.CreateInstance(context.ValueType));
+                }
+            }
+            catch
+            {
+                // If there's an exception resolving the converter, don't set result
+            }
+        }
+
+        public bool CanMap(Type valueType, string mappingScopeName, string formName)
+        {
+            try
+            {
+                var options = new FormDataMapperOptions();
+                return options.CanConvert(valueType);
+            }
+            catch
+            {
+                return false;
+            }
+        }
+    }
+
     class TestComponentBase : IComponent
     {
         public void Attach(RenderHandle renderHandle)