Verify MVC / Razor Pages support for unions

src/Mvc/test/Mvc.FunctionalTests/RazorPagesUnionsTest.cs

@@ -0,0 +1,63 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Net;
+using System.Net.Http;
+using System.Reflection;
+using System.Text;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.InternalTesting;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Xunit.Abstractions;
+
+namespace Microsoft.AspNetCore.Mvc.FunctionalTests;
+
+// Verifies that C# union types flow through the Razor Pages handler pipeline. The
+// underlying JSON formatters are the same SystemTextJsonInputFormatter /
+// SystemTextJsonOutputFormatter that MVC controllers use — this test class exists as a
+// smoke test that confirms Razor Pages model binding for [FromBody] union parameters
+// and IActionResult JsonResult responses behave the same way for unions.
+public class RazorPagesUnionsTest : LoggedTest
+{
+    private static void ConfigureWebHostBuilder(IWebHostBuilder builder) =>
+        builder.UseStartup<RazorPagesWebSite.Startup>();
+
+    protected override void Initialize(TestContext context, MethodInfo methodInfo, object[] testMethodArguments, ITestOutputHelper testOutputHelper)
+    {
+        base.Initialize(context, methodInfo, testMethodArguments, testOutputHelper);
+        Factory = new MvcTestFixture<RazorPagesWebSite.Startup>(LoggerFactory).WithWebHostBuilder(ConfigureWebHostBuilder);
+        Client = Factory.CreateDefaultClient();
+    }
+
+    public override void Dispose()
+    {
+        Factory.Dispose();
+        base.Dispose();
+    }
+
+    public WebApplicationFactory<RazorPagesWebSite.Startup> Factory { get; private set; }
+    public HttpClient Client { get; private set; }
+
+    [Fact]
+    public async Task RazorPage_UnionReturnType_SerializesActiveCase()
+    {
+        var response = await Client.GetAsync("/Unions");
+
+        await response.AssertStatusCodeAsync(HttpStatusCode.OK);
+        Assert.Equal("true", await response.Content.ReadAsStringAsync());
+    }
+
+    [Theory]
+    [InlineData("true", "true")]
+    [InlineData("false", "false")]
+    [InlineData("\"hi\"", "\"hi\"")]
+    public async Task RazorPage_UnionFromBody_RoundTripsUnambiguousPrimitiveCases(string payload, string expectedBody)
+    {
+        var content = new StringContent(payload, Encoding.UTF8, "application/json");
+
+        var response = await Client.PostAsync("/Unions", content);
+
+        await response.AssertStatusCodeAsync(HttpStatusCode.OK);
+        Assert.Equal(expectedBody, await response.Content.ReadAsStringAsync());
+    }
+}

src/Mvc/test/Mvc.FunctionalTests/SystemTextJsonInputFormatterTest.Unions.cs

