ersatztv/ErsatzTV.Scanner.Tests/Core/Metadata/MediaServerOtherVideoLibraryScannerTests.cs

using System.IO.Abstractions;
using ErsatzTV.Core;
using ErsatzTV.Core.Domain;
using ErsatzTV.Core.Interfaces.Metadata;
using ErsatzTV.Core.Interfaces.Repositories;
using ErsatzTV.Core.Metadata;
using ErsatzTV.Core.Plex;
using ErsatzTV.Scanner.Core.Interfaces;
using ErsatzTV.Scanner.Core.Interfaces.Metadata;
using ErsatzTV.Scanner.Core.Metadata;
using ErsatzTV.Scanner.Core.Plex;
using Microsoft.Extensions.Logging;
using NSubstitute;
using NUnit.Framework;
using Shouldly;

namespace ErsatzTV.Scanner.Tests.Core.Metadata;

// #477: a successful-but-empty media-server fetch must not flag a non-empty other-video library
// FileNotFound (which EmptyTrash could then permanently delete). Assert the sweep is skipped.
public class MediaServerOtherVideoLibraryScannerTests
{
    [TestFixture]
    public class CleanupFileNotFoundItems
    {
        [Test]
        public async Task Empty_Incoming_With_Existing_OtherVideos_Does_Not_Flag()
        {
            var otherVideoRepository = Substitute.For<IPlexOtherVideoRepository>();
            var scannerProxy = Substitute.For<IScannerProxy>();

            var library = new PlexLibrary { Id = 9, Name = "Other Videos" };

            otherVideoRepository.GetExistingOtherVideos(library)
                .Returns(new List<PlexItemEtag>
                {
                    new() { Key = "ov-1", State = MediaItemState.Normal },
                    new() { Key = "ov-2", State = MediaItemState.Normal }
                });

            var scanner = new TestOtherVideoLibraryScanner(scannerProxy);

            Either<BaseError, Unit> result = await scanner.Scan(otherVideoRepository, library);

            result.IsRight.ShouldBeTrue();

            await otherVideoRepository.DidNotReceive().FlagFileNotFound(
                Arg.Any<PlexLibrary>(), Arg.Any<List<string>>());
            await scannerProxy.DidNotReceive().ReindexMediaItems(
                Arg.Any<int[]>(), Arg.Any<CancellationToken>());
        }
    }

    // Minimal concrete subclass exposing the cleanup path. Driven with an empty incoming list, so none of
    // the per-item metadata members below are ever invoked — they exist only to satisfy the contract. The
    // connection parameters are likewise never dereferenced on the empty path (passed null! below).
    private sealed class TestOtherVideoLibraryScanner : MediaServerOtherVideoLibraryScanner<
        PlexConnectionParameters, PlexLibrary, PlexOtherVideo, PlexItemEtag>
    {
        public TestOtherVideoLibraryScanner(IScannerProxy scannerProxy)
            : base(
                scannerProxy,
                Substitute.For<IFileSystem>(),
                Substitute.For<ILocalChaptersProvider>(),
                Substitute.For<IMetadataRepository>(),
                Substitute.For<ILogger>())
        {
        }

        public Task<Either<BaseError, Unit>> Scan(
            IPlexOtherVideoRepository otherVideoRepository,
            PlexLibrary library) =>
            ScanLibrary(
                otherVideoRepository,
                null!,
                library,
                _ => string.Empty,
                false,
                CancellationToken.None);

        protected override IAsyncEnumerable<Tuple<PlexOtherVideo, int>> GetOtherVideoLibraryItems(
            PlexConnectionParameters connectionParameters,
            PlexLibrary library,
            MediaServerProjectionFailureCounter projectionFailures) => EmptyOtherVideos();

        protected override string MediaServerItemId(PlexOtherVideo otherVideo) => otherVideo.Key;
        protected override string MediaServerEtag(PlexOtherVideo otherVideo) => otherVideo.Etag;

        protected override Task<Option<OtherVideoMetadata>> GetFullMetadata(
            PlexConnectionParameters connectionParameters, PlexLibrary library,
            MediaItemScanResult<PlexOtherVideo> result, PlexOtherVideo incoming, bool deepScan) =>
            throw new NotSupportedException();

        protected override Task<Option<Tuple<OtherVideoMetadata, MediaVersion>>> GetFullMetadataAndStatistics(
            PlexConnectionParameters connectionParameters, PlexLibrary library,
            MediaItemScanResult<PlexOtherVideo> result, PlexOtherVideo incoming) =>
            throw new NotSupportedException();

        protected override Task<Either<BaseError, MediaItemScanResult<PlexOtherVideo>>> UpdateMetadata(
            MediaItemScanResult<PlexOtherVideo> result, OtherVideoMetadata fullMetadata,
            CancellationToken cancellationToken) =>
            throw new NotSupportedException();

        private static async IAsyncEnumerable<Tuple<PlexOtherVideo, int>> EmptyOtherVideos()
        {
            await Task.CompletedTask;
            yield break;
        }
    }
}