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

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

namespace ErsatzTV.Scanner.Tests.Core.Metadata;

// #476: a show/season gone from the media server is absent from the incoming list, so the per-parent
// loop never visits it and the descendant sweeps never run for it. These tests assert the scanner
// cascades the FileNotFound flag to descendants via the repository, using a substituted repository.
public class MediaServerTelevisionLibraryScannerTests
{
    [TestFixture]
    public class CleanupFileNotFoundItems
    {
        [Test]
        public async Task Removed_Show_Cascades_FileNotFound_To_Seasons_And_Episodes()
        {
            var televisionRepository = Substitute.For<IJellyfinTelevisionRepository>();
            var scannerProxy = Substitute.For<IScannerProxy>();

            var library = new JellyfinLibrary { Id = 42, Name = "TV Shows" };

            // one show exists in the DB but is NOT in the incoming (empty) list => it was removed upstream
            televisionRepository.GetExistingShows(library, Arg.Any<CancellationToken>())
                .Returns(new List<JellyfinItemEtag>
                {
                    new() { ItemId = "show-6366", State = MediaItemState.FileNotFound }
                });

            televisionRepository
                .FlagFileNotFoundShows(library, Arg.Is<List<string>>(l => l.Contains("show-6366")),
                    Arg.Any<CancellationToken>())
                .Returns(new List<int> { 100 });
            televisionRepository
                .FlagFileNotFoundSeasonsForShows(Arg.Is<List<int>>(l => l.SequenceEqual(new[] { 100 })),
                    Arg.Any<CancellationToken>())
                .Returns(new List<int> { 200, 201 });
            televisionRepository
                .FlagFileNotFoundEpisodesForSeasons(Arg.Is<List<int>>(l => l.SequenceEqual(new[] { 200, 201 })),
                    Arg.Any<CancellationToken>())
                .Returns(new List<int> { 300, 301, 302 });
            scannerProxy.ReindexMediaItems(Arg.Any<int[]>(), Arg.Any<CancellationToken>()).Returns(true);

            var scanner = new TestTelevisionLibraryScanner(scannerProxy);

            Either<BaseError, Unit> result = await scanner.Scan(
                televisionRepository,
                new JellyfinConnectionParameters("http://jellyfin.example", "abc", 7),
                library,
                EmptyShows());

            result.IsRight.ShouldBeTrue();

            await televisionRepository.Received(1).FlagFileNotFoundShows(
                library,
                Arg.Is<List<string>>(l => l.Count == 1 && l.Contains("show-6366")),
                Arg.Any<CancellationToken>());
            await televisionRepository.Received(1).FlagFileNotFoundSeasonsForShows(
                Arg.Is<List<int>>(l => l.SequenceEqual(new[] { 100 })),
                Arg.Any<CancellationToken>());
            await televisionRepository.Received(1).FlagFileNotFoundEpisodesForSeasons(
                Arg.Is<List<int>>(l => l.SequenceEqual(new[] { 200, 201 })),
                Arg.Any<CancellationToken>());

            // every affected item (show + seasons + episodes) is reindexed so search reflects the new state
            await scannerProxy.Received(1).ReindexMediaItems(
                Arg.Is<int[]>(a => new[] { 100, 200, 201, 300, 301, 302 }.All(id => a.Contains(id))),
                Arg.Any<CancellationToken>());
        }

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