@@ -0,0 +1,153 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Net;
+using System.Net.Http;
+using System.Text;
+
+namespace Microsoft.AspNetCore.Mvc.FunctionalTests;
+
+public partial class SystemTextJsonInputFormatterTest
+{
+    private static StringContent JsonBody(string json) => new(json, Encoding.UTF8, "application/json");
+
+    [Theory]
+    [InlineData("true", "true")]
+    [InlineData("false", "false")]
+    [InlineData("\"hi\"", "\"hi\"")]
+    public async Task Union_Body_UnambiguousPrimitiveCases_RoundTrip(string payload, string expectedBody)
+    {
+        var response = await Client.PostAsync("/Unions/EchoBoolString", JsonBody(payload));
+        await response.AssertStatusCodeAsync(HttpStatusCode.OK);
+        Assert.Equal(expectedBody, await response.Content.ReadAsStringAsync());
+    }
+
+    [Fact]
+    public async Task Union_Body_AmbiguousPrimitiveCase_WithoutClassifier_ReturnsBadRequest()
+    {
+        var response = await Client.PostAsync("/Unions/EchoIntString", JsonBody("\"hi\""));
+        await response.AssertStatusCodeAsync(HttpStatusCode.BadRequest);
+    }
+
+    [Theory]
+    [InlineData("42", "42")]
+    [InlineData("\"hi\"", "\"hi\"")]
+    public async Task Union_Body_AmbiguousPrimitiveCase_WithClassifier_RoundTrips(string payload, string expectedBody)
+    {
+        var response = await Client.PostAsync("/Unions/EchoIntStringWithClassifier", JsonBody(payload));
+        await response.AssertStatusCodeAsync(HttpStatusCode.OK);
+        Assert.Equal(expectedBody, await response.Content.ReadAsStringAsync());
+    }
+
+    [Fact]
+    public async Task Union_Body_AmbiguousNumericUnion_WithoutClassifier_ReturnsBadRequest()
+    {
+        var response = await Client.PostAsync("/Unions/EchoIntShort", JsonBody("42"));
+        await response.AssertStatusCodeAsync(HttpStatusCode.BadRequest);
+    }
+
+    [Fact]
+    public async Task Union_Body_AmbiguousNumericUnion_WithClassifier_RoundTrips()
+    {
+        var response = await Client.PostAsync("/Unions/EchoIntShortWithClassifier", JsonBody("42"));
+        await response.AssertStatusCodeAsync(HttpStatusCode.OK);
+        Assert.Equal("42", await response.Content.ReadAsStringAsync());
+    }
+
+    [Fact]
+    public async Task Union_Body_UnionWithNullableCase_NumberTokenWorksWithoutClassifier()
+    {
+        var response = await Client.PostAsync("/Unions/EchoNullableIntString", JsonBody("42"));
+        await response.AssertStatusCodeAsync(HttpStatusCode.OK);
+        Assert.Equal("42", await response.Content.ReadAsStringAsync());
+    }
+
+    [Fact]
+    public async Task Union_Body_UnionWithNullableCase_StringTokenAmbiguousWithoutClassifier_ReturnsBadRequest()
+    {
+        var response = await Client.PostAsync("/Unions/EchoNullableIntString", JsonBody("\"hi\""));
+        await response.AssertStatusCodeAsync(HttpStatusCode.BadRequest);
+    }
+
+    [Theory]
+    [InlineData("42", "42")]
+    [InlineData("\"hi\"", "\"hi\"")]
+    [InlineData("null", "null")]
+    public async Task Union_Body_UnionWithNullableCase_WithClassifier_RoundTrips(string payload, string expectedBody)
+    {
+        var response = await Client.PostAsync("/Unions/EchoNullableIntStringWithClassifier", JsonBody(payload));
+
+        await response.AssertStatusCodeAsync(HttpStatusCode.OK);
+        Assert.Equal(expectedBody, await response.Content.ReadAsStringAsync());
+    }
+
+    [Fact]
+    public async Task Union_Body_UnionWithNullableCase_NullPayloadWorksWithoutClassifier()
+    {
+        // Null tokens are short-circuited in the union converter before the classifier
+        // runs, so JSON null round-trips even when no classifier is registered.
+        var response = await Client.PostAsync("/Unions/EchoNullableIntString", JsonBody("null"));
+
+        await response.AssertStatusCodeAsync(HttpStatusCode.OK);
+        Assert.Equal("null", await response.Content.ReadAsStringAsync());
+    }
+
+    [Theory]
+    [InlineData("{\"name\":\"Whiskers\"}")]
+    [InlineData("{\"breed\":\"Labrador\"}")]
+    public async Task Union_Body_ObjectCaseUnion_WithoutClassifier_ReturnsBadRequest(string payload)
+    {
+        var response = await Client.PostAsync("/Unions/EchoPet", JsonBody(payload));
+        await response.AssertStatusCodeAsync(HttpStatusCode.BadRequest);
+    }
+
+    [Theory]
+    [InlineData("{\"name\":\"Whiskers\"}", "{\"name\":\"Whiskers\"}")]
+    [InlineData("{\"breed\":\"Labrador\"}", "{\"breed\":\"Labrador\"}")]
+    public async Task Union_Body_ObjectCaseUnion_WithClassifier_RoundTrips(string payload, string expectedBody)
+    {
+        var response = await Client.PostAsync("/Unions/EchoPetWithClassifier", JsonBody(payload));
+        await response.AssertStatusCodeAsync(HttpStatusCode.OK);
+        Assert.Equal(expectedBody, await response.Content.ReadAsStringAsync());
+    }
+
+    [Fact]
+    public async Task Union_Body_AsPropertyOfWrappingRecord_NumberPayload_RoundTrips()
+    {
+        const string payload = "{\"correlationId\":\"abc\",\"payload\":42}";
+        var response = await Client.PostAsync("/Unions/EchoEnvelope", JsonBody(payload));
+        await response.AssertStatusCodeAsync(HttpStatusCode.OK);
+        Assert.Equal(payload, await response.Content.ReadAsStringAsync());
+    }
+
+    [Theory]
+    [InlineData("{\"correlationId\":\"abc\",\"payload\":null}")]
+    [InlineData("{\"correlationId\":\"abc\"}")]
+    public async Task Union_Body_AsPropertyOfWrappingRecord_NullOrMissingPayload_RoundTripsAsNull(string payload)
+    {
+        var response = await Client.PostAsync("/Unions/EchoEnvelope", JsonBody(payload));
+        await response.AssertStatusCodeAsync(HttpStatusCode.OK);
+        Assert.Equal("{\"correlationId\":\"abc\",\"payload\":null}", await response.Content.ReadAsStringAsync());
+    }
+
+    [Fact]
+    public async Task Union_Body_ExplicitFromBodyAndImplicitBody_BehaveTheSame()
+    {
+        var explicitResponse = await Client.PostAsync("/Unions/EchoIntString", JsonBody("42"));
+        var implicitResponse = await Client.PostAsync("/Unions/EchoIntStringImplicit", JsonBody("42"));
+
+        await explicitResponse.AssertStatusCodeAsync(HttpStatusCode.OK);
+        await implicitResponse.AssertStatusCodeAsync(HttpStatusCode.OK);
+        Assert.Equal("42", await explicitResponse.Content.ReadAsStringAsync());
+        Assert.Equal("42", await implicitResponse.Content.ReadAsStringAsync());
+    }
+
+    [Fact]
+    public async Task Union_Body_NonJsonContentType_Returns415UnsupportedMediaType()
+    {
+        var content = new StringContent("42", Encoding.UTF8, "text/plain");
+        var response = await Client.PostAsync("/Unions/EchoIntString", content);
+
+        await response.AssertStatusCodeAsync(HttpStatusCode.UnsupportedMediaType);
+    }
+}

