Adding/Updating tests

Author: brunolins16

src/Mvc/Mvc.Core/test/ModelBinding/Metadata/NullableEmptyBodyBindingMetadataProviderTest.cs

@@ -0,0 +1,110 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+using System.Reflection;
+
+namespace Microsoft.AspNetCore.Mvc.ModelBinding.Metadata;
+
+#nullable enable
+public class NullableEmptyBodyBindingMetadataProviderTest
+{
+    [Fact]
+    public void IsEmptyBodyAllowed_LeftAlone_WhenAlreadySet()
+    {
+        // Arrange
+        var provider = new NullableEmptyBodyBindingMetadataProvider();
+
+        var context = new BindingMetadataProviderContext(
+          ModelMetadataIdentity.ForParameter(ParameterInfos.NullableParameter),
+          new ModelAttributes(Array.Empty<object>()));
+
+        context.BindingMetadata.IsEmptyBodyAllowed = false;
+
+        // Act
+        provider.CreateBindingMetadata(context);
+
+        // Assert
+        Assert.False(context.BindingMetadata.IsEmptyBodyAllowed);
+    }
+
+    [Fact]
+    public void IsEmptyBodyAllowed_LeftAlone_WhenNotOptional()
+    {
+        // Arrange
+        var provider = new NullableEmptyBodyBindingMetadataProvider();
+
+        var context = new BindingMetadataProviderContext(
+          ModelMetadataIdentity.ForParameter(ParameterInfos.NonNullableParameter),
+          new ModelAttributes(Array.Empty<object>()));
+
+        // Act
+        provider.CreateBindingMetadata(context);
+
+        // Assert
+        Assert.Null(context.BindingMetadata.IsEmptyBodyAllowed);
+    }
+
+
+    [Fact]
+    public void IsEmptyBodyAllowed_IsTrue_WhenDefaultValue()
+    {
+        // Arrange
+        var provider = new NullableEmptyBodyBindingMetadataProvider();
+
+        var context = new BindingMetadataProviderContext(
+          ModelMetadataIdentity.ForParameter(ParameterInfos.ParameterWithDefaultValue),
+          new ModelAttributes(Array.Empty<object>()));
+
+        // Act
+        provider.CreateBindingMetadata(context);
+
+        // Assert
+        Assert.True(context.BindingMetadata.IsEmptyBodyAllowed);
+
+    }
+
+    [Fact]
+    public void IsEmptyBodyAllowed_IsTrue_WhenNullable()
+    {
+        // Arrange
+        var provider = new NullableEmptyBodyBindingMetadataProvider();
+
+        var context = new BindingMetadataProviderContext(
+          ModelMetadataIdentity.ForParameter(ParameterInfos.NullableParameter),
+          new ModelAttributes(Array.Empty<object>()));
+
+        // Act
+        provider.CreateBindingMetadata(context);
+
+        // Assert
+        Assert.True(context.BindingMetadata.IsEmptyBodyAllowed);
+
+    }
+
+    private class ParameterInfos
+    {
+        public void Method(object param1, object? param2)
+        {
+        }
+
+#nullable disable
+        public void Method2(object param1 = null)
+        {
+        }
+#nullable restore
+
+        public static ParameterInfo NonNullableParameter
+            = typeof(ParameterInfos)!
+                .GetMethod(nameof(ParameterInfos.Method))!
+                .GetParameters()[0];
+
+        public static ParameterInfo NullableParameter
+             = typeof(ParameterInfos)!
+                .GetMethod(nameof(ParameterInfos.Method))!
+                .GetParameters()[1];
+
+        public static ParameterInfo ParameterWithDefaultValue
+            = typeof(ParameterInfos)!
+                .GetMethod(nameof(ParameterInfos.Method2))!
+                .GetParameters()[0];
+    }
+}

src/Mvc/test/Mvc.FunctionalTests/InputFormatterTests.cs

@@ -209,6 +209,26 @@ public async Task OptionalFromBodyWorks()
         await response.AssertStatusCodeAsync(HttpStatusCode.OK);
     }
 
+    [Fact]
+    public async Task OptionalFromBodyWorks_WithDefaultValue()
+    {
+        // Act
+        var response = await Client.PostAsJsonAsync<object>($"Home/{nameof(HomeController.DefaultValueBody)}", value: null);
+
+        // Assert
+        await response.AssertStatusCodeAsync(HttpStatusCode.OK);
+    }
+
+    [Fact]
+    public async Task OptionalFromBodyWorks_WithNullable()
+    {
+        // Act
+        var response = await Client.PostAsJsonAsync<object>($"Home/{nameof(HomeController.NullableBody)}", value: null);
+
+        // Assert
+        await response.AssertStatusCodeAsync(HttpStatusCode.OK);
+    }
+
     [Fact]
     public async Task OptionalFromBodyWorksWithEmptyRequest()
     {
@@ -223,4 +243,34 @@ public async Task OptionalFromBodyWorksWithEmptyRequest()
         // Assert
         await response.AssertStatusCodeAsync(HttpStatusCode.OK);
     }
+
+    [Fact]
+    public async Task OptionalFromBodyWorksWithEmptyRequest_WithDefaultValue()
+    {
+        // Arrange
+        var content = new ByteArrayContent(Array.Empty<byte>());
+        Assert.Null(content.Headers.ContentType);
+        Assert.Equal(0, content.Headers.ContentLength);
+
+        // Act
+        var response = await Client.PostAsync($"Home/{nameof(HomeController.DefaultValueBody)}", content);
+
+        // Assert
+        await response.AssertStatusCodeAsync(HttpStatusCode.OK);
+    }
+
+    [Fact]
+    public async Task OptionalFromBodyWorksWithEmptyRequest_WithNullable()
+    {
+        // Arrange
+        var content = new ByteArrayContent(Array.Empty<byte>());
+        Assert.Null(content.Headers.ContentType);
+        Assert.Equal(0, content.Headers.ContentLength);
+
+        // Act
+        var response = await Client.PostAsync($"Home/{nameof(HomeController.NullableBody)}", content);
+
+        // Assert
+        await response.AssertStatusCodeAsync(HttpStatusCode.OK);
+    }
 }

src/Mvc/test/WebSites/FormatterWebSite/Controllers/HomeController.cs

@@ -44,4 +44,14 @@ public IActionResult DefaultBody([FromBody] DummyClass dummy)
     [HttpPost]
     public IActionResult OptionalBody([FromBody(EmptyBodyBehavior = EmptyBodyBehavior.Allow)] DummyClass dummy)
         => ModelState.IsValid ? Ok() : ValidationProblem();
+
+    [HttpPost]
+    public IActionResult DefaultValueBody([FromBody] DummyClass dummy = null)
+        => ModelState.IsValid ? Ok() : ValidationProblem();
+
+#nullable enable
+    [HttpPost]
+    public IActionResult NullableBody([FromBody] DummyClass? dummy)
+        => ModelState.IsValid ? Ok() : ValidationProblem();
+#nullable restore
 }