2 files changed, 468 insertions, 0 deletions
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceImageInheritanceTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceImageInheritanceTests.cs
new file mode 100644
index 0000000000..6a3dcab57a
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceImageInheritanceTests.cs
@@ -0,0 +1,330 @@
+using System;
+using System.Collections.Generic;
+using Emby.Server.Implementations.Dto;
+using Emby.Server.Implementations.Playlists;
+using Jellyfin.Data.Enums;
+using MediaBrowser.Common;
+using MediaBrowser.Controller.Chapters;
+using MediaBrowser.Controller.Drawing;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.LiveTv;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Controller.Trickplay;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Querying;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.Dto;
+
+public class DtoServiceImageInheritanceTests
+{
+    [Fact]
+    public void GetBaseItemDto_PlaylistsUserViewWithDisplayParentPrimary_UsesDisplayParentPrimaryImage()
+    {
+        var displayParent = new PlaylistsFolder
+        {
+            Id = Guid.NewGuid(),
+            ImageInfos =
+            [
+                new ItemImageInfo
+                {
+                    Type = ImageType.Primary,
+                    Path = "/images/playlists-custom.jpg",
+                    DateModified = new DateTime(2026, 1, 15, 12, 0, 0, DateTimeKind.Utc)
+                }
+            ]
+        };
+
+        var userView = new UserView
+        {
+            Id = Guid.NewGuid(),
+            ViewType = CollectionType.playlists,
+            DisplayParentId = displayParent.Id,
+            ImageInfos =
+            [
+                new ItemImageInfo
+                {
+                    Type = ImageType.Primary,
+                    Path = "/images/generated.png",
+                    DateModified = new DateTime(2026, 1, 10, 12, 0, 0, DateTimeKind.Utc)
+                }
+            ]
+        };
+
+        var dtoService = BuildDtoService(displayParent);
+
+        var dto = dtoService.GetBaseItemDto(userView, new DtoOptions(false));
+
+        Assert.NotNull(dto.ParentPrimaryImageItemId);
+        Assert.Equal(displayParent.Id, dto.ParentPrimaryImageItemId);
+        Assert.Equal("/images/playlists-custom.jpg", dto.ParentPrimaryImageTag);
+        Assert.False(dto.ImageTags?.ContainsKey(ImageType.Primary));
+    }
+
+    [Fact]
+    public void GetBaseItemDto_PlaylistsUserViewWithoutDisplayParentPrimary_KeepsOwnPrimaryImage()
+    {
+        var displayParent = new PlaylistsFolder
+        {
+            Id = Guid.NewGuid(),
+            ImageInfos = []
+        };
+
+        var userView = new UserView
+        {
+            Id = Guid.NewGuid(),
+            ViewType = CollectionType.playlists,
+            DisplayParentId = displayParent.Id,
+            ImageInfos =
+            [
+                new ItemImageInfo
+                {
+                    Type = ImageType.Primary,
+                    Path = "/images/generated.png",
+                    DateModified = new DateTime(2026, 1, 10, 12, 0, 0, DateTimeKind.Utc)
+                }
+            ]
+        };
+
+        var dtoService = BuildDtoService(displayParent);
+
+        var dto = dtoService.GetBaseItemDto(userView, new DtoOptions(false));
+
+        Assert.Null(dto.ParentPrimaryImageItemId);
+        Assert.Null(dto.ParentPrimaryImageTag);
+        Assert.NotNull(dto.ImageTags);
+        Assert.True(dto.ImageTags.ContainsKey(ImageType.Primary));
+        Assert.Equal("/images/generated.png", dto.ImageTags[ImageType.Primary]);
+    }
+
+    [Fact]
+    public void GetBaseItemDtos_MusicAlbums_ResolveInheritedThumbFromArtistBatch_WithoutPerAlbumLookup()
+    {
+        var artist = new MusicArtist
+        {
+            Id = Guid.NewGuid(),
+            Name = "Some Artist",
+            ImageInfos =
+            [
+                new ItemImageInfo
+                {
+                    Type = ImageType.Thumb,
+                    Path = "/images/artist-thumb.jpg",
+                    DateModified = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc)
+                }
+            ]
+        };
+
+        static MusicAlbum MakeAlbum() => new MusicAlbum
+        {
+            Id = Guid.NewGuid(),
+            Name = "Album",
+            AlbumArtists = ["Some Artist"],
+            ImageInfos = []
+        };
+
+        var libraryManager = new Mock<ILibraryManager>();
+
+        // DtoService resolves every album-artist name in ONE batch (GetArtists). The album's inherited
+        // Thumb/Backdrop images must come from that batch, not a per-album GetArtist/GetItemList lookup
+        // (the N+1). GetArtist is intentionally left unset: a regression to the per-album path would
+        // resolve no artist and fail the assertions below.
+        libraryManager
+            .Setup(x => x.GetArtists(It.IsAny<IReadOnlyList<string>>()))
+            .Returns(new Dictionary<string, MusicArtist[]>(StringComparer.OrdinalIgnoreCase)
+            {
+                ["Some Artist"] = [artist]
+            });
+
+        var dtoService = BuildDtoService(libraryManager);
+
+        var dtos = dtoService.GetBaseItemDtos([MakeAlbum(), MakeAlbum()], new DtoOptions(false));
+
+        Assert.Equal(2, dtos.Count);
+        foreach (var dto in dtos)
+        {
+            Assert.Equal(artist.Id, dto.ParentThumbItemId);
+            Assert.Equal("/images/artist-thumb.jpg", dto.ParentThumbImageTag);
+        }
+
+        // The artist lookup is batched once for the whole set, never once per album.
+        libraryManager.Verify(x => x.GetArtists(It.IsAny<IReadOnlyList<string>>()), Times.Once);
+        libraryManager.Verify(x => x.GetArtist(It.IsAny<string>(), It.IsAny<DtoOptions>()), Times.Never);
+    }
+
+    [Fact]
+    public void GetBaseItemDtos_Items_ResolvePeopleFromBatch_WithoutPerItemLookup()
+    {
+        static MusicAlbum MakeAlbum() => new MusicAlbum
+        {
+            Id = Guid.NewGuid(),
+            Name = "Album",
+            ImageInfos = []
+        };
+
+        var albumOne = MakeAlbum();
+        var albumTwo = MakeAlbum();
+
+        var libraryManager = new Mock<ILibraryManager>();
+
+        // DtoService resolves people for every item in ONE batch (GetPeopleByItems) before the
+        // per-item loop. A regression to the per-item path would call GetPeople(BaseItem) once per
+        // item (the N+1); it is intentionally left unset so such a regression fails here.
+        libraryManager
+            .Setup(x => x.GetPeopleByItems(It.IsAny<IReadOnlyList<Guid>>()))
+            .Returns(new Dictionary<Guid, IReadOnlyList<PersonInfo>>
+            {
+                [albumOne.Id] = [new PersonInfo { ItemId = albumOne.Id, Name = "Some Actor", Type = PersonKind.Actor }],
+                [albumTwo.Id] = [new PersonInfo { ItemId = albumTwo.Id, Name = "Some Actor", Type = PersonKind.Actor }]
+            });
+
+        // AttachPeople still resolves each distinct name to its Person entity to attach images.
+        libraryManager
+            .Setup(x => x.GetPerson("Some Actor"))
+            .Returns(new Person { Id = Guid.NewGuid(), Name = "Some Actor" });
+
+        var dtoService = BuildDtoService(libraryManager);
+
+        var options = new DtoOptions(false) { Fields = [ItemFields.People] };
+        var dtos = dtoService.GetBaseItemDtos([albumOne, albumTwo], options);
+
+        Assert.Equal(2, dtos.Count);
+        foreach (var dto in dtos)
+        {
+            Assert.NotNull(dto.People);
+            Assert.Single(dto.People);
+            Assert.Equal("Some Actor", dto.People[0].Name);
+        }
+
+        // People are batched once for the whole set, never once per item.
+        libraryManager.Verify(x => x.GetPeopleByItems(It.IsAny<IReadOnlyList<Guid>>()), Times.Once);
+        libraryManager.Verify(x => x.GetPeople(It.IsAny<BaseItem>()), Times.Never);
+    }
+
+    [Fact]
+    public void GetBaseItemDtos_Videos_ResolveMediaSourceCountFromBatch_WithoutPerItemLookup()
+    {
+        static Movie MakeMovie() => new Movie
+        {
+            Id = Guid.NewGuid(),
+            Name = "Movie",
+            ImageInfos = []
+        };
+
+        var movieOne = MakeMovie();
+        var movieTwo = MakeMovie();
+
+        var libraryManager = new Mock<ILibraryManager>();
+
+        // DtoService detects which videos own alternate versions in ONE batch
+        // (GetItemIdsWithAlternateVersions) before the per-item loop. Videos absent from that set have a
+        // single media source, so the per-item GetLinkedAlternateVersions/GetLocalAlternateVersionIds
+        // queries (the N+1) must be skipped entirely. Here neither movie has alternate versions.
+        libraryManager
+            .Setup(x => x.GetItemIdsWithAlternateVersions(It.IsAny<IReadOnlyList<Guid>>()))
+            .Returns(new HashSet<Guid>());
+
+        var dtoService = BuildDtoService(libraryManager);
+
+        var options = new DtoOptions(false) { Fields = [ItemFields.MediaSourceCount] };
+        var dtos = dtoService.GetBaseItemDtos([movieOne, movieTwo], options);
+
+        Assert.Equal(2, dtos.Count);
+
+        // A single media source is the default, so the count is left unset (the client treats null as one).
+        foreach (var dto in dtos)
+        {
+            Assert.Null(dto.MediaSourceCount);
+        }
+
+        // The alternate-version check is batched once for the whole set, and the per-item lookups are
+        // never reached because the batch already ruled out alternate versions.
+        libraryManager.Verify(x => x.GetItemIdsWithAlternateVersions(It.IsAny<IReadOnlyList<Guid>>()), Times.Once);
+        libraryManager.Verify(x => x.GetLinkedAlternateVersions(It.IsAny<Video>()), Times.Never);
+        libraryManager.Verify(x => x.GetLocalAlternateVersionIds(It.IsAny<Video>()), Times.Never);
+    }
+
+    [Fact]
+    public void GetBaseItemDtos_VideoInAlternateVersionBatch_ResolvesRealCount()
+    {
+        var movie = new Movie
+        {
+            Id = Guid.NewGuid(),
+            Name = "Movie",
+            ImageInfos = []
+        };
+
+        var libraryManager = new Mock<ILibraryManager>();
+
+        // This movie IS in the batch set, so the fast path must not short-circuit it: the per-item
+        // lookups still run and the count is computed exactly as it was before batching. Two linked
+        // alternate versions plus the movie itself is a count of three.
+        libraryManager
+            .Setup(x => x.GetItemIdsWithAlternateVersions(It.IsAny<IReadOnlyList<Guid>>()))
+            .Returns(new HashSet<Guid> { movie.Id });
+        libraryManager
+            .Setup(x => x.GetLinkedAlternateVersions(It.IsAny<Video>()))
+            .Returns([new Movie { Id = Guid.NewGuid() }, new Movie { Id = Guid.NewGuid() }]);
+        libraryManager
+            .Setup(x => x.GetLocalAlternateVersionIds(It.IsAny<Video>()))
+            .Returns([]);
+
+        var dtoService = BuildDtoService(libraryManager);
+
+        var options = new DtoOptions(false) { Fields = [ItemFields.MediaSourceCount] };
+        var dtos = dtoService.GetBaseItemDtos([movie], options);
+
+        Assert.Single(dtos);
+        Assert.Equal(3, dtos[0].MediaSourceCount);
+        libraryManager.Verify(x => x.GetItemIdsWithAlternateVersions(It.IsAny<IReadOnlyList<Guid>>()), Times.Once);
+    }
+
+    private static DtoService BuildDtoService(BaseItem displayParent)
+    {
+        var libraryManager = new Mock<ILibraryManager>();
+        libraryManager
+            .Setup(x => x.GetItemById(displayParent.Id))
+            .Returns(displayParent);
+        return BuildDtoService(libraryManager);
+    }
+
+    private static DtoService BuildDtoService(Mock<ILibraryManager> libraryManager)
+    {
+        var userDataManager = new Mock<IUserDataManager>();
+        var imageProcessor = new Mock<IImageProcessor>();
+        var providerManager = new Mock<IProviderManager>();
+        var recordingsManager = new Mock<IRecordingsManager>();
+        var appHost = new Mock<IApplicationHost>();
+        var mediaSourceManager = new Mock<IMediaSourceManager>();
+        var liveTvManager = new Mock<ILiveTvManager>();
+        var trickplayManager = new Mock<ITrickplayManager>();
+        var chapterManager = new Mock<IChapterManager>();
+        var logger = new Mock<Microsoft.Extensions.Logging.ILogger<DtoService>>();
+
+        imageProcessor
+            .Setup(x => x.GetImageCacheTag(It.IsAny<BaseItem>(), It.IsAny<ItemImageInfo>()))
+            .Returns<BaseItem, ItemImageInfo>((_, image) => image.Path);
+
+        // Video.IsActiveRecording() dereferences this static during DTO building.
+        Video.RecordingsManager = recordingsManager.Object;
+        BaseItem.LibraryManager = libraryManager.Object;
+
+        return new DtoService(
+            logger.Object,
+            libraryManager.Object,
+            userDataManager.Object,
+            imageProcessor.Object,
+            providerManager.Object,
+            recordingsManager.Object,
+            appHost.Object,
+            mediaSourceManager.Object,
+            new Lazy<ILiveTvManager>(() => liveTvManager.Object),
+            trickplayManager.Object,
+            chapterManager.Object);
+    }
+}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceTests.cs
new file mode 100644
index 0000000000..9c247d54b9
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceTests.cs
@@ -0,0 +1,138 @@
+using System;
+using Emby.Server.Implementations.Dto;
+using MediaBrowser.Common;
+using MediaBrowser.Controller.Chapters;
+using MediaBrowser.Controller.Drawing;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.LiveTv;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Controller.Trickplay;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Querying;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.Dto;
+
+public class DtoServiceTests
+{
+    private readonly Mock<ILibraryManager> _libraryManagerMock;
+    private readonly DtoService _dtoService;
+
+    public DtoServiceTests()
+    {
+        _libraryManagerMock = new Mock<ILibraryManager>();
+
+        var imageProcessor = new Mock<IImageProcessor>();
+        // Deterministic tag derived from the image so each item gets a distinct, assertable tag.
+        imageProcessor
+            .Setup(x => x.GetImageCacheTag(It.IsAny<BaseItem>(), It.IsAny<ItemImageInfo>()))
+            .Returns((BaseItem _, ItemImageInfo image) => "tag:" + image.Path);
+
+        var appHost = new Mock<IApplicationHost>();
+        appHost.Setup(x => x.SystemId).Returns("test-server");
+
+        // Video.SourceType probes the active-recording manager; provide one so it doesn't NRE.
+        Video.RecordingsManager = new Mock<IRecordingsManager>().Object;
+
+        _dtoService = new DtoService(
+            NullLogger<DtoService>.Instance,
+            _libraryManagerMock.Object,
+            new Mock<IUserDataManager>().Object,
+            imageProcessor.Object,
+            new Mock<IProviderManager>().Object,
+            new Mock<IRecordingsManager>().Object,
+            appHost.Object,
+            new Mock<IMediaSourceManager>().Object,
+            new Lazy<ILiveTvManager>(() => new Mock<ILiveTvManager>().Object),
+            new Mock<ITrickplayManager>().Object,
+            new Mock<IChapterManager>().Object);
+
+        // Episode.Series / Episode.Season resolve through the static BaseItem.LibraryManager.
+        BaseItem.LibraryManager = _libraryManagerMock.Object;
+    }
+
+    [Fact]
+    public void GetBaseItemDto_Episode_AttachesSeasonPosterAsParentPrimaryImage()
+    {
+        var (episode, season, _) = BuildEpisode(seasonHasPoster: true);
+        var options = new DtoOptions(false) { Fields = [ItemFields.PrimaryImageAspectRatio] };
+
+        var dto = _dtoService.GetBaseItemDto(episode, options);
+
+        // The season poster is attached additively; the episode keeps its own primary and 16:9 ratio,
+        // and clients decide per view whether to prefer the parent/series poster over the episode still.
+        Assert.NotNull(dto.ImageTags);
+        Assert.True(dto.ImageTags.ContainsKey(ImageType.Primary));
+        Assert.NotNull(dto.SeriesPrimaryImageTag);
+        Assert.Equal(season.Id, dto.ParentPrimaryImageItemId);
+        Assert.Equal("tag:" + season.GetImageInfo(ImageType.Primary, 0)!.Path, dto.ParentPrimaryImageTag);
+        // Aspect ratio stays the episode's own image, not the poster's.
+        Assert.Equal(episode.GetDefaultPrimaryImageAspectRatio(), dto.PrimaryImageAspectRatio);
+    }
+
+    [Fact]
+    public void GetBaseItemDto_Episode_ParentPrimaryImageFallsBackToSeriesWhenSeasonHasNoPoster()
+    {
+        var (episode, _, series) = BuildEpisode(seasonHasPoster: false);
+        var options = new DtoOptions(false);
+
+        var dto = _dtoService.GetBaseItemDto(episode, options);
+
+        // Episode image is retained; ParentPrimaryImage falls back to the series poster.
+        Assert.NotNull(dto.ImageTags);
+        Assert.True(dto.ImageTags.ContainsKey(ImageType.Primary));
+        Assert.NotNull(dto.SeriesPrimaryImageTag);
+        Assert.Equal(series.Id, dto.ParentPrimaryImageItemId);
+        Assert.Equal("tag:" + series.GetImageInfo(ImageType.Primary, 0)!.Path, dto.ParentPrimaryImageTag);
+    }
+
+    [Fact]
+    public void GetBaseItemDto_Episode_WithoutParentPosters_KeepsOnlyEpisodePrimary()
+    {
+        var (episode, _, _) = BuildEpisode(seasonHasPoster: false, seriesHasPoster: false);
+        var options = new DtoOptions(false);
+
+        var dto = _dtoService.GetBaseItemDto(episode, options);
+
+        // With no season or series poster there is nothing to attach; the episode keeps its own primary.
+        Assert.NotNull(dto.ImageTags);
+        Assert.True(dto.ImageTags.ContainsKey(ImageType.Primary));
+        Assert.Null(dto.ParentPrimaryImageItemId);
+    }
+
+    private (Episode Episode, Season Season, Series Series) BuildEpisode(bool seasonHasPoster, bool seriesHasPoster = true)
+    {
+        // Non-local (http) paths keep aspect-ratio resolution off the image processor and on the
+        // item's default ratio, which is portrait (2/3) for Season/Series and 16:9 for Episode.
+        var series = new Series { Id = Guid.NewGuid(), Name = "Series" };
+        if (seriesHasPoster)
+        {
+            series.SetImage(new ItemImageInfo { Type = ImageType.Primary, Path = "http://test/series.jpg" }, 0);
+        }
+
+        var season = new Season { Id = Guid.NewGuid(), Name = "Season", SeriesId = series.Id };
+        if (seasonHasPoster)
+        {
+            season.SetImage(new ItemImageInfo { Type = ImageType.Primary, Path = "http://test/season.jpg" }, 0);
+        }
+
+        var episode = new Episode
+        {
+            Id = Guid.NewGuid(),
+            Name = "Episode",
+            SeasonId = season.Id,
+            SeriesId = series.Id
+        };
+        episode.SetImage(new ItemImageInfo { Type = ImageType.Primary, Path = "http://test/episode.jpg" }, 0);
+
+        _libraryManagerMock.Setup(x => x.GetItemById(season.Id)).Returns(season);
+        _libraryManagerMock.Setup(x => x.GetItemById(series.Id)).Returns(series);
+
+        return (episode, season, series);
+    }
+}