Years, Ratings for filters endpoints

This commit is contained in:
Ethan Pippin 2026-11-12 00:42:03 -05:00
parent 7b8c6451b5
commit 2cfcb9ac0c
8 changed files with 685 additions and 23 deletions

View file

@ -4199,6 +4199,30 @@ namespace Emby.Server.Implementations.Library
return _itemRepository.GetQueryFiltersLegacy(query);
}
/// <inheritdoc />
public IReadOnlyList<int> GetYears(InternalItemsQuery query)
{
if (query.User is not null)
{
AddUserToQuery(query, query.User);
}
SetTopParentOrAncestorIds(query);
return _itemRepository.GetYears(query);
}
/// <inheritdoc />
public IReadOnlyList<string> GetOfficialRatings(InternalItemsQuery query)
{
if (query.User is not null)
{
AddUserToQuery(query, query.User);
}
SetTopParentOrAncestorIds(query);
return _itemRepository.GetOfficialRatings(query);
}
/// <inheritdoc />
public IReadOnlyList<string> GetTagNames(InternalItemsQuery query)
{

View file

@ -82,7 +82,8 @@ public class FilterController : BaseJellyfinApiController
IncludeItemTypes = includeItemTypes,
Recursive = true,
EnableTotalRecordCount = false,
AncestorIds = [folder.Id],
// Let LibraryManager scope virtual roots to the user's accessible libraries.
AncestorIds = folder is UserRootFolder or AggregateFolder ? [] : [folder.Id],
DtoOptions = new DtoOptions
{
Fields = [],
@ -160,8 +161,7 @@ public class FilterController : BaseJellyfinApiController
var streamLanguageQuery = new InternalItemsQuery(user)
{
// It's possible that different langauges are only available on alternative versions.
// To fetch them all, owned items are included.
// Include alternate versions that may have additional languages.
IncludeOwnedItems = true,
IncludeItemTypes = includeItemTypes,
DtoOptions = new DtoOptions
@ -178,7 +178,7 @@ public class FilterController : BaseJellyfinApiController
IsSeries = isSeries
};
var tagQuery = new InternalItemsQuery(user)
var itemQuery = new InternalItemsQuery(user)
{
IncludeItemTypes = includeItemTypes,
DtoOptions = new DtoOptions
@ -197,22 +197,23 @@ public class FilterController : BaseJellyfinApiController
if ((recursive ?? true) || parentItem is UserView || parentItem is ICollectionFolder)
{
var ancestorIds = parentItem is null ? Array.Empty<Guid>() : new[] { parentItem.Id };
// Let LibraryManager scope virtual roots to the user's accessible libraries.
Guid[] ancestorIds = parentItem is null or UserRootFolder or AggregateFolder ? [] : [parentItem.Id];
genreQuery.AncestorIds = ancestorIds;
streamLanguageQuery.AncestorIds = ancestorIds;
tagQuery.AncestorIds = ancestorIds;
itemQuery.AncestorIds = ancestorIds;
}
else
{
genreQuery.Parent = parentItem;
streamLanguageQuery.Parent = parentItem;
tagQuery.Parent = parentItem;
itemQuery.Parent = parentItem;
}
if ((includeItemTypes.Contains(BaseItemKind.Series) || includeItemTypes.Contains(BaseItemKind.Season))
&& !includeItemTypes.Contains(BaseItemKind.Episode))
{
// streams are joined on epsiodes not shows or seasons
// Series and season languages come from their episodes.
streamLanguageQuery.IncludeItemTypes = [.. includeItemTypes, BaseItemKind.Episode];
}
@ -237,7 +238,9 @@ public class FilterController : BaseJellyfinApiController
}).ToArray();
}
filters.Tags = _libraryManager.GetTagNames(tagQuery);
filters.Tags = _libraryManager.GetTagNames(itemQuery);
filters.Years = _libraryManager.GetYears(itemQuery);
filters.OfficialRatings = _libraryManager.GetOfficialRatings(itemQuery);
if (includeItemTypes.Contains(BaseItemKind.Movie)
|| includeItemTypes.Contains(BaseItemKind.Series)

View file

@ -599,6 +599,30 @@ public sealed partial class BaseItemRepository
return dbContext.BaseItems.Where(e => e.ParentId == id).All(BuildLeafIsPlayedFilter(dbContext, user.Id));
}
/// <inheritdoc />
public IReadOnlyList<int> GetYears(InternalItemsQuery filter)
{
ArgumentNullException.ThrowIfNull(filter);
PrepareFilterQuery(filter);
using var context = _dbProvider.CreateDbContext();
var baseQuery = PrepareItemQuery(context, filter);
baseQuery = TranslateQuery(baseQuery, context, filter);
return GetYears(baseQuery);
}
/// <inheritdoc />
public IReadOnlyList<string> GetOfficialRatings(InternalItemsQuery filter)
{
ArgumentNullException.ThrowIfNull(filter);
PrepareFilterQuery(filter);
using var context = _dbProvider.CreateDbContext();
var baseQuery = PrepareItemQuery(context, filter);
baseQuery = TranslateQuery(baseQuery, context, filter);
return GetOfficialRatings(baseQuery);
}
/// <inheritdoc />
public QueryFiltersLegacy GetQueryFiltersLegacy(InternalItemsQuery filter)
{
@ -610,20 +634,8 @@ public sealed partial class BaseItemRepository
baseQuery = TranslateQuery(baseQuery, context, filter);
var matchingItemIds = baseQuery.Select(e => e.Id);
var years = baseQuery
.Where(e => e.ProductionYear != null && e.ProductionYear > 0)
.Select(e => e.ProductionYear!.Value)
.Distinct()
.OrderBy(y => y)
.ToArray();
var officialRatings = baseQuery
.Where(e => e.OfficialRating != null && e.OfficialRating != string.Empty)
.Select(e => e.OfficialRating!)
.Distinct()
.OrderBy(r => r)
.ToArray();
var years = GetYears(baseQuery);
var officialRatings = GetOfficialRatings(baseQuery);
var tags = context.ItemValuesMap
.Join(
@ -659,4 +671,24 @@ public sealed partial class BaseItemRepository
Genres = genres
};
}
private static IReadOnlyList<int> GetYears(IQueryable<BaseItemEntity> query)
{
return query
.Where(e => e.ProductionYear != null && e.ProductionYear > 0)
.Select(e => e.ProductionYear!.Value)
.Distinct()
.OrderBy(y => y)
.ToArray();
}
private static IReadOnlyList<string> GetOfficialRatings(IQueryable<BaseItemEntity> query)
{
return query
.Where(e => e.OfficialRating != null && e.OfficialRating != string.Empty)
.Select(e => e.OfficialRating!)
.Distinct()
.OrderBy(r => r)
.ToArray();
}
}

