Fix cross-library versions

This commit is contained in:
Shadowghost 2026-09-11 08:35:21 +02:00
parent 220f720589
commit 911edfb64d
8 changed files with 395 additions and 22 deletions

View file

@ -143,11 +143,19 @@ public class SearchManager : ISearchManager
baseQuery = _queryHelpers.ApplyAccessFiltering(dbContext, baseQuery, accessFilter);
var allowedIds = await baseQuery
.Select(e => e.Id)
.ToHashSetAsync(cancellationToken)
var allowed = await baseQuery
.Select(e => new { e.Id, e.PrimaryVersionId })
.ToListAsync(cancellationToken)
.ConfigureAwait(false);
var allowedIds = allowed.Select(e => e.Id).ToHashSet();
// A provider can return both an alternate version and the primary it belongs to, and the
// two are one item to the user.
allowedIds.ExceptWith(allowed
.Where(e => e.PrimaryVersionId.HasValue && allowedIds.Contains(e.PrimaryVersionId.Value))
.Select(e => e.Id));
if (allowedIds.Count == candidates.Count)
{
return candidates;

View file

@ -115,6 +115,7 @@ public class SqlSearchProvider : IInternalSearchProvider
dbQuery = ApplyMediaTypeFilter(dbQuery, query.MediaTypes);
dbQuery = ApplyParentFilter(dbQuery, query.ParentId);
dbQuery = ApplyUserAccessFilter(dbContext, dbQuery, query);
dbQuery = ExcludeVersionsOfMatchedPrimaries(dbQuery);
// Compute the score in SQL: the ternary translates to a CASE WHEN. CleanName is
// the pre-normalized (lowercase, diacritic-stripped) form, so we score against it
@ -193,6 +194,12 @@ public class SqlSearchProvider : IInternalSearchProvider
return query.Where(e => e.ParentId == pid || e.Parents!.Any(p => p.ParentItemId == pid));
}
private static IQueryable<BaseItemEntity> ExcludeVersionsOfMatchedPrimaries(IQueryable<BaseItemEntity> query)
{
var matched = query;
return query.Where(e => e.PrimaryVersionId == null || !matched.Any(p => p.Id == e.PrimaryVersionId));
}
private IQueryable<BaseItemEntity> ApplyUserAccessFilter(
JellyfinDbContext dbContext,
IQueryable<BaseItemEntity> query,

View file

@ -1,3 +1,5 @@
#pragma warning disable RS0030 // Do not use banned APIs: Guid == is required inside EF expression trees.
using System;
using System.Collections.Generic;
using System.Linq;
@ -172,7 +174,7 @@ public sealed class MovieSimilarItemsProvider : ILocalSimilarItemsProvider<Movie
var allCandidateIdsList = allCandidateIds.ToList();
var accessibleItems = await baseQuery
.WhereOneOrMany(allCandidateIdsList, e => e.Id)
.Select(e => new { e.Id, e.PresentationUniqueKey })
.Select(e => new { e.Id, e.PresentationUniqueKey, e.PrimaryVersionId })
.ToListAsync(cancellationToken).ConfigureAwait(false);
// Phase 3: Pick top IDs per source, dedup by PresentationUniqueKey
@ -189,6 +191,9 @@ public sealed class MovieSimilarItemsProvider : ILocalSimilarItemsProvider<Movie
var orderedIds = accessibleItems
.Where(x => scores.ContainsKey(x.Id))
.OrderByDescending(x => scores.GetValueOrDefault(x.Id))
// Two versions of one movie score the same, so name the primary as the
// representative of the group rather than whichever came back first.
.ThenBy(x => x.PrimaryVersionId.HasValue)
.DistinctBy(x => x.PresentationUniqueKey)
.Take(limit)
.Select(x => x.Id)
@ -245,6 +250,11 @@ public sealed class MovieSimilarItemsProvider : ILocalSimilarItemsProvider<Movie
result[id] = [];
}
var hiddenVersionIds = context.BaseItems.AsNoTracking()
.Where(e => e.PrimaryVersionId != null
&& context.BaseItems.Any(p => p.Id == e.PrimaryVersionId && p.TopParentId == e.TopParentId))
.Select(e => e.Id);
foreach (var (valueType, weight) in _itemValueDimensions)
{
var sourceRows = await context.ItemValuesMap.AsNoTracking()
@ -260,7 +270,7 @@ public sealed class MovieSimilarItemsProvider : ILocalSimilarItemsProvider<Movie
}
var candidateRows = await context.ItemValuesMap.AsNoTracking()
.Where(m => !m.Item.PrimaryVersionId.HasValue && m.ItemValue.Type == valueType && allKeys.Contains(m.ItemValue.CleanValue))
.Where(m => !hiddenVersionIds.Contains(m.ItemId) && m.ItemValue.Type == valueType && allKeys.Contains(m.ItemValue.CleanValue))
.Select(m => new { m.ItemId, Key = m.ItemValue.CleanValue })
.ToListAsync(cancellationToken).ConfigureAwait(false);
@ -276,7 +286,7 @@ public sealed class MovieSimilarItemsProvider : ILocalSimilarItemsProvider<Movie
if (personSourceRows.Count > 0)
{
var personCandidateRows = await context.PeopleBaseItemMap.AsNoTracking()
.Where(m => !m.Item.PrimaryVersionId.HasValue)
.Where(m => !hiddenVersionIds.Contains(m.ItemId))
.Where(m => context.PeopleBaseItemMap
.Where(s => sourceIds.Contains(s.ItemId) && _scoredPersonTypes.Contains(s.People.PersonType))
.Select(s => s.PeopleId)

View file

@ -465,16 +465,23 @@ public sealed partial class BaseItemRepository
baseQuery = ApplyParentalRestrictions(context, baseQuery, filter);
// Exclude alternate versions (have PrimaryVersionId set) and owned non-extra items.
// Extras (trailers, etc.) have OwnerId set but also have ExtraType set — keep those.
// Hide alternate versions behind the primary of their library, and exclude owned non-extra
// items. Extras (trailers, etc.) have OwnerId set but also have ExtraType set — keep those.
if (!filter.IncludeOwnedItems)
{
baseQuery = baseQuery.Where(e => e.PrimaryVersionId == null && (e.OwnerId == null || e.ExtraType != null));
baseQuery = ApplyAlternateVersionFiltering(context, baseQuery)
.Where(e => e.OwnerId == null || e.ExtraType != null);
}
return baseQuery;
}
private static IQueryable<BaseItemEntity> ApplyAlternateVersionFiltering(
JellyfinDbContext context,
IQueryable<BaseItemEntity> baseQuery)
=> baseQuery.Where(e => e.PrimaryVersionId == null
|| !context.BaseItems.Any(p => p.Id == e.PrimaryVersionId && p.TopParentId == e.TopParentId));
/// <summary>
/// Restricts a query to the libraries the user may open, exempting requested by-name items.
/// </summary>

View file

@ -807,12 +807,16 @@ public sealed partial class BaseItemRepository
{
// Exclude owned non-extra items from general queries.
// Extras (trailers, etc.) have OwnerId set but also have ExtraType set - keep those.
// Alternate versions (PrimaryVersionId set) are normally excluded too, but resume queries
// keep them so the actually-played version can surface instead of collapsing onto the primary,
// and the library scan keeps them so a merged version is not mistaken for a new item.
baseQuery = filter.IsResumable == true || filter.IncludeAlternateVersions
? baseQuery.Where(e => e.OwnerId == null || e.ExtraType != null)
: baseQuery.Where(e => e.PrimaryVersionId == null && (e.OwnerId == null || e.ExtraType != null));
baseQuery = baseQuery.Where(e => e.OwnerId == null || e.ExtraType != null);
// Alternate versions (PrimaryVersionId set) are normally hidden behind their primary, but
// resume queries keep them so the actually-played version can surface instead of collapsing
// onto the primary, and the library scan keeps them so a merged version is not mistaken for
// a new item.
if (filter.IsResumable != true && !filter.IncludeAlternateVersions)
{
baseQuery = ApplyAlternateVersionFiltering(context, baseQuery);
}
}
if (filter.OwnerIds.Length > 0)

View file

@ -13,13 +13,18 @@ namespace Jellyfin.Server.Implementations.Tests.Item;
public sealed class BaseItemRepositoryGroupingTests : SqliteDbTestFixture
{
private static readonly Guid _movieLibraryId = Guid.Parse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa");
private static readonly Guid _movie4KLibraryId = Guid.Parse("bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb");
private readonly BaseItemRepository _repository;
private readonly string _movieTypeName;
private readonly string _folderTypeName;
public BaseItemRepositoryGroupingTests()
{
var itemTypeLookup = new ItemTypeLookup();
_movieTypeName = itemTypeLookup.BaseItemKindNames[BaseItemKind.Movie];
_folderTypeName = itemTypeLookup.BaseItemKindNames[BaseItemKind.Folder];
_repository = CreateBaseItemRepository(itemTypeLookup);
}
@ -67,6 +72,118 @@ public sealed class BaseItemRepositoryGroupingTests : SqliteDbTestFixture
Assert.Equal(firstId, item.Id);
}
[Fact]
public void GetItemList_LibraryWithoutThePrimaryOfTheGroup_KeepsTheVersionVisible()
{
var primaryId = Guid.Parse("33333333-3333-3333-3333-333333333333");
var versionId = Guid.Parse("44444444-4444-4444-4444-444444444444");
var sameLibraryPrimaryId = Guid.Parse("55555555-5555-5555-5555-555555555555");
var sameLibraryVersionId = Guid.Parse("66666666-6666-6666-6666-666666666666");
SeedCrossLibraryGroup(primaryId, versionId, sameLibraryPrimaryId, sameLibraryVersionId);
var result = _repository.GetItemList(CreateLibraryQuery(_movieLibraryId));
// The version stands in for the group in the library it lives in, because its primary is in
// a library of its own; a group merged inside this library still collapses onto its primary.
Assert.Contains(result, i => i.Id.Equals(versionId));
Assert.Contains(result, i => i.Id.Equals(sameLibraryPrimaryId));
Assert.DoesNotContain(result, i => i.Id.Equals(sameLibraryVersionId));
Assert.DoesNotContain(result, i => i.Id.Equals(primaryId));
}
[Fact]
public void GetItemList_LibraryHoldingThePrimary_ReturnsThePrimary()
{
var primaryId = Guid.Parse("33333333-3333-3333-3333-333333333333");
var versionId = Guid.Parse("44444444-4444-4444-4444-444444444444");
SeedCrossLibraryGroup(primaryId, versionId);
var result = _repository.GetItemList(CreateLibraryQuery(_movie4KLibraryId));
var item = Assert.Single(result);
Assert.Equal(primaryId, item.Id);
}
[Fact]
public void GetItemList_BothLibrariesOfACrossLibraryGroup_ReturnsItOnce()
{
var primaryId = Guid.Parse("33333333-3333-3333-3333-333333333333");
var versionId = Guid.Parse("44444444-4444-4444-4444-444444444444");
SeedCrossLibraryGroup(primaryId, versionId);
var result = _repository.GetItemList(CreateLibraryQuery(_movieLibraryId, _movie4KLibraryId));
// With both libraries in scope the presentation key grouping collapses the version.
var item = Assert.Single(result);
Assert.Equal(primaryId, item.Id);
}
[Fact]
public void GetItems_LibraryWithoutThePrimaryOfTheGroup_CountsWhatItLists()
{
var primaryId = Guid.Parse("33333333-3333-3333-3333-333333333333");
var versionId = Guid.Parse("44444444-4444-4444-4444-444444444444");
SeedCrossLibraryGroup(primaryId, versionId);
var listed = _repository.GetItemList(CreateLibraryQuery(_movieLibraryId)).Count;
var query = CreateLibraryQuery(_movieLibraryId);
query.EnableTotalRecordCount = true;
query.Limit = 1;
// The total the client pages against has to agree with the listing.
Assert.Equal(1, listed);
Assert.Equal(listed, _repository.GetItems(query).TotalRecordCount);
}
private static InternalItemsQuery CreateLibraryQuery(params Guid[] topParentIds)
{
return new InternalItemsQuery(new Database.Implementations.Entities.User("test", "auth", "reset"))
{
IncludeItemTypes = [BaseItemKind.Movie],
TopParentIds = topParentIds
};
}
private void SeedCrossLibraryGroup(
Guid primaryId,
Guid versionId,
Guid? sameLibraryPrimaryId = null,
Guid? sameLibraryVersionId = null)
{
using var ctx = CreateDbContext();
ctx.BaseItems.Add(CreateFolderEntity(_movieLibraryId, "Movies"));
ctx.BaseItems.Add(CreateFolderEntity(_movie4KLibraryId, "Movies-4K"));
// The 4K version heads the group and lives in a library of its own.
ctx.BaseItems.Add(CreateMovieEntity(primaryId, "Movie - 4K", primaryId.ToString("N"), null, _movie4KLibraryId));
ctx.BaseItems.Add(CreateMovieEntity(versionId, "Movie", primaryId.ToString("N"), primaryId, _movieLibraryId));
if (sameLibraryPrimaryId.HasValue && sameLibraryVersionId.HasValue)
{
ctx.BaseItems.Add(CreateMovieEntity(sameLibraryPrimaryId.Value, "Other - 4K", sameLibraryPrimaryId.Value.ToString("N"), null, _movieLibraryId));
ctx.BaseItems.Add(CreateMovieEntity(sameLibraryVersionId.Value, "Other", sameLibraryPrimaryId.Value.ToString("N"), sameLibraryPrimaryId.Value, _movieLibraryId));
}
ctx.SaveChanges();
}
private BaseItemEntity CreateFolderEntity(Guid id, string name)
{
return new BaseItemEntity
{
Id = id,
Type = _folderTypeName,
Name = name,
Path = "/" + name,
IsFolder = true
};
}
private static InternalItemsQuery CreateQuery()
{
// IncludeOwnedItems keeps the alternate version rows in the query so the
@ -78,13 +195,15 @@ public sealed class BaseItemRepositoryGroupingTests : SqliteDbTestFixture
};
}
private BaseItemEntity CreateMovieEntity(Guid id, string name, string presentationKey, Guid? primaryVersionId)
private BaseItemEntity CreateMovieEntity(Guid id, string name, string presentationKey, Guid? primaryVersionId, Guid? libraryId = null)
{
return new BaseItemEntity
{
Id = id,
Type = _movieTypeName,
Name = name,
ParentId = libraryId,
TopParentId = libraryId,
PresentationUniqueKey = presentationKey,
PrimaryVersionId = primaryVersionId,
MediaType = "Video",

View file

@ -10,6 +10,7 @@ using Jellyfin.Database.Implementations.Entities;
using Jellyfin.Server.Implementations.Tests.Item;
using MediaBrowser.Controller.Configuration;
using MediaBrowser.Controller.Dto;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Movies;
using MediaBrowser.Controller.Library;
using MediaBrowser.Model.Configuration;
@ -26,9 +27,14 @@ namespace Jellyfin.Server.Implementations.Tests.Library;
/// </summary>
public sealed class MovieSimilarItemsProviderTests : SqliteDbTestFixture
{
private static readonly Guid _movieLibraryId = Guid.Parse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa");
private static readonly Guid _movie4KLibraryId = Guid.Parse("bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb");
private readonly MovieSimilarItemsProvider _provider;
private readonly Mock<ILibraryManager> _libraryManager = new();
private readonly User _user = new("test", "auth-provider", "reset-provider");
private readonly string _movieTypeName;
private readonly string _folderTypeName;
private readonly Guid _source = Guid.NewGuid();
private readonly Guid _sourceAlternate = Guid.NewGuid();
@ -36,10 +42,19 @@ public sealed class MovieSimilarItemsProviderTests : SqliteDbTestFixture
private readonly Guid _similarAlternate = Guid.NewGuid();
private readonly Guid _unrelated = Guid.NewGuid();
// A second scenario, in two libraries and on a genre of its own, for the group whose primary the
// user may not be able to reach at all.
private readonly Guid _crossSource = Guid.NewGuid();
private readonly Guid _crossLibraryPrimary = Guid.NewGuid();
private readonly Guid _crossLibraryVersion = Guid.NewGuid();
private readonly Guid _sameLibraryPrimary = Guid.NewGuid();
private readonly Guid _sameLibraryVersion = Guid.NewGuid();
public MovieSimilarItemsProviderTests()
{
var itemTypeLookup = new ItemTypeLookup();
_movieTypeName = itemTypeLookup.BaseItemKindNames[BaseItemKind.Movie]!;
_folderTypeName = itemTypeLookup.BaseItemKindNames[BaseItemKind.Folder]!;
using (var context = CreateDbContext())
{
@ -53,7 +68,7 @@ public sealed class MovieSimilarItemsProviderTests : SqliteDbTestFixture
CreateDbContextFactory(),
CreateBaseItemRepository(itemTypeLookup),
serverConfigurationManager.Object,
new Mock<ILibraryManager>().Object);
_libraryManager.Object);
}
[Fact]
@ -80,10 +95,52 @@ public sealed class MovieSimilarItemsProviderTests : SqliteDbTestFixture
Assert.DoesNotContain(_sourceAlternate, items);
}
private async Task<List<Guid>> GetSimilarItemsAsync()
[Fact]
public async Task GetSimilarItems_UserWithoutThePrimarysLibrary_OffersTheVersion()
{
// The user may only open the library the 1080p version is in, so its primary is out of reach
// and the version is all that is left to stand in for the group.
RestrictUserTo(_movieLibraryId);
var items = await GetSimilarItemsAsync(_crossSource).ConfigureAwait(true);
Assert.Contains(_crossLibraryVersion, items);
Assert.DoesNotContain(_crossLibraryPrimary, items);
}
[Fact]
public async Task GetSimilarItems_UserWithBothLibraries_OffersThePrimaryOfTheGroupOnce()
{
RestrictUserTo(_movieLibraryId, _movie4KLibraryId);
var items = await GetSimilarItemsAsync(_crossSource).ConfigureAwait(true);
Assert.Contains(_crossLibraryPrimary, items);
Assert.DoesNotContain(_crossLibraryVersion, items);
}
[Fact]
public async Task GetSimilarItems_GroupMergedInsideOneLibrary_StillOffersOnlyThePrimary()
{
RestrictUserTo(_movieLibraryId, _movie4KLibraryId);
var items = await GetSimilarItemsAsync(_crossSource).ConfigureAwait(true);
Assert.Contains(_sameLibraryPrimary, items);
Assert.DoesNotContain(_sameLibraryVersion, items);
}
private void RestrictUserTo(params Guid[] libraryIds)
{
_libraryManager
.Setup(l => l.ConfigureUserAccess(It.IsAny<InternalItemsQuery>(), It.IsAny<User>()))
.Callback<InternalItemsQuery, User>((query, _) => query.TopParentIds = libraryIds);
}
private async Task<List<Guid>> GetSimilarItemsAsync(Guid? sourceId = null)
{
var results = await _provider.GetSimilarItemsAsync(
new Movie { Id = _source, Name = "Source" },
new Movie { Id = sourceId ?? _source, Name = "Source" },
new SimilarItemsQuery { User = _user, Limit = 10, DtoOptions = new DtoOptions() },
CancellationToken.None).ConfigureAwait(false);
@ -102,19 +159,52 @@ public sealed class MovieSimilarItemsProviderTests : SqliteDbTestFixture
var similarAlternate = AddMovie(context, _similarAlternate, "Similar 4K", primaryVersionId: _similar);
var unrelated = AddMovie(context, _unrelated, "Unrelated", primaryVersionId: null);
// The second scenario scores on a genre of its own, so it stays out of the results above.
var crossLibrary = CreateItemValue("Science Fiction", "science fiction");
AddLibrary(context, _movieLibraryId, "Movies");
AddLibrary(context, _movie4KLibraryId, "Movies-4K");
var crossSource = AddMovie(context, _crossSource, "Cross Source", primaryVersionId: null, libraryId: _movieLibraryId);
// The 4K version heads the group and lives in a library of its own.
var crossLibraryPrimary = AddMovie(context, _crossLibraryPrimary, "Coco 4K", primaryVersionId: null, libraryId: _movie4KLibraryId);
var crossLibraryVersion = AddMovie(context, _crossLibraryVersion, "Coco", primaryVersionId: _crossLibraryPrimary, libraryId: _movieLibraryId);
// A group merged inside one library, as a control.
var sameLibraryPrimary = AddMovie(context, _sameLibraryPrimary, "Up 4K", primaryVersionId: null, libraryId: _movieLibraryId);
var sameLibraryVersion = AddMovie(context, _sameLibraryVersion, "Up", primaryVersionId: _sameLibraryPrimary, libraryId: _movieLibraryId);
context.Users.Add(_user);
context.ItemValues.AddRange(shared, other);
context.ItemValues.AddRange(shared, other, crossLibrary);
context.ItemValuesMap.AddRange(
CreateMap(source, shared),
CreateMap(sourceAlternate, shared),
CreateMap(similar, shared),
CreateMap(similarAlternate, shared),
CreateMap(unrelated, other));
CreateMap(unrelated, other),
CreateMap(crossSource, crossLibrary),
CreateMap(crossLibraryPrimary, crossLibrary),
CreateMap(crossLibraryVersion, crossLibrary),
CreateMap(sameLibraryPrimary, crossLibrary),
CreateMap(sameLibraryVersion, crossLibrary));
context.SaveChanges();
}
private BaseItemEntity AddMovie(JellyfinDbContext context, Guid id, string name, Guid? primaryVersionId)
private void AddLibrary(JellyfinDbContext context, Guid id, string name)
{
context.BaseItems.Add(new BaseItemEntity
{
Id = id,
Type = _folderTypeName,
Name = name,
Path = "/" + name,
IsFolder = true
});
}
private BaseItemEntity AddMovie(JellyfinDbContext context, Guid id, string name, Guid? primaryVersionId, Guid? libraryId = null)
{
var item = new BaseItemEntity
{
@ -122,6 +212,8 @@ public sealed class MovieSimilarItemsProviderTests : SqliteDbTestFixture
Type = _movieTypeName,
Name = name,
SortName = name,
ParentId = libraryId,
TopParentId = libraryId,
MediaType = "Video",
IsMovie = true,
IsFolder = false,

View file

@ -0,0 +1,126 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Emby.Server.Implementations.Data;
using Emby.Server.Implementations.Library.Search;
using Jellyfin.Database.Implementations;
using Jellyfin.Database.Implementations.Entities;
using Jellyfin.Server.Implementations.Item;
using Jellyfin.Server.Implementations.Tests.Item;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Library;
using Moq;
using Xunit;
using BaseItemKind = Jellyfin.Data.Enums.BaseItemKind;
namespace Jellyfin.Server.Implementations.Tests.Library;
/// <summary>
/// Covers what <see cref="SqlSearchProvider"/> returns for a version group merged across two
/// libraries: the primary represents the group wherever it is visible, and the version stands in
/// for it for a user who cannot open the library the primary lives in.
/// </summary>
public sealed class SqlSearchProviderTests : SqliteDbTestFixture
{
private static readonly Guid _movieLibraryId = Guid.Parse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa");
private static readonly Guid _movie4KLibraryId = Guid.Parse("bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb");
private static readonly Guid _primaryId = Guid.Parse("cccccccc-cccc-cccc-cccc-cccccccccccc");
private static readonly Guid _versionId = Guid.Parse("dddddddd-dddd-dddd-dddd-dddddddddddd");
private readonly SqlSearchProvider _provider;
private readonly Mock<ILibraryManager> _libraryManager = new();
private readonly User _user = new("test", "auth-provider", "reset-provider");
public SqlSearchProviderTests()
{
var itemTypeLookup = new ItemTypeLookup();
var movieTypeName = itemTypeLookup.BaseItemKindNames[BaseItemKind.Movie]!;
var folderTypeName = itemTypeLookup.BaseItemKindNames[BaseItemKind.Folder]!;
using (var context = CreateDbContext())
{
context.Users.Add(_user);
context.BaseItems.Add(CreateLibrary(_movieLibraryId, folderTypeName, "Movies", "/movies"));
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.SaveChanges();
}
var userManager = new Mock<IUserManager>();
userManager.Setup(u => u.GetUserById(_user.Id)).Returns(_user);
_provider = new SqlSearchProvider(
CreateDbContextFactory(),
itemTypeLookup,
_libraryManager.Object,
userManager.Object,
CreateBaseItemRepository(itemTypeLookup));
}
[Fact]
public async Task SearchAsync_UserWithoutThePrimarysLibrary_FindsTheVersion()
{
RestrictUserTo(_movieLibraryId);
var hits = await SearchAsync().ConfigureAwait(true);
Assert.Equal([_versionId], hits);
}
[Fact]
public async Task SearchAsync_UserWithBothLibraries_FindsThePrimaryOnce()
{
RestrictUserTo(_movieLibraryId, _movie4KLibraryId);
var hits = await SearchAsync().ConfigureAwait(true);
Assert.Equal([_primaryId], hits);
}
private void RestrictUserTo(params Guid[] libraryIds)
{
_libraryManager
.Setup(l => l.ConfigureUserAccess(It.IsAny<InternalItemsQuery>(), It.IsAny<User>()))
.Callback<InternalItemsQuery, User>((query, _) => query.TopParentIds = libraryIds);
}
private async Task<List<Guid>> SearchAsync()
{
var results = await _provider.SearchAsync(
new SearchProviderQuery { SearchTerm = "coco", UserId = _user.Id, Limit = 10 },
CancellationToken.None).ConfigureAwait(false);
return results.Select(r => r.ItemId).ToList();
}
private static BaseItemEntity CreateLibrary(Guid id, string typeName, string name, string path)
=> new()
{
Id = id,
Type = typeName,
Name = name,
Path = path,
IsFolder = true
};
private static BaseItemEntity CreateMovie(Guid id, string typeName, Guid libraryId, Guid? primaryVersionId)
=> new()
{
Id = id,
Type = typeName,
Name = "Coco",
CleanName = "coco",
SortName = "Coco",
MediaType = "Video",
IsMovie = true,
IsFolder = false,
IsVirtualItem = false,
ParentId = libraryId,
TopParentId = libraryId,
PresentationUniqueKey = (primaryVersionId ?? id).ToString("N"),
PrimaryVersionId = primaryVersionId
};
}