ersatztv/ErsatzTV.Tests/Controllers/MultiCollectionControllerTests.cs

using System.Reflection;
using ErsatzTV.Application.MediaCollections;
using ErsatzTV.Controllers.Api;
using ErsatzTV.Controllers.Api.Requests;
using ErsatzTV.Core;
using ErsatzTV.Core.Api.MediaCollections;
using ErsatzTV.Core.Domain;
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 MultiCollectionControllerTests
{
    [SetUp]
    public void SetUp()
    {
        _mediator = Substitute.For<IMediator>();
        _controller = new MultiCollectionController(_mediator);
    }

    private MultiCollectionController _controller = null!;
    private IMediator _mediator = null!;

    [Test]
    public void Controller_Should_Expose_Idiomatic_Rest_Routes()
    {
        ShouldHaveActionRoute(nameof(MultiCollectionController.GetAll), "GET", "/api/multi-collections");
        ShouldHaveActionRoute(nameof(MultiCollectionController.GetById), "GET", "/api/multi-collections/{id:int}");
        ShouldHaveActionRoute(nameof(MultiCollectionController.Create), "POST", "/api/multi-collections");
        ShouldHaveActionRoute(nameof(MultiCollectionController.Update), "PUT", "/api/multi-collections/{id:int}");
        ShouldHaveActionRoute(nameof(MultiCollectionController.Delete), "DELETE", "/api/multi-collections/{id:int}");
    }

    [Test]
    public async Task GetAll_Should_Clamp_Paging_And_Map_Response()
    {
        _mediator.Send(Arg.Any<GetPagedMultiCollections>(), Arg.Any<CancellationToken>())
            .Returns(new PagedMultiCollectionsViewModel(1, new List<MultiCollectionViewModel> { MakeMulti(3, "Kids") }));

        PagedMultiCollectionsResponseModel result =
            await _controller.GetAll("k", -5, 9999, CancellationToken.None);

        result.TotalCount.ShouldBe(1);
        result.Page.Count.ShouldBe(1);
        result.Page[0].Id.ShouldBe(3);
        result.Page[0].Items.Count.ShouldBe(2);
        result.Page[0].Items[0].CollectionId.ShouldBe(10);
        result.Page[0].Items[1].SmartCollectionId.ShouldBe(20);
        await _mediator.Received(1).Send(
            Arg.Is<GetPagedMultiCollections>(q => q.Query == "k" && q.PageNum == 0 && q.PageSize == 100),
            Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task GetById_Should_Return_200_For_Some()
    {
        _mediator.Send(Arg.Any<GetMultiCollectionById>(), Arg.Any<CancellationToken>())
            .Returns(Option<MultiCollectionViewModel>.Some(MakeMulti(4, "Kids")));

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

        result.ShouldBeOfType<OkObjectResult>().Value.ShouldBeOfType<MultiCollectionResponseModel>().Id.ShouldBe(4);
    }

    [Test]
    public async Task GetById_Should_Return_404_For_None()
    {
        _mediator.Send(Arg.Any<GetMultiCollectionById>(), Arg.Any<CancellationToken>())
            .Returns(Option<MultiCollectionViewModel>.None);

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

        result.ShouldBeOfType<NotFoundObjectResult>();
    }

    [Test]
    public async Task Create_Should_Return_201_And_Map_Request()
    {
        _mediator.Send(Arg.Any<CreateMultiCollection>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, MultiCollectionViewModel>(MakeMulti(8, "Kids")));

        IActionResult result = await _controller.Create(
            new CreateMultiCollectionRequest(
                "Kids",
                new List<MultiCollectionItemRequest>
                {
                    new(10, null, true, PlaybackOrder.Chronological),
                    new(null, 20, false, PlaybackOrder.Shuffle)
                }),
            CancellationToken.None);

        var created = result.ShouldBeOfType<CreatedResult>();
        created.Location.ShouldBe("/api/multi-collections/8");
        created.Value.ShouldBeOfType<MultiCollectionResponseModel>().Name.ShouldBe("Kids");
        await _mediator.Received(1).Send(
            Arg.Is<CreateMultiCollection>(c =>
                c.Name == "Kids" &&
                c.Items.Count == 2 &&
                c.Items[0].CollectionId == 10 &&
                c.Items[0].ScheduleAsGroup &&
                c.Items[0].PlaybackOrder == PlaybackOrder.Chronological &&
                c.Items[1].SmartCollectionId == 20),
            Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task Create_Should_Return_422_On_Validation_Error()
    {
        _mediator.Send(Arg.Any<CreateMultiCollection>(), Arg.Any<CancellationToken>())
            .Returns(Left<BaseError, MultiCollectionViewModel>(BaseError.New("dupe")));

        IActionResult result = await _controller.Create(
            new CreateMultiCollectionRequest("Kids", new List<MultiCollectionItemRequest>()),
            CancellationToken.None);

        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
    }

    [Test]
    public async Task Update_Should_Return_200_With_Refreshed_Body_And_Map_Request()
    {
        _mediator.Send(Arg.Any<UpdateMultiCollection>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, Unit>(Unit.Default));
        _mediator.Send(Arg.Any<GetMultiCollectionById>(), Arg.Any<CancellationToken>())
            .Returns(Option<MultiCollectionViewModel>.Some(MakeMulti(4, "Kids")));

        IActionResult result = await _controller.Update(
            4,
            new UpdateMultiCollectionRequest(
                "Kids",
                new List<MultiCollectionItemRequest> { new(10, null, true, PlaybackOrder.Random) }),
            CancellationToken.None);

        result.ShouldBeOfType<OkObjectResult>().Value.ShouldBeOfType<MultiCollectionResponseModel>().Id.ShouldBe(4);
        await _mediator.Received(1).Send(
            Arg.Is<UpdateMultiCollection>(c =>
                c.MultiCollectionId == 4 &&
                c.Name == "Kids" &&
                c.Items.Count == 1 &&
                c.Items[0].CollectionId == 10 &&
                c.Items[0].PlaybackOrder == PlaybackOrder.Random),
            Arg.Any<CancellationToken>());
    }

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

        IActionResult result = await _controller.Update(
            4,
            new UpdateMultiCollectionRequest("Kids", new List<MultiCollectionItemRequest>()),
            CancellationToken.None);

        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
        await _mediator.DidNotReceive().Send(Arg.Any<GetMultiCollectionById>(), Arg.Any<CancellationToken>());
    }

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

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

        result.ShouldBeOfType<NoContentResult>();
        await _mediator.Received(1).Send(
            Arg.Is<DeleteMultiCollection>(c => c.MultiCollectionId == 4),
            Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task Delete_Should_Return_404_On_NotFoundError()
    {
        _mediator.Send(Arg.Any<DeleteMultiCollection>(), Arg.Any<CancellationToken>())
            .Returns(Left<BaseError, Unit>(new ErsatzTV.Core.Errors.NotFoundError("missing")));

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

        result.ShouldBeOfType<NotFoundObjectResult>();
    }

    private static MultiCollectionViewModel MakeMulti(int id, string name) =>
        new(
            id,
            name,
            new List<MultiCollectionItemViewModel>
            {
                new(
                    id,
                    new MediaCollectionViewModel(CollectionType.Collection, 10, "Movies", false, MediaItemState.Normal),
                    true,
                    PlaybackOrder.Chronological)
            },
            new List<MultiCollectionSmartItemViewModel>
            {
                new(id, new SmartCollectionViewModel(20, "Smart", "query"), false, PlaybackOrder.Shuffle)
            });

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

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