View file

@ -850,6 +850,20 @@ namespace MediaBrowser.Controller.Library
/// <returns>Aggregated filter values.</returns>
QueryFiltersLegacy GetQueryFiltersLegacy(InternalItemsQuery query);
/// <summary>
/// Gets the distinct, sorted production years of the matching items.
/// </summary>
/// <param name="query">The query filter.</param>
/// <returns>The production years.</returns>
IReadOnlyList<int> GetYears(InternalItemsQuery query);
/// <summary>
/// Gets the distinct, sorted official ratings of the matching items.
/// </summary>
/// <param name="query">The query filter.</param>
/// <returns>The official ratings.</returns>
IReadOnlyList<string> GetOfficialRatings(InternalItemsQuery query);
/// <summary>
/// Gets a list of all distinct tags of the matching items.
/// </summary>

View file

@ -148,6 +148,20 @@ public interface IItemRepository
/// <returns>Aggregated filter values.</returns>
QueryFiltersLegacy GetQueryFiltersLegacy(InternalItemsQuery filter);
/// <summary>
/// Gets the distinct, sorted production years of the matching items.
/// </summary>
/// <param name="filter">The query filter.</param>
/// <returns>The production years.</returns>
IReadOnlyList<int> GetYears(InternalItemsQuery filter);
/// <summary>
/// Gets the distinct, sorted official ratings of the matching items.
/// </summary>
/// <param name="filter">The query filter.</param>
/// <returns>The official ratings.</returns>
IReadOnlyList<string> GetOfficialRatings(InternalItemsQuery filter);
/// <summary>
/// Gets whether all children of the requested item have been played.
/// </summary>

View file

@ -15,6 +15,8 @@ namespace MediaBrowser.Model.Querying
Genres = Array.Empty<NameGuidPair>();
AudioLanguages = Array.Empty<NameValuePair>();
SubtitleLanguages = Array.Empty<NameValuePair>();
Years = Array.Empty<int>();
OfficialRatings = Array.Empty<string>();
}
public IReadOnlyList<NameGuidPair> Genres { get; set; }
@ -24,5 +26,9 @@ namespace MediaBrowser.Model.Querying
public IReadOnlyList<NameValuePair> AudioLanguages { get; set; }
public IReadOnlyList<NameValuePair> SubtitleLanguages { get; set; }
public IReadOnlyList<int> Years { get; set; }
public IReadOnlyList<string> OfficialRatings { get; set; }
}
}

View file

@ -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();
}
}

View file

@ -0,0 +1,35 @@
using System.Net.Http.Json;
using System.Text.Json;
using System.Threading.Tasks;
using Xunit;
namespace Jellyfin.Server.Integration.Tests.Controllers;
public sealed class FilterControllerTests : IClassFixture<JellyfinApplicationFactory>
{
private readonly JellyfinApplicationFactory _factory;
private static string? _accessToken;
public FilterControllerTests(JellyfinApplicationFactory factory)
{
_factory = factory;
}
[Theory]
[InlineData("Movie")]
[InlineData("Series")]
public async Task GetQueryFilters_EmptyLibrary_SerializesEmptyArrays(string itemType)
{
using var client = _factory.CreateClient();
client.DefaultRequestHeaders.AddAuthHeader(_accessToken ??= await AuthHelper.CompleteStartupAsync(client));
var filters = await client.GetFromJsonAsync<JsonElement>($"/Items/Filters2?includeItemTypes={itemType}", TestContext.Current.CancellationToken);
foreach (var field in new[] { "Years", "OfficialRatings", "Genres", "Tags", "AudioLanguages", "SubtitleLanguages" })
{
var values = filters.GetProperty(field);
Assert.Equal(JsonValueKind.Array, values.ValueKind);
Assert.Equal(0, values.GetArrayLength());
}
}
}