aboutsummaryrefslogtreecommitdiff
path: root/tests/Jellyfin.Server.Implementations.Tests/Library
diff options
context:
space:
mode:
Diffstat (limited to 'tests/Jellyfin.Server.Implementations.Tests/Library')
-rw-r--r--tests/Jellyfin.Server.Implementations.Tests/Library/DotIgnoreIgnoreRuleTest.cs101
-rw-r--r--tests/Jellyfin.Server.Implementations.Tests/Library/LibraryManager/LibraryRootIgnoreTests.cs93
-rw-r--r--tests/Jellyfin.Server.Implementations.Tests/Library/LibraryManagerConvertImageTests.cs50
-rw-r--r--tests/Jellyfin.Server.Implementations.Tests/Library/MediaSourceManagerTests.cs25
-rw-r--r--tests/Jellyfin.Server.Implementations.Tests/Library/MediaStreamSelectorTests.cs15
-rw-r--r--tests/Jellyfin.Server.Implementations.Tests/Library/QueryFiltersTests.cs534
-rw-r--r--tests/Jellyfin.Server.Implementations.Tests/Library/SqlSearchProviderTests.cs56
7 files changed, 872 insertions, 2 deletions
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/DotIgnoreIgnoreRuleTest.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/DotIgnoreIgnoreRuleTest.cs
index 03c0b4af39..94de2f7b23 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Library/DotIgnoreIgnoreRuleTest.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/DotIgnoreIgnoreRuleTest.cs
@@ -470,4 +470,105 @@ public class DotIgnoreIgnoreRuleTest
Directory.Delete(tempDir, true);
}
}
+
+ [Fact]
+ public void LibraryRoot_IgnoreFileAboveRoot_IsNotConsulted()
+ {
+ var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+ var libraryRoot = Path.Combine(tempDir, "Movies");
+ var movieDir = Path.Combine(libraryRoot, "Movie (2020)");
+ Directory.CreateDirectory(movieDir);
+
+ try
+ {
+ File.WriteAllText(Path.Combine(tempDir, ".ignore"), string.Empty);
+
+ var rule = new DotIgnoreIgnoreRule();
+ var fileInfo = new FileSystemMetadata
+ {
+ FullName = Path.Combine(movieDir, "Movie (2020).mkv"),
+ IsDirectory = false
+ };
+
+ // Without library roots the walk reaches the filesystem root
+ Assert.True(rule.ShouldIgnore(fileInfo, null));
+
+ rule.SetLibraryRootsProvider(() => [libraryRoot + Path.DirectorySeparatorChar]);
+ Assert.False(rule.ShouldIgnore(fileInfo, null));
+
+ // A .ignore in the library root itself still applies
+ File.WriteAllText(Path.Combine(libraryRoot, ".ignore"), "*.mkv");
+ rule.ClearDirectoryCache();
+ Assert.True(rule.ShouldIgnore(fileInfo, null));
+ }
+ finally
+ {
+ Directory.Delete(tempDir, true);
+ }
+ }
+
+ [Fact]
+ public void LibraryRoot_NestedRoots_StopAtOutermost()
+ {
+ var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+ var outerRoot = Path.Combine(tempDir, "Media");
+ var innerRoot = Path.Combine(outerRoot, "Movies");
+ Directory.CreateDirectory(innerRoot);
+
+ try
+ {
+ File.WriteAllText(Path.Combine(outerRoot, ".ignore"), "*.mkv");
+
+ var rule = new DotIgnoreIgnoreRule();
+ rule.SetLibraryRootsProvider(() => [innerRoot, outerRoot]);
+ var fileInfo = new FileSystemMetadata
+ {
+ FullName = Path.Combine(innerRoot, "Movie.mkv"),
+ IsDirectory = false
+ };
+
+ Assert.True(rule.ShouldIgnore(fileInfo, null));
+ }
+ finally
+ {
+ Directory.Delete(tempDir, true);
+ }
+ }
+
+ [Fact]
+ public void LibraryRoot_PathOutsideLibraries_WalksToFilesystemRoot()
+ {
+ var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+ var libraryRoot = Path.Combine(tempDir, "Movies");
+ var otherDir = Path.Combine(tempDir, "Other", "Sub");
+ Directory.CreateDirectory(libraryRoot);
+ Directory.CreateDirectory(otherDir);
+
+ try
+ {
+ File.WriteAllText(Path.Combine(tempDir, ".ignore"), string.Empty);
+
+ var rule = new DotIgnoreIgnoreRule();
+ rule.SetLibraryRootsProvider(() => [libraryRoot]);
+
+ // A sibling whose name only shares the root's prefix is not inside the library
+ var fileInfo = new FileSystemMetadata
+ {
+ FullName = Path.Combine(tempDir, "MoviesExtra", "Movie.mkv"),
+ IsDirectory = false
+ };
+ Assert.True(rule.ShouldIgnore(fileInfo, null));
+
+ fileInfo = new FileSystemMetadata
+ {
+ FullName = Path.Combine(otherDir, "Movie.mkv"),
+ IsDirectory = false
+ };
+ Assert.True(rule.ShouldIgnore(fileInfo, null));
+ }
+ finally
+ {
+ Directory.Delete(tempDir, true);
+ }
+ }
}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/LibraryManager/LibraryRootIgnoreTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/LibraryManager/LibraryRootIgnoreTests.cs
new file mode 100644
index 0000000000..f37aadbe8d
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/LibraryManager/LibraryRootIgnoreTests.cs
@@ -0,0 +1,93 @@
+using System;
+using System.IO;
+using AutoFixture;
+using AutoFixture.AutoMoq;
+using Emby.Naming.Common;
+using Emby.Server.Implementations.IO;
+using Emby.Server.Implementations.Library;
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Sorting;
+using MediaBrowser.Model.IO;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.Library.LibraryManager;
+
+public sealed class LibraryRootIgnoreTests : IDisposable
+{
+ private readonly string _tempDir;
+ private readonly string _userViewsPath;
+ private readonly string _libraryRoot;
+ private readonly FileSystemMetadata _movieFile;
+
+ public LibraryRootIgnoreTests()
+ {
+ _tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+ _userViewsPath = Path.Combine(_tempDir, "root", "default");
+ _libraryRoot = Path.Combine(_tempDir, "media", "Movies");
+ var movieDir = Path.Combine(_libraryRoot, "Movie (2020)");
+ Directory.CreateDirectory(movieDir);
+
+ // Ignores everything below it, but sits above the library root
+ File.WriteAllText(Path.Combine(_tempDir, ".ignore"), string.Empty);
+
+ _movieFile = new FileSystemMetadata
+ {
+ FullName = Path.Combine(movieDir, "Movie (2020).mkv"),
+ IsDirectory = false
+ };
+ }
+
+ public void Dispose()
+ {
+ Directory.Delete(_tempDir, true);
+ }
+
+ [Fact]
+ public void IgnoreFile_IgnoreFileAboveMblinkLibraryRoot_IsNotConsulted()
+ {
+ var libraryDir = Path.Combine(_userViewsPath, "Movies");
+ Directory.CreateDirectory(libraryDir);
+ File.WriteAllText(Path.Combine(libraryDir, "Movies.mblink"), _libraryRoot);
+
+ Assert.False(CreateLibraryManager().IgnoreFile(_movieFile, null));
+ }
+
+ [Fact]
+ public void IgnoreFile_UserViewsPathMissing_WalksToFilesystemRoot()
+ {
+ // Before root/default exists there are no library roots, so the .ignore above still applies
+ Assert.False(Directory.Exists(_userViewsPath));
+ Assert.True(CreateLibraryManager().IgnoreFile(_movieFile, null));
+ }
+
+ private Emby.Server.Implementations.Library.LibraryManager CreateLibraryManager()
+ {
+ var fixture = new Fixture().Customize(new AutoMoqCustomization());
+ fixture.Register(() => new NamingOptions());
+ var configMock = fixture.Freeze<Mock<IServerConfigurationManager>>();
+ configMock.Setup(c => c.ApplicationPaths.ProgramDataPath).Returns(_tempDir);
+ configMock.Setup(c => c.ApplicationPaths.DefaultUserViewsPath).Returns(_userViewsPath);
+ fixture.Freeze<Mock<IServerApplicationHost>>()
+ .Setup(h => h.ExpandVirtualPath(It.IsAny<string>()))
+ .Returns<string>(path => path);
+ fixture.Inject<IFileSystem>(new ManagedFileSystem(
+ NullLogger<ManagedFileSystem>.Instance,
+ configMock.Object.ApplicationPaths,
+ [new MbLinkShortcutHandler()]));
+
+ // The same instance LibraryManager hands the roots to must be the one evaluating the rules
+ var dotIgnoreRule = new DotIgnoreIgnoreRule();
+ fixture.Inject(dotIgnoreRule);
+
+ return fixture.Build<Emby.Server.Implementations.Library.LibraryManager>().Do(s => s.AddParts(
+ [dotIgnoreRule],
+ [],
+ [],
+ Array.Empty<IBaseItemComparer>(),
+ []))
+ .Create();
+ }
+}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/LibraryManagerConvertImageTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/LibraryManagerConvertImageTests.cs
new file mode 100644
index 0000000000..d374847e54
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/LibraryManagerConvertImageTests.cs
@@ -0,0 +1,50 @@
+using System;
+using System.Net;
+using System.Threading;
+using System.Threading.Tasks;
+using AutoFixture;
+using AutoFixture.AutoMoq;
+using Emby.Naming.Common;
+using MediaBrowser.Common.Net;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Configuration;
+using MediaBrowser.Model.Entities;
+using Moq;
+using Xunit;
+using ServerLibraryManager = Emby.Server.Implementations.Library.LibraryManager;
+
+namespace Jellyfin.Server.Implementations.Tests.Library;
+
+public class LibraryManagerConvertImageTests
+{
+ [Theory]
+ [InlineData(HttpStatusCode.NotFound)]
+ [InlineData(HttpStatusCode.Forbidden)]
+ public async Task ConvertImageToLocal_RejectedDownload_KeepsTheResponseAsInnerException(HttpStatusCode status)
+ {
+ // The Live TV guide reads the provider's error body off the inner exception to stop
+ // requesting images from an account that is refusing them.
+ const string Body = "{\"response\":\"MAX_IMAGE_DOWNLOADS\",\"code\":5002}";
+ var rejection = new HttpResponseBodyException("test", status, Body);
+
+ var fixture = new Fixture().Customize(new AutoMoqCustomization());
+ fixture.Register(() => new NamingOptions());
+ var configuration = fixture.Freeze<Mock<IServerConfigurationManager>>();
+ configuration.Setup(c => c.Configuration).Returns(new ServerConfiguration());
+ configuration.Setup(c => c.ApplicationPaths.ProgramDataPath).Returns("/data");
+ var providerManager = fixture.Freeze<Mock<IProviderManager>>();
+ providerManager.Setup(p => p.SaveImage(It.IsAny<BaseItem>(), It.IsAny<string>(), It.IsAny<ImageType>(), It.IsAny<int?>(), It.IsAny<CancellationToken>()))
+ .ThrowsAsync(rejection);
+ var manager = fixture.Create<ServerLibraryManager>();
+
+ var item = new Movie { Id = Guid.NewGuid(), Name = "Test" };
+ var image = new ItemImageInfo { Path = "https://example.com/image.jpg", Type = ImageType.Primary };
+
+ var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => manager.ConvertImageToLocal(item, image, 0, removeOnFailure: false));
+
+ Assert.Same(rejection, ex.InnerException);
+ }
+}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/MediaSourceManagerTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/MediaSourceManagerTests.cs
index 131cb23fa4..187d44559e 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Library/MediaSourceManagerTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/MediaSourceManagerTests.cs
@@ -151,6 +151,31 @@ namespace Jellyfin.Server.Implementations.Tests.Library
Assert.Equal(expectedIndex, mediaInfo.DefaultAudioStreamIndex);
}
+ [Fact]
+ public void SetDefaultAudioStreamIndex_VariantPreference_MatchesBaseCodeTrack()
+ {
+ _mockLocalizationManager
+ .Setup(m => m.FindLanguageInfo("pt-br"))
+ .Returns(new CultureDto("pt-br", "Portuguese (Brazil)", "pt-br", ["pt-br", "por"]));
+
+ var mediaInfo = new MediaSourceInfo
+ {
+ MediaStreams = new MediaStream[]
+ {
+ new() { Index = 0, Type = MediaStreamType.Video, IsDefault = true },
+ new() { Index = 1, Type = MediaStreamType.Audio, Language = "eng", IsDefault = true },
+ new() { Index = 2, Type = MediaStreamType.Audio, Language = "por", IsDefault = false }
+ }
+ };
+
+ _user.AudioLanguagePreference = "pt-br";
+ _user.PlayDefaultAudioTrack = false;
+
+ _mediaSourceManager.SetDefaultAudioAndSubtitleStreamIndices(_item, mediaInfo, _user);
+
+ Assert.Equal(2, mediaInfo.DefaultAudioStreamIndex);
+ }
+
[Theory]
// A remembered full track must not survive a switch to "only forced" (it falls through to
// the forced track here); a remembered forced track and "off" still must.
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/MediaStreamSelectorTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/MediaStreamSelectorTests.cs
index 07feae587b..3fc474816b 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Library/MediaStreamSelectorTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/MediaStreamSelectorTests.cs
@@ -1,5 +1,6 @@
using System;
using Emby.Server.Implementations.Library;
+using Jellyfin.Database.Implementations.Enums;
using MediaBrowser.Model.Entities;
using Xunit;
@@ -115,4 +116,18 @@ public class MediaStreamSelectorTests
Assert.Equal(expectedScore, MediaStreamSelector.GetStreamScore(stream, languagePref));
}
+
+ [Fact]
+ public void GetDefaultSubtitleStreamIndex_VariantPreference_PrefersVariantTrackOverBaseCodeTrack()
+ {
+ var streams = new MediaStream[]
+ {
+ new() { Index = 0, Type = MediaStreamType.Video },
+ new() { Index = 1, Type = MediaStreamType.Audio, Language = "eng", IsDefault = true },
+ new() { Index = 2, Type = MediaStreamType.Subtitle, Language = "por", IsExternal = true },
+ new() { Index = 3, Type = MediaStreamType.Subtitle, Language = "pt-br", IsExternal = true }
+ };
+
+ Assert.Equal(3, MediaStreamSelector.GetDefaultSubtitleStreamIndex(streams, ["pt-br", "por"], SubtitlePlaybackMode.Always, "eng"));
+ }
}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/QueryFiltersTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/QueryFiltersTests.cs
new file mode 100644
index 0000000000..72a20d7f98
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/QueryFiltersTests.cs
@@ -0,0 +1,534 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Security.Claims;
+using AutoFixture;
+using AutoFixture.AutoMoq;
+using Emby.Naming.Common;
+using Emby.Server.Implementations.Data;
+using Jellyfin.Api.Constants;
+using Jellyfin.Api.Controllers;
+using Jellyfin.Data;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Database.Implementations.Enums;
+using Jellyfin.Server.Implementations.Tests.Item;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Persistence;
+using MediaBrowser.Model.Configuration;
+using MediaBrowser.Model.Globalization;
+using MediaBrowser.Model.Library;
+using MediaBrowser.Model.Querying;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using Xunit;
+using BaseItemKind = Jellyfin.Data.Enums.BaseItemKind;
+using ServerLibraryManager = Emby.Server.Implementations.Library.LibraryManager;
+
+namespace Jellyfin.Server.Implementations.Tests.Library;
+
+public sealed class QueryFiltersTests : SqliteDbTestFixture
+{
+ private readonly DirectoryInfo _rootDirectory;
+ private readonly ItemTypeLookup _itemTypeLookup = new();
+ private readonly Mock<IUserViewManager> _userViewManager = new();
+ private readonly User _user = new("restricted", "auth", "reset")
+ {
+ MaxParentalRatingScore = 50
+ };
+
+ private readonly Guid _firstLibraryId = Guid.NewGuid();
+ private readonly Guid _secondLibraryId = Guid.NewGuid();
+ private readonly Guid _inaccessibleLibraryId = Guid.NewGuid();
+ private readonly Folder _folder = new() { Id = Guid.NewGuid() };
+ private readonly AggregateFolder _aggregateRoot = new() { Id = Guid.NewGuid() };
+ private readonly CollectionFolder _collection;
+ private readonly UserView _view;
+ private readonly UserRootFolder _userRoot;
+ private readonly FilterController _controller;
+
+ public QueryFiltersTests()
+ {
+ _rootDirectory = Directory.CreateTempSubdirectory("jellyfin-query-filters-");
+ _user.SetPreference(PreferenceKind.BlockedTags, ["blocked"]);
+
+ var fixture = new Fixture().Customize(new AutoMoqCustomization());
+ fixture.Register(() => new NamingOptions());
+ fixture.Inject<IItemRepository>(CreateBaseItemRepository(_itemTypeLookup));
+ fixture.Inject(new Lazy<IUserViewManager>(() => _userViewManager.Object));
+ var configuration = fixture.Freeze<Mock<IServerConfigurationManager>>();
+ configuration.Setup(c => c.Configuration).Returns(new ServerConfiguration());
+ configuration.Setup(c => c.ApplicationPaths.ProgramDataPath).Returns(_rootDirectory.FullName);
+ configuration.Setup(c => c.ApplicationPaths.DefaultUserViewsPath).Returns(_rootDirectory.FullName);
+
+ var libraryManager = fixture.Create<ServerLibraryManager>();
+ _userRoot = new UserRootFolder
+ {
+ Id = libraryManager.GetNewItemId(_rootDirectory.FullName, typeof(UserRootFolder)),
+ Path = _rootDirectory.FullName
+ };
+ _collection = new CollectionFolder
+ {
+ Id = Guid.NewGuid(),
+ PhysicalFolderIds = [_firstLibraryId]
+ };
+ _view = new UserView
+ {
+ Id = Guid.NewGuid(),
+ DisplayParentId = _collection.Id
+ };
+ var secondCollection = new CollectionFolder
+ {
+ Id = Guid.NewGuid(),
+ PhysicalFolderIds = [_secondLibraryId]
+ };
+ libraryManager.RegisterItem(_userRoot);
+ libraryManager.RegisterItem(_aggregateRoot);
+ libraryManager.RegisterItem(_collection);
+ libraryManager.RegisterItem(_view);
+ libraryManager.RegisterItem(_folder);
+
+ _userViewManager.Setup(m => m.GetUserViews(It.Is<UserViewQuery>(q => q.User == _user && q.IncludeHidden)))
+ .Returns([_collection, secondCollection]);
+ var userManager = fixture.Freeze<Mock<IUserManager>>();
+ userManager.Setup(m => m.GetUserById(_user.Id)).Returns(_user);
+ _controller = new FilterController(libraryManager, userManager.Object, Mock.Of<ILocalizationManager>())
+ {
+ ControllerContext = new ControllerContext
+ {
+ HttpContext = new DefaultHttpContext
+ {
+ User = new ClaimsPrincipal(new ClaimsIdentity(
+ [new Claim(InternalClaimTypes.UserId, _user.Id.ToString("N"))]))
+ }
+ }
+ };
+
+ using var context = CreateDbContext();
+ foreach (var id in new[] { _firstLibraryId, _secondLibraryId, _inaccessibleLibraryId, _folder.Id, _userRoot.Id, _aggregateRoot.Id })
+ {
+ context.BaseItems.Add(new BaseItemEntity
+ {
+ Id = id,
+ Type = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Folder],
+ IsFolder = true
+ });
+ }
+
+ context.SaveChanges();
+
+ SeedItems(BaseItemKind.Movie, 0, "PG", "G", "PG-13");
+ SeedItems(BaseItemKind.Series, 1, "TV-PG", "TV-G", "TV-14");
+ }
+
+ [Theory]
+ [InlineData(BaseItemKind.Movie, null)]
+ [InlineData(BaseItemKind.Series, null)]
+ [InlineData(BaseItemKind.Movie, "library")]
+ [InlineData(BaseItemKind.Series, "library")]
+ [InlineData(BaseItemKind.Movie, "view")]
+ [InlineData(BaseItemKind.Series, "view")]
+ [InlineData(BaseItemKind.Movie, "folder")]
+ [InlineData(BaseItemKind.Series, "folder")]
+ [InlineData(BaseItemKind.Movie, "userRoot")]
+ [InlineData(BaseItemKind.Series, "userRoot")]
+ [InlineData(BaseItemKind.Movie, "aggregateRoot")]
+ [InlineData(BaseItemKind.Series, "aggregateRoot")]
+ public void GetQueryFiltersLegacy_ReturnsAccessibleYearsAndRatings(BaseItemKind itemType, string? parent)
+ {
+ // A missing userId uses the authenticated user's access restrictions.
+ var result = _controller.GetQueryFiltersLegacy(null, GetParentId(parent), [itemType], []);
+ var filters = Assert.IsType<QueryFiltersLegacy>(result.Value);
+
+ AssertYearsAndRatings(itemType, parent, filters.Years, filters.OfficialRatings);
+ }
+
+ [Theory]
+ [InlineData(BaseItemKind.Movie)]
+ [InlineData(BaseItemKind.Series)]
+ public void GetQueryFiltersLegacy_NoAccessibleLibraries_ReturnsEmptyFilters(BaseItemKind itemType)
+ {
+ _userViewManager.Setup(m => m.GetUserViews(It.IsAny<UserViewQuery>())).Returns([]);
+
+ var result = _controller.GetQueryFiltersLegacy(null, null, [itemType], []);
+ var filters = Assert.IsType<QueryFiltersLegacy>(result.Value);
+
+ Assert.Empty(filters.Years);
+ Assert.Empty(filters.OfficialRatings);
+ Assert.Empty(filters.Tags);
+ Assert.Empty(filters.Genres);
+ }
+
+ [Theory]
+ [InlineData(BaseItemKind.Movie, null, true)]
+ [InlineData(BaseItemKind.Series, null, true)]
+ [InlineData(BaseItemKind.Movie, null, false)]
+ [InlineData(BaseItemKind.Series, null, false)]
+ [InlineData(BaseItemKind.Movie, "library", true)]
+ [InlineData(BaseItemKind.Series, "library", true)]
+ [InlineData(BaseItemKind.Movie, "library", false)]
+ [InlineData(BaseItemKind.Series, "library", false)]
+ [InlineData(BaseItemKind.Movie, "view", true)]
+ [InlineData(BaseItemKind.Series, "view", true)]
+ [InlineData(BaseItemKind.Movie, "view", false)]
+ [InlineData(BaseItemKind.Series, "view", false)]
+ [InlineData(BaseItemKind.Movie, "folder", true)]
+ [InlineData(BaseItemKind.Series, "folder", true)]
+ [InlineData(BaseItemKind.Movie, "folder", false)]
+ [InlineData(BaseItemKind.Series, "folder", false)]
+ [InlineData(BaseItemKind.Movie, "userRoot", true)]
+ [InlineData(BaseItemKind.Series, "userRoot", true)]
+ [InlineData(BaseItemKind.Movie, "aggregateRoot", true)]
+ [InlineData(BaseItemKind.Series, "aggregateRoot", true)]
+ public void GetQueryFilters_ReturnsAccessibleYearsAndRatings(BaseItemKind itemType, string? parent, bool recursive)
+ {
+ var filters = GetFilters(itemType, GetParentId(parent), recursive);
+
+ AssertYearsAndRatings(itemType, parent, filters.Years, filters.OfficialRatings);
+ }
+
+ [Theory]
+ [InlineData(BaseItemKind.Movie, true)]
+ [InlineData(BaseItemKind.Series, true)]
+ [InlineData(BaseItemKind.Movie, false)]
+ [InlineData(BaseItemKind.Series, false)]
+ public void GetQueryFilters_Recursive_ControlsWhetherDescendantsContribute(BaseItemKind itemType, bool recursive)
+ {
+ using var context = CreateDbContext();
+ var nestedFolder = new BaseItemEntity
+ {
+ Id = Guid.NewGuid(),
+ Type = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Folder],
+ IsFolder = true,
+ ParentId = _folder.Id,
+ TopParentId = _firstLibraryId
+ };
+ context.BaseItems.Add(nestedFolder);
+ context.SaveChanges();
+ var descendantId = AddItem(itemType, _firstLibraryId, nestedFolder.Id, 2019, "Descendant");
+ context.AncestorIds.Add(new AncestorId
+ {
+ ItemId = descendantId,
+ Item = context.BaseItems.Find(descendantId)!,
+ ParentItemId = _folder.Id,
+ ParentItem = context.BaseItems.Find(_folder.Id)!
+ });
+ context.SaveChanges();
+
+ var filters = GetFilters(itemType, _folder.Id, recursive);
+ var firstYear = itemType == BaseItemKind.Movie ? 2001 : 2002;
+ var firstRating = itemType == BaseItemKind.Movie ? "PG" : "TV-PG";
+
+ Assert.Equal(recursive ? [firstYear, 2019] : new[] { firstYear }, filters.Years);
+ Assert.Equal(recursive ? ["Descendant", firstRating] : new[] { firstRating }, filters.OfficialRatings);
+ }
+
+ [Theory]
+ [InlineData(BaseItemKind.Movie, false)]
+ [InlineData(BaseItemKind.Series, false)]
+ [InlineData(BaseItemKind.Movie, true)]
+ [InlineData(BaseItemKind.Series, true)]
+ public void GetQueryFilters_MissingMetadata_DoesNotExcludeTheOtherField(BaseItemKind itemType, bool withParent)
+ {
+ using (var context = CreateDbContext())
+ {
+ foreach (var item in context.BaseItems)
+ {
+ item.ProductionYear = null;
+ item.OfficialRating = null;
+ }
+
+ context.SaveChanges();
+ }
+
+ AddItem(itemType, _firstLibraryId, _folder.Id, null, "PG");
+ AddItem(itemType, _firstLibraryId, _folder.Id, 2019, null);
+ AddItem(itemType, _firstLibraryId, _folder.Id, 2019, string.Empty);
+ AddItem(itemType, _firstLibraryId, _folder.Id, -1, "PG");
+
+ var filters = GetFilters(itemType, withParent ? _collection.Id : null);
+
+ Assert.Equal([2019], filters.Years);
+ Assert.Equal(["PG"], filters.OfficialRatings);
+ }
+
+ [Theory]
+ [InlineData(BaseItemKind.Movie, false)]
+ [InlineData(BaseItemKind.Series, false)]
+ [InlineData(BaseItemKind.Movie, true)]
+ [InlineData(BaseItemKind.Series, true)]
+ public void GetQueryFilters_AllowedTags_OnlyIncludesAllowedItems(BaseItemKind itemType, bool withParent)
+ {
+ _user.SetPreference(PreferenceKind.AllowedTags, ["allowed"]);
+ var allowedId = AddItem(itemType, _firstLibraryId, _folder.Id, 2017, "Allowed");
+ AddItemValue(allowedId, ItemValueType.Tags, "allowed");
+ var blockedId = AddItem(itemType, _firstLibraryId, _folder.Id, 2018, "Blocked", blockedTag: true);
+ AddItemValue(blockedId, ItemValueType.Tags, "allowed");
+
+ var filters = GetFilters(itemType, withParent ? _collection.Id : null);
+
+ Assert.Equal([2017], filters.Years);
+ Assert.Equal(["Allowed"], filters.OfficialRatings);
+ Assert.Equal(["allowed"], filters.Tags);
+ }
+
+ [Theory]
+ [InlineData(BaseItemKind.Movie)]
+ [InlineData(BaseItemKind.Series)]
+ public void GetQueryFilters_NoAccessibleLibraries_ReturnsEmptyFilters(BaseItemKind itemType)
+ {
+ _userViewManager.Setup(m => m.GetUserViews(It.IsAny<UserViewQuery>())).Returns([]);
+
+ var filters = GetFilters(itemType);
+
+ Assert.Empty(filters.Years);
+ Assert.Empty(filters.OfficialRatings);
+ Assert.Empty(filters.Genres);
+ Assert.Empty(filters.Tags);
+ Assert.Empty(filters.AudioLanguages);
+ Assert.Empty(filters.SubtitleLanguages);
+ }
+
+ [Theory]
+ [InlineData(BaseItemKind.Movie, false)]
+ [InlineData(BaseItemKind.Series, false)]
+ [InlineData(BaseItemKind.Movie, true)]
+ [InlineData(BaseItemKind.Series, true)]
+ public void GetQueryFilters_IsMovie_UsesTheSameFilterForMetadata(BaseItemKind itemType, bool withParent)
+ {
+ var result = _controller.GetQueryFilters(
+ userId: null,
+ parentId: withParent ? _collection.Id : null,
+ includeItemTypes: [itemType],
+ isAiring: null,
+ isMovie: itemType != BaseItemKind.Movie,
+ isSports: null,
+ isKids: null,
+ isNews: null,
+ isSeries: null,
+ recursive: null);
+ var filters = Assert.IsType<QueryFilters>(result.Value);
+
+ Assert.Empty(filters.Years);
+ Assert.Empty(filters.OfficialRatings);
+ }
+
+ [Theory]
+ [InlineData(BaseItemKind.Movie, false)]
+ [InlineData(BaseItemKind.Series, false)]
+ [InlineData(BaseItemKind.Movie, true)]
+ [InlineData(BaseItemKind.Series, true)]
+ public void GetQueryFilters_PreservesGenresTagsAndLanguages(BaseItemKind itemType, bool withParent)
+ {
+ var isMovie = itemType == BaseItemKind.Movie;
+ var visibleId = AddItem(itemType, _firstLibraryId, _folder.Id, isMovie ? 2001 : 2002, isMovie ? "PG" : "TV-PG");
+ AddItemValue(visibleId, ItemValueType.Tags, "visible");
+ AddItemValue(visibleId, ItemValueType.Genre, "Drama");
+ var hiddenId = AddItem(itemType, _inaccessibleLibraryId, _inaccessibleLibraryId, 2099, "Hidden");
+ AddItemValue(hiddenId, ItemValueType.Tags, "hidden");
+ AddItemValue(hiddenId, ItemValueType.Genre, "Horror");
+
+ // Languages come from episodes; years and ratings come from the series.
+ if (!isMovie)
+ {
+ visibleId = AddItem(BaseItemKind.Episode, _firstLibraryId, visibleId, 2088, "Episode rating");
+ hiddenId = AddItem(BaseItemKind.Episode, _inaccessibleLibraryId, hiddenId, 2089, "Hidden episode rating");
+ }
+
+ AddLanguages(visibleId, "eng", "spa");
+ AddLanguages(hiddenId, "ger", "fre");
+ using (var context = CreateDbContext())
+ {
+ foreach (var name in new[] { "Drama", "Horror" })
+ {
+ var id = Guid.NewGuid();
+ context.BaseItems.Add(new BaseItemEntity
+ {
+ Id = id,
+ Type = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Genre],
+ Name = name,
+ CleanName = name.ToLowerInvariant(),
+ PresentationUniqueKey = id.ToString("N")
+ });
+ }
+
+ context.SaveChanges();
+ }
+
+ var filters = GetFilters(itemType, withParent ? _collection.Id : null);
+
+ Assert.Equal(["Drama"], filters.Genres.Select(g => g.Name));
+ Assert.NotEqual(Guid.Empty, Assert.Single(filters.Genres).Id);
+ Assert.Equal(["visible"], filters.Tags);
+ var audioLanguage = Assert.Single(filters.AudioLanguages);
+ Assert.Equal("eng", audioLanguage.Value);
+ Assert.Equal("eng", audioLanguage.Name);
+ var subtitleLanguage = Assert.Single(filters.SubtitleLanguages);
+ Assert.Equal("spa", subtitleLanguage.Value);
+ Assert.Equal("spa", subtitleLanguage.Name);
+ AssertYearsAndRatings(itemType, withParent ? "library" : null, filters.Years, filters.OfficialRatings);
+ }
+
+ protected override void Dispose(bool disposing)
+ {
+ base.Dispose(disposing);
+ if (disposing)
+ {
+ _rootDirectory.Delete(true);
+ }
+ }
+
+ private QueryFilters GetFilters(BaseItemKind itemType, Guid? parentId = null, bool? recursive = null)
+ {
+ var result = _controller.GetQueryFilters(
+ userId: null,
+ parentId: parentId,
+ includeItemTypes: [itemType],
+ isAiring: null,
+ isMovie: null,
+ isSports: null,
+ isKids: null,
+ isNews: null,
+ isSeries: null,
+ recursive: recursive);
+ return Assert.IsType<QueryFilters>(result.Value);
+ }
+
+ private Guid? GetParentId(string? parent)
+ {
+ return parent switch
+ {
+ null => null,
+ "library" => _collection.Id,
+ "view" => _view.Id,
+ "folder" => _folder.Id,
+ "userRoot" => _userRoot.Id,
+ "aggregateRoot" => _aggregateRoot.Id,
+ _ => throw new ArgumentOutOfRangeException(nameof(parent))
+ };
+ }
+
+ private static void AssertYearsAndRatings(BaseItemKind itemType, string? parent, IReadOnlyList<int> years, IReadOnlyList<string> officialRatings)
+ {
+ var offset = itemType == BaseItemKind.Movie ? 0 : 1;
+ int[] expectedYears = parent switch
+ {
+ "folder" => [2001 + offset],
+ "library" or "view" => [2001 + offset, 2005 + offset],
+ _ => [2001 + offset, 2005 + offset, 2011 + offset]
+ };
+ string[] ratings = itemType == BaseItemKind.Movie ? ["PG", "G", "PG-13"] : ["TV-PG", "TV-G", "TV-14"];
+
+ Assert.Equal(expectedYears, years);
+ Assert.Equal(ratings.Take(expectedYears.Length).Order(StringComparer.Ordinal), officialRatings);
+ }
+
+ private void SeedItems(BaseItemKind kind, int yearOffset, string firstRating, string siblingRating, string secondRating)
+ {
+ // Unsorted, duplicate, and missing values exercise metadata aggregation.
+ AddItem(kind, _secondLibraryId, _secondLibraryId, 2011 + yearOffset, secondRating);
+ AddItem(kind, _firstLibraryId, _firstLibraryId, 2005 + yearOffset, siblingRating);
+ AddItem(kind, _firstLibraryId, _folder.Id, 2001 + yearOffset, firstRating);
+ AddItem(kind, _firstLibraryId, _folder.Id, 2001 + yearOffset, firstRating);
+ AddItem(kind, _firstLibraryId, _folder.Id, null, null);
+ AddItem(kind, _firstLibraryId, _folder.Id, 0, string.Empty);
+
+ // Distinct metadata reveals any restricted items in the response.
+ AddItem(kind, _inaccessibleLibraryId, _inaccessibleLibraryId, 1991 + yearOffset, "Inaccessible library");
+ AddItem(kind, _firstLibraryId, _folder.Id, 2021 + yearOffset, "Above parental limit", parentalRating: 100);
+ AddItem(kind, _firstLibraryId, _folder.Id, 2031 + yearOffset, "Blocked tag", blockedTag: true);
+ }
+
+ private Guid AddItem(BaseItemKind kind, Guid libraryId, Guid parentId, int? year, string? rating, int parentalRating = 10, bool blockedTag = false)
+ {
+ using var context = CreateDbContext();
+ var item = new BaseItemEntity
+ {
+ Id = Guid.NewGuid(),
+ Type = _itemTypeLookup.BaseItemKindNames[kind],
+ MediaType = "Video",
+ IsFolder = kind == BaseItemKind.Series,
+ IsMovie = kind == BaseItemKind.Movie,
+ IsVirtualItem = false,
+ TopParentId = libraryId,
+ ParentId = parentId,
+ ProductionYear = year,
+ OfficialRating = rating,
+ InheritedParentalRatingValue = parentalRating
+ };
+ context.BaseItems.Add(item);
+
+ // Virtual roots and collection views are not stored ancestors.
+ foreach (var ancestorId in new[] { libraryId, parentId }.Distinct())
+ {
+ context.AncestorIds.Add(new AncestorId
+ {
+ ItemId = item.Id,
+ Item = item,
+ ParentItemId = ancestorId,
+ ParentItem = context.BaseItems.Find(ancestorId)!
+ });
+ }
+
+ context.SaveChanges();
+ if (blockedTag)
+ {
+ AddItemValue(item.Id, ItemValueType.Tags, "blocked");
+ }
+
+ return item.Id;
+ }
+
+ private void AddItemValue(Guid itemId, ItemValueType type, string value)
+ {
+ using var context = CreateDbContext();
+ var itemValue = context.ItemValues.SingleOrDefault(t => t.Type == type && t.Value == value);
+ if (itemValue is null)
+ {
+ itemValue = new ItemValue
+ {
+ ItemValueId = Guid.NewGuid(),
+ Type = type,
+ Value = value,
+ CleanValue = value.ToLowerInvariant()
+ };
+ context.ItemValues.Add(itemValue);
+ }
+
+ context.ItemValuesMap.Add(new ItemValueMap
+ {
+ ItemId = itemId,
+ ItemValueId = itemValue.ItemValueId,
+ Item = context.BaseItems.Find(itemId)!,
+ ItemValue = itemValue
+ });
+ context.SaveChanges();
+ }
+
+ private void AddLanguages(Guid itemId, string audioLanguage, string subtitleLanguage)
+ {
+ using var context = CreateDbContext();
+ var item = context.BaseItems.Find(itemId)!;
+ context.MediaStreamInfos.AddRange(
+ new MediaStreamInfo
+ {
+ ItemId = itemId,
+ Item = item,
+ StreamIndex = 0,
+ StreamType = MediaStreamTypeEntity.Audio,
+ Language = audioLanguage
+ },
+ new MediaStreamInfo
+ {
+ ItemId = itemId,
+ Item = item,
+ StreamIndex = 1,
+ StreamType = MediaStreamTypeEntity.Subtitle,
+ Language = subtitleLanguage
+ });
+ context.SaveChanges();
+ }
+}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/SqlSearchProviderTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/SqlSearchProviderTests.cs
index 89ca037256..eefde9bed6 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Library/SqlSearchProviderTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/SqlSearchProviderTests.cs
@@ -32,12 +32,24 @@ public sealed class SqlSearchProviderTests : SqliteDbTestFixture
private static readonly Guid _primaryId = Guid.Parse("cccccccc-cccc-cccc-cccc-cccccccccccc");
private static readonly Guid _versionId = Guid.Parse("dddddddd-dddd-dddd-dddd-dddddddddddd");
+ // A movie nested one folder below the library, so only its AncestorIds rows reach the library.
+ private static readonly Guid _franchiseFolderId = Guid.Parse("eeeeeeee-eeee-eeee-eeee-eeeeeeeeeeee");
+ private static readonly Guid _nestedMovieId = Guid.Parse("ffffffff-ffff-ffff-ffff-ffffffffffff");
+
+ private readonly QueryPlanRecorder _recorder;
private readonly SqlSearchProvider _provider;
private readonly Mock<ILibraryManager> _libraryManager = new();
private readonly User _user = new("test", "auth-provider", "reset-provider");
public SqlSearchProviderTests()
+ : this(new QueryPlanRecorder())
{
+ }
+
+ private SqlSearchProviderTests(QueryPlanRecorder recorder)
+ : base(recorder)
+ {
+ _recorder = recorder;
var itemTypeLookup = new ItemTypeLookup();
var movieTypeName = itemTypeLookup.BaseItemKindNames[BaseItemKind.Movie]!;
var folderTypeName = itemTypeLookup.BaseItemKindNames[BaseItemKind.Folder]!;
@@ -49,6 +61,15 @@ public sealed class SqlSearchProviderTests : SqliteDbTestFixture
context.BaseItems.Add(CreateLibrary(_movie4KLibraryId, folderTypeName, "Movies-4K", "/movies-4k"));
context.BaseItems.Add(CreateMovie(_primaryId, movieTypeName, _movie4KLibraryId, null));
context.BaseItems.Add(CreateMovie(_versionId, movieTypeName, _movieLibraryId, _primaryId));
+ context.BaseItems.Add(CreateLibrary(_franchiseFolderId, folderTypeName, "Franchise", "/movies/franchise"));
+ var nestedMovie = CreateMovie(_nestedMovieId, movieTypeName, _movieLibraryId, null);
+ nestedMovie.Name = "Moana";
+ nestedMovie.CleanName = "moana";
+ nestedMovie.SortName = "Moana";
+ nestedMovie.ParentId = _franchiseFolderId;
+ context.BaseItems.Add(nestedMovie);
+ context.AncestorIds.Add(new AncestorId { ItemId = _nestedMovieId, ParentItemId = _franchiseFolderId, Item = null!, ParentItem = null! });
+ context.AncestorIds.Add(new AncestorId { ItemId = _nestedMovieId, ParentItemId = _movieLibraryId, Item = null!, ParentItem = null! });
context.SaveChanges();
}
@@ -88,6 +109,31 @@ public sealed class SqlSearchProviderTests : SqliteDbTestFixture
Assert.Equal([_primaryId], hits);
}
+ [Fact]
+ public async Task SearchAsync_WithParent_FindsItemsNestedBelowIt()
+ {
+ RestrictUserTo(_movieLibraryId);
+
+ Assert.Equal([_nestedMovieId], await SearchAsync("moana", _movieLibraryId).ConfigureAwait(true));
+ Assert.Equal([_nestedMovieId], await SearchAsync("moana", _franchiseFolderId).ConfigureAwait(true));
+ Assert.Empty(await SearchAsync("moana", _movie4KLibraryId).ConfigureAwait(true));
+ }
+
+ [Fact]
+ public async Task SearchAsync_WithParent_SeeksDescendantsByParent()
+ {
+ RestrictUserTo(_movieLibraryId);
+ _recorder.Commands.Clear();
+
+ await SearchAsync("moana", _franchiseFolderId).ConfigureAwait(true);
+
+ var query = Assert.Single(_recorder.Commands, c => c.Sql.Contains("\"AncestorIds\"", StringComparison.Ordinal));
+ // The ParentId alternative keeps BaseItems as the driver; the descendants become a list built once, not a per-row probe.
+ var plan = Explain(query);
+ Assert.Contains(plan, line => line.Contains("COVERING INDEX IX_AncestorIds_ParentItemId_ItemId (ParentItemId=?)", StringComparison.Ordinal));
+ Assert.DoesNotContain(plan, line => line.Contains("sqlite_autoindex_AncestorIds_1", StringComparison.Ordinal));
+ }
+
private void RestrictUserTo(params Guid[] libraryIds)
{
_libraryManager
@@ -95,10 +141,10 @@ public sealed class SqlSearchProviderTests : SqliteDbTestFixture
.Callback<InternalItemsQuery, User>((query, _) => query.TopParentIds = libraryIds);
}
- private async Task<List<Guid>> SearchAsync()
+ private async Task<List<Guid>> SearchAsync(string searchTerm = "coco", Guid? parentId = null)
{
var results = await _provider.SearchAsync(
- new SearchProviderQuery { SearchTerm = "coco", UserId = _user.Id, Limit = 10 },
+ new SearchProviderQuery { SearchTerm = searchTerm, UserId = _user.Id, ParentId = parentId, Limit = 10 },
CancellationToken.None).ConfigureAwait(false);
return results.Select(r => r.ItemId).ToList();
@@ -131,4 +177,10 @@ public sealed class SqlSearchProviderTests : SqliteDbTestFixture
PresentationUniqueKey = (primaryVersionId ?? id).ToString("N"),
PrimaryVersionId = primaryVersionId
};
+
+ private string[] Explain(RecordedCommand query)
+ {
+ using var context = CreateDbContext();
+ return QueryPlanRecorder.Explain(context, query);
+ }
}