ersatztv/ErsatzTV.Tests/Controllers/PlayoutControllerTests.cs

using System.Reflection;
using ErsatzTV.Application.Playouts;
using ErsatzTV.Controllers.Api;
using ErsatzTV.Controllers.Api.Requests;
using ErsatzTV.Core;
using ErsatzTV.Core.Api.Playouts;
using ErsatzTV.Core.Domain;
using ErsatzTV.Core.Domain.Filler;
using ErsatzTV.Core.Errors;
using LanguageExt;
using MediatR;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Routing;
using NSubstitute;
using NUnit.Framework;
using Shouldly;
using static LanguageExt.Prelude;
using Unit = LanguageExt.Unit;

namespace ErsatzTV.Tests.Controllers;

[TestFixture]
public class PlayoutControllerTests
{
    private PlayoutController _controller = null!;
    private IMediator _mediator = null!;

    [SetUp]
    public void SetUp()
    {
        _mediator = Substitute.For<IMediator>();
        _controller = new PlayoutController(_mediator);
    }

    [Test]
    public void Controller_Should_Expose_Idiomatic_Rest_Routes()
    {
        ShouldHaveActionRoute(nameof(PlayoutController.GetAll), "GET", "/api/playouts");
        ShouldHaveActionRoute(nameof(PlayoutController.GetById), "GET", "/api/playouts/{id:int}");
        ShouldHaveActionRoute(nameof(PlayoutController.GetItems), "GET", "/api/playouts/{id:int}/items");
        ShouldHaveActionRoute(nameof(PlayoutController.GetWarningsCount), "GET", "/api/playouts/warnings/count");
        ShouldHaveActionRoute(nameof(PlayoutController.Create), "POST", "/api/playouts");
        ShouldHaveActionRoute(nameof(PlayoutController.ResetAll), "POST", "/api/playouts/reset-all");
        ShouldHaveActionRoute(nameof(PlayoutController.Delete), "DELETE", "/api/playouts/{id:int}");
    }

    [Test]
    public void Create_Should_Use_Stable_Request_Dto()
    {
        MethodInfo action = typeof(PlayoutController).GetMethod(nameof(PlayoutController.Create))
            ?? throw new AssertionException($"Missing action {nameof(PlayoutController.Create)}");

        action.GetParameters()[0].ParameterType.ShouldBe(typeof(CreatePlayoutRequest));
    }

    [Test]
    public async Task Create_Should_Return_201_With_Location_And_Body()
    {
        _mediator.Send(Arg.Any<CreateClassicPlayout>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, CreatePlayoutResponse>(new CreatePlayoutResponse(9)));
        PlayoutNameViewModel vm = MakePlayout(9);
        _mediator.Send(Arg.Any<GetPlayoutById>(), Arg.Any<CancellationToken>())
            .Returns(Option<PlayoutNameViewModel>.Some(vm));

        IActionResult result = await _controller.Create(new CreatePlayoutRequest(3, 4), CancellationToken.None);

        var created = result.ShouldBeOfType<CreatedResult>();
        created.StatusCode.ShouldBe(201);
        created.Location.ShouldBe("/api/playouts/9");
        created.Value.ShouldBe(ToResponse(vm));
    }

