MvcControllerIntegrationValidationTest.cs

using System.ComponentModel.DataAnnotations;
using System.Net;
using System.Net.Http.Json;
using System.Text;

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

using OptionalValues.DataAnnotations;
using Shouldly;

namespace OptionalValues.Mvc.Tests;

public class MvcControllerIntegrationValidationTest : IAsyncLifetime
{
    private WebApplication? _app;
    private HttpClient? _client;

    public async Task InitializeAsync()
    {
        var builder = WebApplication.CreateBuilder();

        builder.Services.AddControllers(options => options.AddOptionalValueSupport())
            .AddApplicationPart(typeof(ValidationController).Assembly)
            .AddJsonOptions(options => options.JsonSerializerOptions.AddOptionalValueSupport());

        builder.WebHost.UseTestServer();

        _app = builder.Build();
        _app.MapControllers();

        await _app.StartAsync();
        _client = _app.GetTestClient();
    }

    public async Task DisposeAsync()
    {
        if (_app != null)
        {
            await _app.DisposeAsync();
        }

        _client?.Dispose();
    }

    [Fact]
    public async Task UnspecifiedOptionalValue_ShouldPass_ControllerValidation()
    {
        var content = new StringContent(
            """{"specifiedName":null,"requiredName":"valid"}""",
            Encoding.UTF8,
            "application/json");

        HttpResponseMessage response = await _client!.PostAsync("/validation", content);

        response.StatusCode.ShouldBe(HttpStatusCode.OK);
    }

    [Fact]
    public async Task SpecifiedOptionalValue_ShouldPass_ControllerValidation()
    {
        var content = new StringContent(
            """{"name":"short","specifiedName":null,"requiredName":"valid","child":{"value":"valid","nested":{"grandchild":{"value":"valid"}}}}""",
            Encoding.UTF8,
            "application/json");

        HttpResponseMessage response = await _client!.PostAsync("/validation", content);

        response.StatusCode.ShouldBe(HttpStatusCode.OK);
    }

    [Fact]
    public async Task InvalidOptionalValueDataAnnotations_ShouldFail_ControllerValidation()
    {
        var content = new StringContent("""{"name":"toolong"}""", Encoding.UTF8, "application/json");

        HttpResponseMessage response = await _client!.PostAsync("/validation", content);

        response.StatusCode.ShouldBe(HttpStatusCode.BadRequest);

        HttpValidationProblemDetails? problemDetails =
            await response.Content.ReadFromJsonAsync<HttpValidationProblemDetails>();

        problemDetails.ShouldNotBeNull();
        problemDetails.Errors.ShouldContainKey(nameof(MvcControllerValidationRequestModel.Name));
    }

    [Fact]
    public async Task SpecifiedAndRequiredValueAttributes_ShouldFail_ControllerValidation_WhenUnspecified()
    {
        var content = new StringContent("""{"name":"short"}""", Encoding.UTF8, "application/json");

        HttpResponseMessage response = await _client!.PostAsync("/validation", content);

        response.StatusCode.ShouldBe(HttpStatusCode.BadRequest);

        HttpValidationProblemDetails? problemDetails =
            await response.Content.ReadFromJsonAsync<HttpValidationProblemDetails>();

        problemDetails.ShouldNotBeNull();
        problemDetails.Errors.ShouldContainKey(nameof(MvcControllerValidationRequestModel.SpecifiedName));
        problemDetails.Errors.ShouldContainKey(nameof(MvcControllerValidationRequestModel.RequiredName));
    }

    [Fact]
    public async Task RequiredValueAttribute_ShouldFail_ControllerValidation_WhenValueIsNull()
    {
        var content = new StringContent(
            """{"name":"short","specifiedName":null,"requiredName":null}""",
            Encoding.UTF8,
            "application/json");

        HttpResponseMessage response = await _client!.PostAsync("/validation", content);

        response.StatusCode.ShouldBe(HttpStatusCode.BadRequest);

        HttpValidationProblemDetails? problemDetails =
            await response.Content.ReadFromJsonAsync<HttpValidationProblemDetails>();

        problemDetails.ShouldNotBeNull();
        problemDetails.Errors.ShouldNotContainKey(nameof(MvcControllerValidationRequestModel.SpecifiedName));
        problemDetails.Errors.ShouldContainKey(nameof(MvcControllerValidationRequestModel.RequiredName));
    }

    [Fact]
    public async Task InvalidChildDataAnnotations_ShouldFail_ControllerValidation()
    {
        var content = new StringContent("""{"child":{"value":"toolong"}}""", Encoding.UTF8, "application/json");

        HttpResponseMessage response = await _client!.PostAsync("/validation", content);

        response.StatusCode.ShouldBe(HttpStatusCode.BadRequest);

        HttpValidationProblemDetails? problemDetails =
            await response.Content.ReadFromJsonAsync<HttpValidationProblemDetails>();

        problemDetails.ShouldNotBeNull();
        problemDetails.Errors.ShouldContainKey($"{nameof(MvcControllerValidationRequestModel.Child)}.{nameof(MvcControllerValidationChildModel.Value)}");
    }

    [Fact]
    public async Task InvalidNestedChildDataAnnotations_ShouldFail_ControllerValidation()
    {
        var content = new StringContent(
            """{"child":{"value":"valid","nested":{"grandchild":{"value":"toolong"}}}}""",
            Encoding.UTF8,
            "application/json");

        HttpResponseMessage response = await _client!.PostAsync("/validation", content);

        response.StatusCode.ShouldBe(HttpStatusCode.BadRequest);

        HttpValidationProblemDetails? problemDetails =
            await response.Content.ReadFromJsonAsync<HttpValidationProblemDetails>();

        problemDetails.ShouldNotBeNull();
        problemDetails.Errors.ShouldContainKey(
            $"{nameof(MvcControllerValidationRequestModel.Child)}.{nameof(MvcControllerValidationChildModel.Nested)}.{nameof(MvcControllerValidationNestedChildModel.Grandchild)}.{nameof(MvcControllerValidationGrandchildModel.Value)}");
    }
}

public class MvcControllerValidationRequestModel
{
    [OptionalStringLength(5)]
    public OptionalValue<string> Name { get; init; }

    [Specified]
    public OptionalValue<string?> SpecifiedName { get; init; }

    [RequiredValue]
    public OptionalValue<string?> RequiredName { get; init; }

    public OptionalValue<MvcControllerValidationChildModel> Child { get; init; }
}

public class MvcControllerValidationChildModel
{
    [StringLength(5)]
    public string? Value { get; init; }

    public MvcControllerValidationNestedChildModel? Nested { get; init; }
}

public class MvcControllerValidationNestedChildModel
{
    public MvcControllerValidationGrandchildModel? Grandchild { get; init; }
}

public class MvcControllerValidationGrandchildModel
{
    [StringLength(5)]
    public string? Value { get; init; }
}

[ApiController]
[Route("validation")]
public class ValidationController : ControllerBase
{
    [HttpPost]
    public IActionResult Post(MvcControllerValidationRequestModel model) => Ok(model);
}