src/Mvc/test/Mvc.FunctionalTests/SystemTextJsonInputFormatterTest.cs

@@ -3,7 +3,7 @@
 
 namespace Microsoft.AspNetCore.Mvc.FunctionalTests;
 
-public class SystemTextJsonInputFormatterTest : JsonInputFormatterTestBase<FormatterWebSite.StartupWithJsonFormatter>
+public partial class SystemTextJsonInputFormatterTest : JsonInputFormatterTestBase<FormatterWebSite.StartupWithJsonFormatter>
 {
     [Fact(Skip = "https://github.com/dotnet/runtime/issues/38539")]
     public override Task JsonInputFormatter_RoundtripsRecordType()

src/Mvc/test/Mvc.FunctionalTests/SystemTextJsonOutputFormatterTest.Unions.cs

@@ -0,0 +1,103 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Net;
+using System.Net.Http;
+using System.Text;
+
+namespace Microsoft.AspNetCore.Mvc.FunctionalTests;
+
+public partial class SystemTextJsonOutputFormatterTest
+{
+    [Theory]
+    [InlineData("PrimitiveByteString", "value", "42")]
+    [InlineData("PrimitiveByteString", "string", "\"hi\"")]
+    [InlineData("PrimitiveShortString", "value", "1234")]
+    [InlineData("PrimitiveShortString", "string", "\"hi\"")]
+    [InlineData("PrimitiveIntString", "value", "42")]
+    [InlineData("PrimitiveIntString", "string", "\"hi\"")]
+    [InlineData("PrimitiveLongString", "value", "9999999999")]
+    [InlineData("PrimitiveLongString", "string", "\"hi\"")]
+    [InlineData("PrimitiveDecimalString", "value", "3.14")]
+    [InlineData("PrimitiveDecimalString", "string", "\"hi\"")]
+    [InlineData("PrimitiveDoubleString", "value", "2.5")]
+    [InlineData("PrimitiveDoubleString", "string", "\"hi\"")]
+    [InlineData("PrimitiveBoolString", "value", "true")]
+    [InlineData("PrimitiveBoolString", "string", "\"hi\"")]
+    [InlineData("PrimitiveGuidInt", "value", "\"00000000-0000-0000-0000-000000000001\"")]
+    [InlineData("PrimitiveGuidInt", "int", "42")]
+    [InlineData("PrimitiveDateTimeInt", "value", "\"2024-05-28T10:00:00\"")]
+    [InlineData("PrimitiveDateTimeInt", "int", "42")]
+    [InlineData("PrimitiveCharInt", "value", "\"x\"")]
+    [InlineData("PrimitiveCharInt", "int", "42")]
+    public async Task Union_ReturnType_PrimitiveCases_SerializeActiveCase(string action, string kind, string expectedBody)
+    {
+        var response = await Client.GetAsync($"/Unions/{action}/{kind}");
+
+        await response.AssertStatusCodeAsync(HttpStatusCode.OK);
+        Assert.Equal(expectedBody, await response.Content.ReadAsStringAsync());
+    }
+
+    [Theory]
+    [InlineData("AsyncTask")]
+    [InlineData("AsyncValueTask")]
+    public async Task Union_ReturnType_TaskAndValueTask_SerializeActiveCase(string action)
+    {
+        var response = await Client.GetAsync($"/Unions/{action}");
+        await response.AssertStatusCodeAsync(HttpStatusCode.OK);
+        Assert.Equal("42", await response.Content.ReadAsStringAsync());
+    }
+
+    [Theory]
+    [InlineData("value", HttpStatusCode.OK, "42")]
+    [InlineData("null", HttpStatusCode.NoContent, "")]
+    public async Task Union_ReturnType_NullableWrapper_HandlesValueAndNull(string kind, HttpStatusCode expectedStatus, string expectedBody)
+    {
+        var response = await Client.GetAsync($"/Unions/NullableWrapper/{kind}");
+        await response.AssertStatusCodeAsync(expectedStatus);
+        Assert.Equal(expectedBody, await response.Content.ReadAsStringAsync());
+    }
+
+    [Theory]
+    [InlineData("int", "5")]
+    [InlineData("string", "\"hi\"")]
+    [InlineData("null", "null")]
+    public async Task Union_ReturnType_UnionWithNullableCase_SerializesActiveCase(string kind, string expectedBody)
+    {
+        var response = await Client.GetAsync($"/Unions/UnionWithNullableCase/{kind}");
+
+        await response.AssertStatusCodeAsync(HttpStatusCode.OK);
+        Assert.Equal(expectedBody, await response.Content.ReadAsStringAsync());
+    }
+
+    [Theory]
+    [InlineData("cat", "{\"name\":\"Whiskers\"}")]
+    [InlineData("dog", "{\"breed\":\"Labrador\"}")]
+    public async Task Union_ReturnType_ObjectCase_SerializesActiveCase(string kind, string expectedBody)
+    {
+        var response = await Client.GetAsync($"/Unions/ObjectCase/{kind}");
+        await response.AssertStatusCodeAsync(HttpStatusCode.OK);
+        Assert.Equal(expectedBody, await response.Content.ReadAsStringAsync());
+    }
+
+    [Theory]
+    [InlineData("int", "42")]
+    [InlineData("string", "\"nested\"")]
+    [InlineData("bool", "true")]
+    public async Task Union_ReturnType_NestedUnion_SerializesInnermostCase(string kind, string expectedBody)
+    {
+        var response = await Client.GetAsync($"/Unions/Nested/{kind}");
+        await response.AssertStatusCodeAsync(HttpStatusCode.OK);
+        Assert.Equal(expectedBody, await response.Content.ReadAsStringAsync());
+    }
+
+    [Theory]
+    [InlineData("int", "{\"correlationId\":\"abc\",\"payload\":42}")]
+    [InlineData("string", "{\"correlationId\":\"abc\",\"payload\":\"hi\"}")]
+    public async Task Union_ReturnType_AsPropertyOfWrappingRecord_SerializesActiveCase(string kind, string expectedBody)
+    {
+        var response = await Client.GetAsync($"/Unions/Envelope/{kind}");
+        await response.AssertStatusCodeAsync(HttpStatusCode.OK);
+        Assert.Equal(expectedBody, await response.Content.ReadAsStringAsync());
+    }
+}

src/Mvc/test/Mvc.FunctionalTests/SystemTextJsonOutputFormatterTest.cs

@@ -8,7 +8,7 @@
 
 namespace Microsoft.AspNetCore.Mvc.FunctionalTests;
 
-public class SystemTextJsonOutputFormatterTest : JsonOutputFormatterTestBase<FormatterWebSite.StartupWithJsonFormatter>
+public partial class SystemTextJsonOutputFormatterTest : JsonOutputFormatterTestBase<FormatterWebSite.StartupWithJsonFormatter>
 {
     [Fact]
     public override Task SerializableErrorIsReturnedInExpectedFormat() => base.SerializableErrorIsReturnedInExpectedFormat();