    [Test]
    public async Task Create_Should_Map_Request_To_Classic_Playout_Command()
    {
        _mediator.Send(Arg.Any<CreateClassicPlayout>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, CreatePlayoutResponse>(new CreatePlayoutResponse(9)));
        _mediator.Send(Arg.Any<GetPlayoutById>(), Arg.Any<CancellationToken>())
            .Returns(Option<PlayoutNameViewModel>.Some(MakePlayout(9)));

        await _controller.Create(new CreatePlayoutRequest(3, 4), CancellationToken.None);

        await _mediator.Received(1).Send(
            Arg.Is<CreateClassicPlayout>(c => c.ChannelId == 3 && c.ProgramScheduleId == 4),
            Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task Create_Should_Return_404_For_NotFoundError_With_ProblemDetails()
    {
        _mediator.Send(Arg.Any<CreateClassicPlayout>(), Arg.Any<CancellationToken>())
            .Returns(Left<BaseError, CreatePlayoutResponse>(new NotFoundError("missing")));

        IActionResult result = await _controller.Create(new CreatePlayoutRequest(404, 4), CancellationToken.None);

        var notFound = result.ShouldBeOfType<NotFoundObjectResult>();
        var problem = notFound.Value.ShouldBeOfType<ProblemDetails>();
        problem.Status.ShouldBe(404);
        problem.Title.ShouldBe("Resource not found");
    }

    [Test]
    public async Task Create_Should_Return_422_On_Validation_Error_With_ProblemDetails()
    {
        _mediator.Send(Arg.Any<CreateClassicPlayout>(), Arg.Any<CancellationToken>())
            .Returns(Left<BaseError, CreatePlayoutResponse>(BaseError.New("bad")));

        IActionResult result = await _controller.Create(new CreatePlayoutRequest(3, 4), CancellationToken.None);

        var unprocessable = result.ShouldBeOfType<UnprocessableEntityObjectResult>();
        var problem = unprocessable.Value.ShouldBeOfType<ProblemDetails>();
        problem.Status.ShouldBe(422);
        problem.Title.ShouldBe("Validation failed");
    }

    [Test]
    public async Task Delete_Should_Return_204_On_Success()
    {
        _mediator.Send(Arg.Any<DeletePlayout>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, Unit>(Unit.Default));

        IActionResult result = await _controller.Delete(9, CancellationToken.None);

        result.ShouldBeOfType<NoContentResult>();
        await _mediator.Received(1).Send(
            Arg.Is<DeletePlayout>(c => c.PlayoutId == 9),
            Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task Delete_Should_Return_404_For_NotFoundError_With_ProblemDetails()
    {
        _mediator.Send(Arg.Any<DeletePlayout>(), Arg.Any<CancellationToken>())
            .Returns(Left<BaseError, Unit>(new NotFoundError("missing")));

        IActionResult result = await _controller.Delete(404, CancellationToken.None);

        var notFound = result.ShouldBeOfType<NotFoundObjectResult>();
        var problem = notFound.Value.ShouldBeOfType<ProblemDetails>();
        problem.Status.ShouldBe(404);
        problem.Title.ShouldBe("Resource not found");
    }

    [Test]
    public async Task GetById_Should_Return_200_For_Some()
    {
        PlayoutNameViewModel vm = MakePlayout(9);
        _mediator.Send(Arg.Any<GetPlayoutById>(), Arg.Any<CancellationToken>())
            .Returns(Option<PlayoutNameViewModel>.Some(vm));

        IActionResult result = await _controller.GetById(9, CancellationToken.None);

        result.ShouldBeOfType<OkObjectResult>().Value.ShouldBe(ToResponse(vm));
    }

    [Test]
    public async Task GetById_Should_Return_404_For_None_With_ProblemDetails()
    {
        _mediator.Send(Arg.Any<GetPlayoutById>(), Arg.Any<CancellationToken>())
            .Returns(Option<PlayoutNameViewModel>.None);

        IActionResult result = await _controller.GetById(9, CancellationToken.None);

        var notFound = result.ShouldBeOfType<NotFoundObjectResult>();
        var problem = notFound.Value.ShouldBeOfType<ProblemDetails>();
        problem.Status.ShouldBe(404);
        problem.Title.ShouldBe("Resource not found");
    }

    [Test]
    public async Task GetAll_Should_Project_Paged_List_With_BuildStatus()
    {
        var buildStatus = new PlayoutBuildStatus
        {
            LastBuild = new DateTimeOffset(2026, 7, 2, 10, 0, 0, TimeSpan.Zero),
            Success = false,
            Message = "boom"
        };
        PlayoutNameViewModel vm = MakePlayout(9) with
        {
            BuildStatus = buildStatus,
            DbDailyRebuildTime = TimeSpan.FromHours(4)
        };
        _mediator.Send(Arg.Any<GetPagedPlayouts>(), Arg.Any<CancellationToken>())
            .Returns(new PagedPlayoutsViewModel(1, [vm]));

        PagedPlayoutsResponseModel result = await _controller.GetAll("q", 2, 25, CancellationToken.None);

        result.TotalCount.ShouldBe(1);
        PlayoutListItemResponseModel item = result.Page.Single();
        item.Id.ShouldBe(9);
        item.ChannelNumber.ShouldBe("101");
        item.ChannelName.ShouldBe("Channel");
        item.ScheduleKind.ShouldBe(PlayoutScheduleKind.Classic);
        item.ScheduleName.ShouldBe("Schedule");
        item.DailyRebuildTime.ShouldBe(TimeSpan.FromHours(4));
        item.BuildStatus.ShouldNotBeNull();
        item.BuildStatus.Success.ShouldBeFalse();
        item.BuildStatus.Message.ShouldBe("boom");
        item.BuildStatus.LastBuild.ShouldBe(buildStatus.LastBuild);

        await _mediator.Received(1).Send(
            Arg.Is<GetPagedPlayouts>(q => q.Query == "q" && q.PageNum == 2 && q.PageSize == 25),
            Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task GetAll_Should_Emit_Null_BuildStatus_When_Absent()
    {
        PlayoutNameViewModel vm = MakePlayout(9) with { BuildStatus = null };
        _mediator.Send(Arg.Any<GetPagedPlayouts>(), Arg.Any<CancellationToken>())
            .Returns(new PagedPlayoutsViewModel(1, [vm]));

        PagedPlayoutsResponseModel result = await _controller.GetAll("", 0, 100, CancellationToken.None);

        result.Page.Single().BuildStatus.ShouldBeNull();
    }

    [Test]
    public async Task GetItems_Should_Project_Items_And_Null_FillerKind_For_Gaps()
    {
        _mediator.Send(Arg.Any<GetPlayoutById>(), Arg.Any<CancellationToken>())
            .Returns(Option<PlayoutNameViewModel>.Some(MakePlayout(9)));

        var item = new PlayoutItemViewModel(
            "Movie",
            new DateTimeOffset(2026, 7, 2, 12, 0, 0, TimeSpan.Zero),
            new DateTimeOffset(2026, 7, 2, 13, 0, 0, TimeSpan.Zero),
            "1:00:00",
            string.Empty,
            Some(FillerKind.MidRoll));
        var gap = new PlayoutItemViewModel(
            "UNSCHEDULED",
            new DateTimeOffset(2026, 7, 2, 13, 0, 0, TimeSpan.Zero),
            new DateTimeOffset(2026, 7, 2, 13, 30, 0, TimeSpan.Zero),
            "30:00",
            string.Empty,
            Option<FillerKind>.None);
        _mediator.Send(Arg.Any<GetFuturePlayoutItemsById>(), Arg.Any<CancellationToken>())
            .Returns(new PagedPlayoutItemsViewModel(2, [item, gap]));

        IActionResult actionResult = await _controller.GetItems(9, showFiller: true, 1, 10, CancellationToken.None);

        var result = actionResult.ShouldBeOfType<OkObjectResult>().Value.ShouldBeOfType<PagedPlayoutItemsResponseModel>();
        result.TotalCount.ShouldBe(2);
        result.Page[0].Title.ShouldBe("Movie");
        result.Page[0].Duration.ShouldBe("1:00:00");
        result.Page[0].FillerKind.ShouldBe(FillerKind.MidRoll);
        result.Page[1].Title.ShouldBe("UNSCHEDULED");
        result.Page[1].FillerKind.ShouldBeNull();

        await _mediator.Received(1).Send(
            Arg.Is<GetFuturePlayoutItemsById>(q =>
                q.PlayoutId == 9 && q.ShowFiller && q.PageNum == 1 && q.PageSize == 10),
            Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task GetItems_Should_Return_404_For_Unknown_Playout_With_ProblemDetails()
    {
        _mediator.Send(Arg.Any<GetPlayoutById>(), Arg.Any<CancellationToken>())
            .Returns(Option<PlayoutNameViewModel>.None);

        IActionResult result = await _controller.GetItems(404, showFiller: false, 0, 100, CancellationToken.None);

        var notFound = result.ShouldBeOfType<NotFoundObjectResult>();
        var problem = notFound.Value.ShouldBeOfType<ProblemDetails>();
        problem.Status.ShouldBe(404);
        problem.Title.ShouldBe("Resource not found");

        await _mediator.DidNotReceive().Send(Arg.Any<GetFuturePlayoutItemsById>(), Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task GetWarningsCount_Should_Return_Count()
    {
        _mediator.Send(Arg.Any<GetPlayoutWarningsCount>(), Arg.Any<CancellationToken>())
            .Returns(7);

        int result = await _controller.GetWarningsCount(CancellationToken.None);

        result.ShouldBe(7);
    }

    [Test]
    public async Task ResetAll_Should_Return_202_And_Send_Command()
    {
        IActionResult result = await _controller.ResetAll(CancellationToken.None);

        result.ShouldBeOfType<AcceptedResult>();
        await _mediator.Received(1).Send(Arg.Any<ResetAllPlayouts>(), Arg.Any<CancellationToken>());
    }

    private static PlayoutNameViewModel MakePlayout(int id) =>
        new(
            id,
            PlayoutScheduleKind.Classic,
            "Channel",
            "101",
            ChannelPlayoutMode.Continuous,
            "Schedule",
            string.Empty,
            null,
            new PlayoutBuildStatus());

    private static PlayoutResponseModel ToResponse(PlayoutNameViewModel vm) =>
        PlayoutResponseModel.From(
            vm.PlayoutId,
            vm.ScheduleKind,
            vm.ChannelName,
            vm.ChannelNumber,
            vm.PlayoutMode,
            vm.ScheduleName,
            vm.ScheduleFile,
            vm.DbDailyRebuildTime,
            vm.BuildStatus is null
                ? null
                : new PlayoutBuildStatusResponseModel(
                    vm.BuildStatus.LastBuild,
                    vm.BuildStatus.Success,
                    vm.BuildStatus.Message));

    private static void ShouldHaveActionRoute(string actionName, string httpMethod, string route)
    {
        MethodInfo action = typeof(PlayoutController).GetMethod(actionName)
            ?? throw new AssertionException($"Missing action {actionName}");

        HttpMethodAttribute attribute = action.GetCustomAttributes<HttpMethodAttribute>(inherit: true).Single();
        attribute.HttpMethods.ShouldContain(httpMethod);
        attribute.Template.ShouldBe(route);
    }
}