    // Minimal concrete subclass that exposes the abstract scanner's cleanup path. The incoming show list
    // is supplied directly (empty = "all shows removed"), so none of the per-item metadata members below
    // are ever invoked — they exist only to satisfy the abstract contract.
    private sealed class TestTelevisionLibraryScanner : MediaServerTelevisionLibraryScanner<
        JellyfinConnectionParameters, JellyfinLibrary, JellyfinShow, JellyfinSeason, JellyfinEpisode,
        JellyfinItemEtag>
    {
        public TestTelevisionLibraryScanner(IScannerProxy scannerProxy)
            : base(
                scannerProxy,
                Substitute.For<IFileSystem>(),
                Substitute.For<ILocalChaptersProvider>(),
                Substitute.For<IMetadataRepository>(),
                Substitute.For<ILogger>())
        {
        }

        public Task<Either<BaseError, Unit>> Scan(
            IMediaServerTelevisionRepository<JellyfinLibrary, JellyfinShow, JellyfinSeason, JellyfinEpisode,
                JellyfinItemEtag> televisionRepository,
            JellyfinConnectionParameters connectionParameters,
            JellyfinLibrary library,
            IAsyncEnumerable<Tuple<JellyfinShow, int>> showEntries) =>
            ScanLibrary(
                televisionRepository,
                connectionParameters,
                library,
                _ => string.Empty,
                showEntries,
                false,
                CancellationToken.None);

        protected override IAsyncEnumerable<Tuple<JellyfinShow, int>> GetShowLibraryItems(
            JellyfinConnectionParameters connectionParameters, JellyfinLibrary library) =>
            throw new NotSupportedException();

        protected override string MediaServerItemId(JellyfinShow show) => show.ItemId;
        protected override string MediaServerItemId(JellyfinSeason season) => season.ItemId;
        protected override string MediaServerItemId(JellyfinEpisode episode) => episode.ItemId;
        protected override string MediaServerEtag(JellyfinShow show) => show.Etag;
        protected override string MediaServerEtag(JellyfinSeason season) => season.Etag;
        protected override string MediaServerEtag(JellyfinEpisode episode) => episode.Etag;

        protected override IAsyncEnumerable<Tuple<JellyfinSeason, int>> GetSeasonLibraryItems(
            JellyfinLibrary library, JellyfinConnectionParameters connectionParameters, JellyfinShow show) =>
            throw new NotSupportedException();

        protected override IAsyncEnumerable<Tuple<JellyfinEpisode, int>> GetEpisodeLibraryItems(
            JellyfinLibrary library, JellyfinConnectionParameters connectionParameters, JellyfinShow show,
            JellyfinSeason season, bool isNewSeason) =>
            throw new NotSupportedException();

        protected override Task<Option<ShowMetadata>> GetFullMetadata(
            JellyfinConnectionParameters connectionParameters, JellyfinLibrary library,
            MediaItemScanResult<JellyfinShow> result, JellyfinShow incoming, bool deepScan) =>
            throw new NotSupportedException();

        protected override Task<Option<SeasonMetadata>> GetFullMetadata(
            JellyfinConnectionParameters connectionParameters, JellyfinLibrary library,
            MediaItemScanResult<JellyfinSeason> result, JellyfinSeason incoming, bool deepScan) =>
            throw new NotSupportedException();

        protected override Task<Option<EpisodeMetadata>> GetFullMetadata(
            JellyfinConnectionParameters connectionParameters, JellyfinLibrary library,
            MediaItemScanResult<JellyfinEpisode> result, JellyfinEpisode incoming, bool deepScan) =>
            throw new NotSupportedException();

        protected override Task<Option<Tuple<EpisodeMetadata, MediaVersion>>> GetFullMetadataAndStatistics(
            JellyfinConnectionParameters connectionParameters, JellyfinLibrary library,
            MediaItemScanResult<JellyfinEpisode> result, JellyfinEpisode incoming) =>
            throw new NotSupportedException();

        protected override Task<Either<BaseError, MediaItemScanResult<JellyfinShow>>> UpdateMetadata(
            MediaItemScanResult<JellyfinShow> result, ShowMetadata fullMetadata) =>
            throw new NotSupportedException();

        protected override Task<Either<BaseError, MediaItemScanResult<JellyfinSeason>>> UpdateMetadata(
            MediaItemScanResult<JellyfinSeason> result, SeasonMetadata fullMetadata) =>
            throw new NotSupportedException();

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