ersatztv/ErsatzTV.Tests/Controllers/LibrariesControllerTests.cs

using System.Reflection;
using ErsatzTV.Application.Libraries;
using ErsatzTV.Controllers.Api;
using ErsatzTV.Core.Api.Libraries;
using ErsatzTV.Core.Interfaces.Repositories;
using LanguageExt;
using MediatR;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Routing;
using NSubstitute;
using NUnit.Framework;
using Shouldly;

namespace ErsatzTV.Tests.Controllers;

[TestFixture]
public class LibrariesControllerTests
{
    private LibrariesController _controller = null!;
    private IMediator _mediator = null!;
    private ITelevisionRepository _televisionRepository = null!;

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

    [Test]
    public void ScanStatus_Should_Expose_Idiomatic_Rest_Route()
    {
        MethodInfo action = typeof(LibrariesController).GetMethod(nameof(LibrariesController.GetScanStatus))
            ?? throw new AssertionException("Missing action GetScanStatus");

        HttpMethodAttribute attribute = action.GetCustomAttributes<HttpMethodAttribute>(inherit: true).Single();
        attribute.HttpMethods.ShouldContain("GET");
        attribute.Template.ShouldBe("/api/libraries/scan-status");
        attribute.Name.ShouldBe("GetLibraryScanStatus");
    }

    [Test]
    public async Task GetScanStatus_Should_Return_Results_From_Mediator()
    {
        var expected = new List<LibraryScanStatusResponseModel>
        {
            new(1, 42.5m),
            new(2, 99m)
        };

        _mediator.Send(Arg.Any<GetLibraryScanStatus>(), Arg.Any<CancellationToken>())
            .Returns(expected);

        List<LibraryScanStatusResponseModel> result = await _controller.GetScanStatus(CancellationToken.None);

        result.ShouldBe(expected);
    }

    [Test]
    public async Task ScanShow_Should_Return_NotFoundProblem_When_Show_Not_In_Library()
    {
        _televisionRepository.GetShowTitle(3, 999).Returns(Option<string>.None);

        IActionResult result = await _controller.ScanShow(3, new ScanShowRequest(999));

        var notFound = result.ShouldBeOfType<NotFoundObjectResult>();
        notFound.Value.ShouldBeOfType<ProblemDetails>().Status.ShouldBe(StatusCodes.Status404NotFound);
        await _mediator.DidNotReceive().Send(Arg.Any<QueueShowScanByLibraryId>(), Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task ScanShow_Should_Queue_Scan_By_Show_Id_When_Show_Belongs_To_Library()
    {
        _televisionRepository.GetShowTitle(3, 42).Returns(Option<string>.Some("The Office"));
        _mediator.Send(Arg.Any<QueueShowScanByLibraryId>(), Arg.Any<CancellationToken>()).Returns(true);

        IActionResult result = await _controller.ScanShow(3, new ScanShowRequest(42, DeepScan: true));

        result.ShouldBeOfType<OkResult>();
        await _mediator.Received(1).Send(
            Arg.Is<QueueShowScanByLibraryId>(r =>
                r.LibraryId == 3 && r.ShowId == 42 && r.ShowTitle == "The Office" && r.DeepScan),
            Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task ScanShow_Should_Return_BadRequest_When_Mediator_Fails_To_Queue()
    {
        _televisionRepository.GetShowTitle(3, 42).Returns(Option<string>.Some("The Office"));
        _mediator.Send(Arg.Any<QueueShowScanByLibraryId>(), Arg.Any<CancellationToken>()).Returns(false);

        IActionResult result = await _controller.ScanShow(3, new ScanShowRequest(42));

        result.ShouldBeOfType<BadRequestObjectResult>();
    }

    [Test]
    public async Task ScanLibrary_Should_Return_202_When_Queued()
    {
        _mediator.Send(Arg.Any<QueueLibraryScanByLibraryId>(), Arg.Any<CancellationToken>())
            .Returns(QueueLibraryScanResult.Queued);

        IActionResult result = await _controller.ScanLibrary(7, CancellationToken.None);

        result.ShouldBeOfType<AcceptedResult>();
        await _mediator.Received(1).Send(
            Arg.Is<QueueLibraryScanByLibraryId>(r => r.LibraryId == 7),
            Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task ScanLibrary_Should_Return_404_When_NotFound()
    {
        _mediator.Send(Arg.Any<QueueLibraryScanByLibraryId>(), Arg.Any<CancellationToken>())
            .Returns(QueueLibraryScanResult.NotFound);

        IActionResult result = await _controller.ScanLibrary(7, CancellationToken.None);

        var notFound = result.ShouldBeOfType<NotFoundObjectResult>();
        notFound.Value.ShouldBeOfType<ProblemDetails>().Status.ShouldBe(StatusCodes.Status404NotFound);
    }

    [Test]
    public async Task ScanLibrary_Should_Return_409_When_AlreadyScanning()
    {
        _mediator.Send(Arg.Any<QueueLibraryScanByLibraryId>(), Arg.Any<CancellationToken>())
            .Returns(QueueLibraryScanResult.AlreadyScanning);

        IActionResult result = await _controller.ScanLibrary(7, CancellationToken.None);

        var conflict = result.ShouldBeOfType<ConflictObjectResult>();
        conflict.Value.ShouldBeOfType<ProblemDetails>().Status.ShouldBe(StatusCodes.Status409Conflict);
    }

    [Test]
    public async Task ScanLibrary_Should_Return_422_When_SyncDisabled()
    {
        _mediator.Send(Arg.Any<QueueLibraryScanByLibraryId>(), Arg.Any<CancellationToken>())
            .Returns(QueueLibraryScanResult.SyncDisabled);

        IActionResult result = await _controller.ScanLibrary(7, CancellationToken.None);

        var unprocessable = result.ShouldBeOfType<UnprocessableEntityObjectResult>();
        unprocessable.Value.ShouldBeOfType<ProblemDetails>().Status.ShouldBe(StatusCodes.Status422UnprocessableEntity);
    }
}