Musify/backend/Tests/Musify.Api.Tests/Extensions/ErrorOrHttpExtensionsTests.cs

using ErrorOr;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Musify.Api.Extensions;
using Xunit;

namespace Musify.Api.Tests.Extensions;

public sealed class ErrorOrHttpExtensionsTests
{
    // The concrete IResult types (NoContent, UnauthorizedHttpResult, ...) resolve logging/problem-
    // details services from HttpContext.RequestServices when they execute, so it can't be empty.
    private static readonly IServiceProvider Services = new ServiceCollection().AddLogging().AddProblemDetails().BuildServiceProvider();

    private static async Task<(int StatusCode, string Body)> ExecuteAsync(IResult result)
    {
        var context = new DefaultHttpContext { RequestServices = Services };
        var bodyStream = new MemoryStream();
        context.Response.Body = bodyStream;

        await result.ExecuteAsync(context);

        bodyStream.Position = 0;
        using var reader = new StreamReader(bodyStream);
        return (context.Response.StatusCode, await reader.ReadToEndAsync());
    }

    [Fact]
    public async Task ToHttpResult_Success_ReturnsNoContent()
    {
        ErrorOr<Success> result = new Success();

        var (statusCode, _) = await ExecuteAsync(result.ToHttpResult());

        Assert.Equal(StatusCodes.Status204NoContent, statusCode);
    }

    [Fact]
    public async Task ToHttpResult_Value_ReturnsOkWithTheValue()
    {
        ErrorOr<string> result = "hello";

        var (statusCode, body) = await ExecuteAsync(result.ToHttpResult());

        Assert.Equal(StatusCodes.Status200OK, statusCode);
        Assert.Contains("hello", body);
    }

    [Fact]
    public async Task ToHttpResult_NotFoundError_ReturnsNotFound()
    {
        ErrorOr<string> result = Error.NotFound(description: "not here");

        var (statusCode, _) = await ExecuteAsync(result.ToHttpResult());

        Assert.Equal(StatusCodes.Status404NotFound, statusCode);
    }

    [Fact]
    public async Task ToHttpResult_UnauthorizedError_ReturnsUnauthorized()
    {
        ErrorOr<string> result = Error.Unauthorized();

        var (statusCode, _) = await ExecuteAsync(result.ToHttpResult());

        Assert.Equal(StatusCodes.Status401Unauthorized, statusCode);
    }

    [Fact]
    public async Task ToHttpResult_ForbiddenError_ReturnsForbidden()
    {
        ErrorOr<string> result = Error.Forbidden();

        var (statusCode, _) = await ExecuteAsync(result.ToHttpResult());

        Assert.Equal(StatusCodes.Status403Forbidden, statusCode);
    }

    [Fact]
    public async Task ToHttpResult_ConflictError_ReturnsConflict()
    {
        ErrorOr<string> result = Error.Conflict();

        var (statusCode, _) = await ExecuteAsync(result.ToHttpResult());

        Assert.Equal(StatusCodes.Status409Conflict, statusCode);
    }

    [Fact]
    public async Task ToHttpResult_FailureError_ReturnsProblem500()
    {
        ErrorOr<string> result = Error.Failure();

        var (statusCode, _) = await ExecuteAsync(result.ToHttpResult());

        Assert.Equal(StatusCodes.Status500InternalServerError, statusCode);
    }

    [Fact]
    public async Task ToHttpResult_ValidationErrors_ReturnsValidationProblem()
    {
        ErrorOr<string> result = new List<Error>
        {
            Error.Validation("Name", "Name is required"),
            Error.Validation("Name", "Name is too long"),
            Error.Validation("Age", "Age must be positive"),
        };

        var (statusCode, body) = await ExecuteAsync(result.ToHttpResult());

        Assert.Equal(StatusCodes.Status400BadRequest, statusCode);
        Assert.Contains("Name is required", body);
        Assert.Contains("Age must be positive", body);
    }

    [Fact]
    public async Task ToCreatedResult_Success_ReturnsCreatedAtTheGivenLocation()
    {
        ErrorOr<string> result = "the-id";

        var context = new DefaultHttpContext { RequestServices = Services, Response = { Body = new MemoryStream() } };
        await result.ToCreatedResult(value => $"/things/{value}").ExecuteAsync(context);

        Assert.Equal(StatusCodes.Status201Created, context.Response.StatusCode);
        Assert.Equal("/things/the-id", context.Response.Headers.Location);
    }

    [Fact]
    public async Task ToCreatedResult_Error_ReturnsTheMappedErrorStatus()
    {
        ErrorOr<string> result = Error.Conflict();

        var (statusCode, _) = await ExecuteAsync(result.ToCreatedResult(value => $"/things/{value}"));

        Assert.Equal(StatusCodes.Status409Conflict, statusCode);
    }
}