Merge remote-tracking branch 'upstream/master' into network-rewrite

tests/Jellyfin.Controller.Tests/BaseItemManagerTests.cs

@@ -20,17 +20,13 @@ namespace Jellyfin.Controller.Tests
         {
             BaseItem item = (BaseItem)Activator.CreateInstance(itemType)!;
 
-            var libraryOptions = new LibraryOptions
-            {
-                TypeOptions = new[]
+            var libraryTypeOptions = itemType == typeof(Book)
+                ? new TypeOptions
                 {
-                    new TypeOptions
-                    {
-                        Type = "Book",
-                        MetadataFetchers = new[] { "LibraryEnabled" }
-                    }
+                    Type = "Book",
+                    MetadataFetchers = new[] { "LibraryEnabled" }
                 }
-            };
+                : null;
 
             var serverConfiguration = new ServerConfiguration();
             foreach (var typeConfig in serverConfiguration.MetadataOptions)
@@ -43,7 +39,7 @@ namespace Jellyfin.Controller.Tests
                 .Returns(serverConfiguration);
 
             var baseItemManager = new BaseItemManager(serverConfigurationManager.Object);
-            var actual = baseItemManager.IsMetadataFetcherEnabled(item, libraryOptions, fetcherName);
+            var actual = baseItemManager.IsMetadataFetcherEnabled(item, libraryTypeOptions, fetcherName);
 
             Assert.Equal(expected, actual);
         }
@@ -57,17 +53,13 @@ namespace Jellyfin.Controller.Tests
         {
             BaseItem item = (BaseItem)Activator.CreateInstance(itemType)!;
 
-            var libraryOptions = new LibraryOptions
-            {
-                TypeOptions = new[]
+            var libraryTypeOptions = itemType == typeof(Book)
+                ? new TypeOptions
                 {
-                    new TypeOptions
-                    {
-                        Type = "Book",
-                        ImageFetchers = new[] { "LibraryEnabled" }
-                    }
+                    Type = "Book",
+                    ImageFetchers = new[] { "LibraryEnabled" }
                 }
-            };
+                : null;
 
             var serverConfiguration = new ServerConfiguration();
             foreach (var typeConfig in serverConfiguration.MetadataOptions)
@@ -80,7 +72,7 @@ namespace Jellyfin.Controller.Tests
                 .Returns(serverConfiguration);
 
             var baseItemManager = new BaseItemManager(serverConfigurationManager.Object);
-            var actual = baseItemManager.IsImageFetcherEnabled(item, libraryOptions, fetcherName);
+            var actual = baseItemManager.IsImageFetcherEnabled(item, libraryTypeOptions, fetcherName);
 
             Assert.Equal(expected, actual);
         }

tests/Jellyfin.Controller.Tests/Entities/BaseItemTests.cs

@@ -0,0 +1,18 @@
+using MediaBrowser.Controller.Entities;
+using Xunit;
+
+namespace Jellyfin.Controller.Tests.Entities
+{
+    public class BaseItemTests
+    {
+        [Theory]
+        [InlineData("", "")]
+        [InlineData("1", "0000000001")]
+        [InlineData("t", "t")]
+        [InlineData("test", "test")]
+        [InlineData("test1", "test0000000001")]
+        [InlineData("1test 2", "0000000001test 0000000002")]
+        public void BaseItem_ModifySortChunks_Valid(string input, string expected)
+            => Assert.Equal(expected, BaseItem.ModifySortChunks(input));
+    }
+}

tests/Jellyfin.MediaEncoding.Tests/Probing/ProbeResultNormalizerTests.cs

@@ -65,6 +65,7 @@ namespace Jellyfin.MediaEncoding.Tests.Probing
             Assert.True(res.VideoStream.IsDefault);
             Assert.False(res.VideoStream.IsExternal);
             Assert.False(res.VideoStream.IsForced);
+            Assert.False(res.VideoStream.IsHearingImpaired);
             Assert.False(res.VideoStream.IsInterlaced);
             Assert.False(res.VideoStream.IsTextSubtitleStream);
             Assert.Equal(13d, res.VideoStream.Level);
@@ -142,16 +143,19 @@ namespace Jellyfin.MediaEncoding.Tests.Probing
             Assert.Equal(MediaStreamType.Subtitle, res.MediaStreams[3].Type);
             Assert.Equal("DVDSUB", res.MediaStreams[3].Codec);
             Assert.Null(res.MediaStreams[3].Title);
+            Assert.False(res.MediaStreams[3].IsHearingImpaired);
 
             Assert.Equal("eng", res.MediaStreams[4].Language);
             Assert.Equal(MediaStreamType.Subtitle, res.MediaStreams[4].Type);
             Assert.Equal("mov_text", res.MediaStreams[4].Codec);
             Assert.Null(res.MediaStreams[4].Title);
+            Assert.True(res.MediaStreams[4].IsHearingImpaired);
 
             Assert.Equal("eng", res.MediaStreams[5].Language);
             Assert.Equal(MediaStreamType.Subtitle, res.MediaStreams[5].Type);
             Assert.Equal("mov_text", res.MediaStreams[5].Codec);
             Assert.Equal("Commentary", res.MediaStreams[5].Title);
+            Assert.False(res.MediaStreams[5].IsHearingImpaired);
         }
 
         [Fact]

tests/Jellyfin.MediaEncoding.Tests/Test Data/Probing/video_mp4_metadata.json

@@ -206,7 +206,7 @@
                 "lyrics": 0,
                 "karaoke": 0,
                 "forced": 0,
-                "hearing_impaired": 0,
+                "hearing_impaired": 1,
                 "visual_impaired": 0,
                 "clean_effects": 0,
                 "attached_pic": 0,

tests/Jellyfin.Model.Tests/Dlna/StreamBuilderTests.cs

@@ -21,8 +21,8 @@ namespace Jellyfin.Model.Tests
         [Theory]
         // Chrome
         [InlineData("Chrome", "mp4-h264-aac-vtt-2600k", PlayMethod.DirectPlay)] // #6450
-        [InlineData("Chrome", "mp4-h264-ac3-aac-srt-2600k", PlayMethod.DirectPlay)] // #6450
-        [InlineData("Chrome", "mp4-h264-ac3-aacDef-srt-2600k", PlayMethod.DirectPlay)] // #6450
+        [InlineData("Chrome", "mp4-h264-ac3-aac-srt-2600k", PlayMethod.DirectStream, TranscodeReason.SecondaryAudioNotSupported, "Remux")] // #6450
+        [InlineData("Chrome", "mp4-h264-ac3-aacDef-srt-2600k", PlayMethod.DirectStream, TranscodeReason.SecondaryAudioNotSupported, "Remux")] // #6450
         [InlineData("Chrome", "mp4-h264-ac3-aacExt-srt-2600k", PlayMethod.DirectStream, TranscodeReason.AudioIsExternal)] // #6450
         [InlineData("Chrome", "mp4-h264-ac3-srt-2600k", PlayMethod.DirectStream, TranscodeReason.AudioCodecNotSupported)] // #6450
         [InlineData("Chrome", "mp4-hevc-aac-srt-15200k", PlayMethod.Transcode, TranscodeReason.VideoCodecNotSupported, "Transcode")]
@@ -32,8 +32,8 @@ namespace Jellyfin.Model.Tests
         [InlineData("Chrome", "mkv-vp9-vorbis-vtt-2600k", PlayMethod.DirectPlay, (TranscodeReason)0, "Remux")] // #6450
         // Firefox
         [InlineData("Firefox", "mp4-h264-aac-vtt-2600k", PlayMethod.DirectPlay)] // #6450
-        [InlineData("Firefox", "mp4-h264-ac3-aac-srt-2600k", PlayMethod.DirectPlay)] // #6450
-        [InlineData("Firefox", "mp4-h264-ac3-aacDef-srt-2600k", PlayMethod.DirectPlay)] // #6450
+        [InlineData("Firefox", "mp4-h264-ac3-aac-srt-2600k", PlayMethod.DirectStream, TranscodeReason.SecondaryAudioNotSupported, "Remux")] // #6450
+        [InlineData("Firefox", "mp4-h264-ac3-aacDef-srt-2600k", PlayMethod.DirectStream, TranscodeReason.SecondaryAudioNotSupported, "Remux")] // #6450
         [InlineData("Firefox", "mp4-h264-ac3-aacExt-srt-2600k", PlayMethod.DirectStream, TranscodeReason.AudioIsExternal)] // #6450
         [InlineData("Firefox", "mp4-h264-ac3-srt-2600k", PlayMethod.DirectStream, TranscodeReason.AudioCodecNotSupported)] // #6450
         [InlineData("Firefox", "mp4-hevc-aac-srt-15200k", PlayMethod.Transcode, TranscodeReason.VideoCodecNotSupported, "Transcode")]
@@ -59,11 +59,11 @@ namespace Jellyfin.Model.Tests
         [InlineData("AndroidPixel", "mp4-hevc-ac3-aac-srt-15200k", PlayMethod.Transcode, TranscodeReason.ContainerBitrateExceedsLimit, "Transcode")]
         // Yatse
         [InlineData("Yatse", "mp4-h264-aac-srt-2600k", PlayMethod.DirectPlay, (TranscodeReason)0, "Remux")] // #6450
-        [InlineData("Yatse", "mp4-h264-ac3-aac-srt-2600k", PlayMethod.DirectPlay, (TranscodeReason)0, "Remux")] // #6450
-        [InlineData("Yatse", "mp4-h264-ac3-aacDef-srt-2600k", PlayMethod.DirectPlay, (TranscodeReason)0, "Remux")] // #6450
+        [InlineData("Yatse", "mp4-h264-ac3-aac-srt-2600k", PlayMethod.DirectStream, TranscodeReason.SecondaryAudioNotSupported, "Remux")] // #6450
+        [InlineData("Yatse", "mp4-h264-ac3-aacDef-srt-2600k", PlayMethod.DirectStream, TranscodeReason.SecondaryAudioNotSupported, "Remux")] // #6450
         [InlineData("Yatse", "mp4-h264-ac3-srt-2600k", PlayMethod.DirectStream, TranscodeReason.AudioCodecNotSupported)]
         [InlineData("Yatse", "mp4-hevc-aac-srt-15200k", PlayMethod.DirectPlay, (TranscodeReason)0, "Remux")] // #6450
-        [InlineData("Yatse", "mp4-hevc-ac3-aac-srt-15200k", PlayMethod.DirectPlay, (TranscodeReason)0, "Remux")] // #6450
+        [InlineData("Yatse", "mp4-hevc-ac3-aac-srt-15200k", PlayMethod.DirectStream, TranscodeReason.SecondaryAudioNotSupported, "Remux")] // #6450
         // RokuSSPlus
         [InlineData("RokuSSPlus", "mp4-h264-aac-srt-2600k", PlayMethod.DirectPlay, (TranscodeReason)0, "Remux")] // #6450
         [InlineData("RokuSSPlus", "mp4-h264-ac3-aac-srt-2600k", PlayMethod.DirectPlay, (TranscodeReason)0, "Remux")] // #6450 should be DirectPlay
@@ -83,8 +83,8 @@ namespace Jellyfin.Model.Tests
         [InlineData("JellyfinMediaPlayer", "mkv-vp9-vorbis-vtt-2600k", PlayMethod.DirectPlay)] // #6450
         // Chrome-NoHLS
         [InlineData("Chrome-NoHLS", "mp4-h264-aac-vtt-2600k", PlayMethod.DirectPlay)] // #6450
-        [InlineData("Chrome-NoHLS", "mp4-h264-ac3-aac-srt-2600k", PlayMethod.DirectPlay)] // #6450
-        [InlineData("Chrome-NoHLS", "mp4-h264-ac3-aacDef-srt-2600k", PlayMethod.DirectPlay)] // #6450
+        [InlineData("Chrome-NoHLS", "mp4-h264-ac3-aac-srt-2600k", PlayMethod.DirectStream, TranscodeReason.SecondaryAudioNotSupported, "Remux")] // #6450
+        [InlineData("Chrome-NoHLS", "mp4-h264-ac3-aacDef-srt-2600k", PlayMethod.DirectStream, TranscodeReason.SecondaryAudioNotSupported, "Remux")] // #6450
         [InlineData("Chrome-NoHLS", "mp4-h264-ac3-aacExt-srt-2600k", PlayMethod.DirectStream, TranscodeReason.AudioIsExternal)] // #6450
         [InlineData("Chrome-NoHLS", "mp4-h264-ac3-srt-2600k", PlayMethod.DirectStream, TranscodeReason.AudioCodecNotSupported)] // #6450
         [InlineData("Chrome-NoHLS", "mp4-hevc-aac-srt-15200k", PlayMethod.Transcode, TranscodeReason.VideoCodecNotSupported, "Transcode", "http")]
@@ -273,15 +273,15 @@ namespace Jellyfin.Model.Tests
 
         [Theory]
         // Chrome
-        [InlineData("Chrome", "mp4-h264-ac3-aac-srt-2600k", PlayMethod.DirectPlay)] // #6450
+        [InlineData("Chrome", "mp4-h264-ac3-aac-srt-2600k", PlayMethod.DirectStream, TranscodeReason.SecondaryAudioNotSupported, "Remux")] // #6450
         [InlineData("Chrome", "mp4-h264-ac3-aacExt-srt-2600k", PlayMethod.DirectStream, TranscodeReason.AudioIsExternal)] // #6450
         [InlineData("Chrome", "mp4-hevc-ac3-aac-srt-15200k", PlayMethod.Transcode, TranscodeReason.VideoCodecNotSupported, "Transcode")]
         // Firefox
-        [InlineData("Firefox", "mp4-h264-ac3-aac-srt-2600k", PlayMethod.DirectPlay)] // #6450
+        [InlineData("Firefox", "mp4-h264-ac3-aac-srt-2600k", PlayMethod.DirectStream, TranscodeReason.SecondaryAudioNotSupported, "Remux")] // #6450
         [InlineData("Firefox", "mp4-hevc-ac3-aac-srt-15200k", PlayMethod.Transcode, TranscodeReason.VideoCodecNotSupported, "Transcode")]
         // Yatse
-        [InlineData("Yatse", "mp4-h264-ac3-aac-srt-2600k", PlayMethod.DirectPlay, (TranscodeReason)0, "Remux")] // #6450
-        [InlineData("Yatse", "mp4-hevc-ac3-aac-srt-15200k", PlayMethod.DirectPlay, (TranscodeReason)0, "Remux")] // #6450
+        [InlineData("Yatse", "mp4-h264-ac3-aac-srt-2600k", PlayMethod.DirectStream, TranscodeReason.SecondaryAudioNotSupported, "Remux")] // #6450
+        [InlineData("Yatse", "mp4-hevc-ac3-aac-srt-15200k", PlayMethod.DirectStream, TranscodeReason.SecondaryAudioNotSupported, "Remux")] // #6450
         // RokuSSPlus
         [InlineData("RokuSSPlus", "mp4-h264-ac3-aac-srt-2600k", PlayMethod.DirectPlay, (TranscodeReason)0, "Remux")] // #6450
         [InlineData("RokuSSPlus", "mp4-hevc-ac3-aac-srt-15200k", PlayMethod.DirectPlay, (TranscodeReason)0, "Remux")] // #6450
@@ -359,7 +359,7 @@ namespace Jellyfin.Model.Tests
                 Assert.Single(val.TargetAudioCodec);
                 // Assert.Single(val.AudioCodecs);
 
-                if (transcodeMode == "DirectStream")
+                if (transcodeMode.Equals("DirectStream", StringComparison.Ordinal))
                 {
                     Assert.Equal(val.Container, uri.Extension);
                 }
@@ -371,14 +371,14 @@ namespace Jellyfin.Model.Tests
                 Assert.NotEmpty(val.AudioCodecs);
 
                 // Check expected container (todo: this could be a test param)
-                if (transcodeProtocol == "http")
+                if (transcodeProtocol.Equals("http", StringComparison.Ordinal))
                 {
                     // Assert.Equal("webm", val.Container);
                     Assert.Equal(val.Container, uri.Extension);
                     Assert.Equal("stream", uri.Filename);
                     Assert.Equal("http", val.SubProtocol);
                 }
-                else if (transcodeProtocol == "HLS.mp4")
+                else if (transcodeProtocol.Equals("HLS.mp4", StringComparison.Ordinal))
                 {
                     Assert.Equal("mp4", val.Container);
                     Assert.Equal("m3u8", uri.Extension);
@@ -394,7 +394,7 @@ namespace Jellyfin.Model.Tests
                 }
 
                 // Full transcode
-                if (transcodeMode == "Transcode")
+                if (transcodeMode.Equals("Transcode", StringComparison.Ordinal))
                 {
                     if ((val.TranscodeReasons & (StreamBuilder.ContainerReasons | TranscodeReason.DirectPlayError)) == 0)
                     {
@@ -413,7 +413,7 @@ namespace Jellyfin.Model.Tests
                     Assert.Contains(targetVideoStream.Codec, val.TargetVideoCodec);
                     Assert.Single(val.TargetVideoCodec);
 
-                    if (transcodeMode == "DirectStream")
+                    if (transcodeMode.Equals("DirectStream", StringComparison.Ordinal))
                     {
                         // Check expected audio codecs (1)
                         if (!targetAudioStream.IsExternal)
@@ -428,7 +428,7 @@ namespace Jellyfin.Model.Tests
                             }
                         }
                     }
-                    else if (transcodeMode == "Remux")
+                    else if (transcodeMode.Equals("Remux", StringComparison.Ordinal))
                     {
                         // Check expected audio codecs (1)
                         Assert.Contains(targetAudioStream.Codec, val.AudioCodecs);

tests/Jellyfin.Model.Tests/Entities/MediaStreamTests.cs

@@ -82,6 +82,19 @@ namespace Jellyfin.Model.Tests.Entities
                     Codec = null
                 });
 
+            data.Add(
+                "Title - EN - Hearing Impaired - Default - Forced - SRT",
+                new MediaStream
+                {
+                    Type = MediaStreamType.Subtitle,
+                    Title = "Title",
+                    Language = "EN",
+                    IsForced = true,
+                    IsDefault = true,
+                    IsHearingImpaired = true,
+                    Codec = "SRT"
+                });
+
             data.Add(
                 "Title - AAC - Default - External",
                 new MediaStream

tests/Jellyfin.Naming.Tests/ExternalFiles/ExternalPathParserTests.cs

@@ -17,12 +17,15 @@ public class ExternalPathParserTests
     {
         var englishCultureDto = new CultureDto("English", "English", "en", new[] { "eng" });
         var frenchCultureDto = new CultureDto("French", "French", "fr", new[] { "fre", "fra" });
+        var hindiCultureDto = new CultureDto("Hindi", "Hindi", "hi", new[] { "hin" });
 
         var localizationManager = new Mock<ILocalizationManager>(MockBehavior.Loose);
         localizationManager.Setup(lm => lm.FindLanguageInfo(It.IsRegex(@"en.*", RegexOptions.IgnoreCase)))
             .Returns(englishCultureDto);
         localizationManager.Setup(lm => lm.FindLanguageInfo(It.IsRegex(@"fr.*", RegexOptions.IgnoreCase)))
             .Returns(frenchCultureDto);
+        localizationManager.Setup(lm => lm.FindLanguageInfo(It.IsRegex(@"hi.*", RegexOptions.IgnoreCase)))
+            .Returns(hindiCultureDto);
 
         _audioPathParser = new ExternalPathParser(new NamingOptions(), localizationManager.Object, DlnaProfileType.Audio);
         _subtitlePathParser = new ExternalPathParser(new NamingOptions(), localizationManager.Object, DlnaProfileType.Subtitle);
@@ -89,6 +92,7 @@ public class ExternalPathParserTests
     [InlineData(".DEFAULT.FORCED", null, null, true, true)]
     [InlineData(".en", null, "eng")]
     [InlineData(".EN", null, "eng")]
+    [InlineData(".hi", null, "hin")]
     [InlineData(".fr.en", "fr", "eng")]
     [InlineData(".en.fr", "en", "fre")]
     [InlineData(".title.en.fr", "title.en", "fre")]
@@ -96,7 +100,11 @@ public class ExternalPathParserTests
     [InlineData(".Title.with.Separator", "Title.with.Separator", null)]
     [InlineData(".title.en.default.forced", "title", "eng", true, true)]
     [InlineData(".forced.default.en.title", "title", "eng", true, true)]
-    public void ParseFile_ExtraTokens_ParseToValues(string tokens, string? title, string? language, bool isDefault = false, bool isForced = false)
+    [InlineData(".sdh.en.title", "title", "eng", false, false, true)]
+    [InlineData(".en.cc.title", "title", "eng", false, false, true)]
+    [InlineData(".hi.en.title", "title", "eng", false, false, true)]
+    [InlineData(".en.hi.title", "title", "eng", false, false, true)]
+    public void ParseFile_ExtraTokens_ParseToValues(string tokens, string? title, string? language, bool isDefault = false, bool isForced = false, bool isHearingImpaired = false)
     {
         var path = "My.Video" + tokens + ".srt";
 
@@ -107,5 +115,6 @@ public class ExternalPathParserTests
         Assert.Equal(language, actual.Language);
         Assert.Equal(isDefault, actual.IsDefault);
         Assert.Equal(isForced, actual.IsForced);
+        Assert.Equal(isHearingImpaired, actual.IsHearingImpaired);
     }
 }

tests/Jellyfin.Naming.Tests/Video/ExtraTests.cs

@@ -51,8 +51,9 @@ namespace Jellyfin.Naming.Tests.Video
         [InlineData(ExtraType.Interview, "interviews")]
         [InlineData(ExtraType.Scene, "scenes")]
         [InlineData(ExtraType.Sample, "samples")]
-        [InlineData(ExtraType.Clip, "shorts")]
-        [InlineData(ExtraType.Clip, "featurettes")]
+        [InlineData(ExtraType.Short, "shorts")]
+        [InlineData(ExtraType.Featurette, "featurettes")]
+        [InlineData(ExtraType.Clip, "clips")]
         [InlineData(ExtraType.ThemeVideo, "backdrops")]
         [InlineData(ExtraType.Unknown, "extras")]
         public void TestDirectories(ExtraType type, string dirName)

tests/Jellyfin.Providers.Tests/Manager/ProviderManagerTests.cs

@@ -0,0 +1,614 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.BaseItemManager;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Controller.Subtitles;
+using MediaBrowser.Model.Configuration;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Providers.Manager;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using Xunit;
+
+// Allow Moq to see internal class
+[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]
+
+namespace Jellyfin.Providers.Tests.Manager
+{
+    public class ProviderManagerTests
+    {
+        private static readonly ILogger<ProviderManager> _logger = new NullLogger<ProviderManager>();
+
+        public static TheoryData<Mock<IMetadataService>[], int> RefreshSingleItemOrderData()
+            => new()
+            {
+                // no order set, uses provided order
+                {
+                    new[]
+                    {
+                        MockIMetadataService(true, true),
+                        MockIMetadataService(true, true)
+                    },
+                    0
+                },
+                // sort order sets priority when all match
+                {
+                    new[]
+                    {
+                        MockIMetadataService(true, true, 1),
+                        MockIMetadataService(true, true, 0),
+                        MockIMetadataService(true, true, 2)
+                    },
+                    1
+                },
+                // CanRefreshPrimary prioritized
+                {
+                    new[]
+                    {
+                        MockIMetadataService(false, true),
+                        MockIMetadataService(true, true),
+                    },
+                    1
+                },
+                // falls back to CanRefresh
+                {
+                    new[]
+                    {
+                        MockIMetadataService(false, false),
+                        MockIMetadataService(false, true)
+                    },
+                    1
+                },
+            };
+
+        [Theory]
+        [MemberData(nameof(RefreshSingleItemOrderData))]
+        public async Task RefreshSingleItem_ServiceOrdering_FollowsPriority(Mock<IMetadataService>[] servicesList, int expectedIndex)
+        {
+            var item = new Movie();
+
+            using var providerManager = GetProviderManager();
+            AddParts(providerManager, metadataServices: servicesList.Select(s => s.Object).ToArray());
+
+            var refreshOptions = new MetadataRefreshOptions(Mock.Of<IDirectoryService>(MockBehavior.Strict));
+            var actual = await providerManager.RefreshSingleItem(item, refreshOptions, CancellationToken.None).ConfigureAwait(false);
+
+            Assert.Equal(ItemUpdateType.MetadataDownload, actual);
+            for (var i = 0; i < servicesList.Length; i++)
+            {
+                var times = i == expectedIndex ? Times.Once() : Times.Never();
+                servicesList[i].Verify(mock => mock.RefreshMetadata(It.IsAny<BaseItem>(), It.IsAny<MetadataRefreshOptions>(), It.IsAny<CancellationToken>()), times);
+            }
+        }
+
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public async Task RefreshSingleItem_RefreshMetadata_WhenServiceFound(bool serviceFound)
+        {
+            var item = new Movie();
+
+            var servicesList = new[] { MockIMetadataService(false, serviceFound) };
+
+            using var providerManager = GetProviderManager();
+            AddParts(providerManager, metadataServices: servicesList.Select(s => s.Object).ToArray());
+
+            var refreshOptions = new MetadataRefreshOptions(Mock.Of<IDirectoryService>(MockBehavior.Strict));
+            var actual = await providerManager.RefreshSingleItem(item, refreshOptions, CancellationToken.None).ConfigureAwait(false);
+
+            var expectedResult = serviceFound ? ItemUpdateType.MetadataDownload : ItemUpdateType.None;
+            Assert.Equal(expectedResult, actual);
+        }
+
+        public static TheoryData<int, int[]?, int[]?, int?[]?, int[]> GetImageProvidersOrderData()
+            => new()
+            {
+                { 3, null, null, null, new[] { 0, 1, 2 } }, // no order options set
+
+                // library options ordering
+                { 3, Array.Empty<int>(), null, null, new[] { 0, 1, 2 } }, // no order provided
+                { 3, new[] { 1 }, null, null, new[] { 1, 0, 2 } }, // one item in order
+                { 3, new[] { 2, 1, 0 }, null, null, new[] { 2, 1, 0 } }, // full reverse order
+
+                // server options ordering
+                { 3, null, Array.Empty<int>(), null, new[] { 0, 1, 2 } }, // no order provided
+                { 3, null, new[] { 1 }, null, new[] { 1, 0, 2 } }, // one item in order
+                { 3, null, new[] { 2, 1, 0 }, null, new[] { 2, 1, 0 } }, // full reverse order
+
+                // IHasOrder ordering
+                { 3, null, null, new int?[] { null, 1, null }, new[] { 1, 0, 2 } }, // one item with defined order
+                { 3, null, null, new int?[] { 2, 1, 0 }, new[] { 2, 1, 0 } }, // full reverse order
+
+                // multiple orders set
+                { 3, new[] { 1 }, new[] { 2, 0, 1 }, null, new[] { 1, 0, 2 } }, // partial library order first, server order ignored
+                { 3, new[] { 1 }, null, new int?[] { 2, 0, 1 }, new[] { 1, 2, 0 } }, // library order first, then orderby
+                { 3, new[] { 2, 1, 0 }, new[] { 1, 2, 0 }, new int?[] { 2, 0, 1 }, new[] { 2, 1, 0 } }, // library order wins
+            };
+
+        [Theory]
+        [MemberData(nameof(GetImageProvidersOrderData))]
+        public void GetImageProviders_ProviderOrder_MatchesExpected(int providerCount, int[]? libraryOrder, int[]? serverOrder, int?[]? hasOrderOrder, int[] expectedOrder)
+        {
+            var item = new Movie();
+
+            var nameProvider = new Func<int, string>(i => "Provider" + i);
+
+            var providerList = new List<IImageProvider>();
+            for (var i = 0; i < providerCount; i++)
+            {
+                var order = hasOrderOrder?[i];
+                providerList.Add(MockIImageProvider<ILocalImageProvider>(nameProvider(i), item, order: order));
+            }
+
+            var libraryOptions = CreateLibraryOptions(item.GetType().Name, imageFetcherOrder: libraryOrder?.Select(nameProvider).ToArray());
+            var serverConfiguration = CreateServerConfiguration(item.GetType().Name, imageFetcherOrder: serverOrder?.Select(nameProvider).ToArray());
+
+            using var providerManager = GetProviderManager(serverConfiguration: serverConfiguration, libraryOptions: libraryOptions);
+            AddParts(providerManager, imageProviders: providerList);
+
+            var refreshOptions = new ImageRefreshOptions(Mock.Of<IDirectoryService>(MockBehavior.Strict));
+            var actualProviders = providerManager.GetImageProviders(item, refreshOptions).ToList();
+
+            Assert.Equal(providerList.Count, actualProviders.Count);
+            var actualOrder = actualProviders.Select(i => providerList.IndexOf(i)).ToArray();
+            Assert.Equal(expectedOrder, actualOrder);
+        }
+
+        [Theory]
+        [InlineData(true, false, true)]
+        [InlineData(false, false, false)]
+        [InlineData(true, true, false)]
+        public void GetImageProviders_CanRefreshImagesBasic_WhenSupportsWithoutError(bool supports, bool errorOnSupported, bool expected)
+        {
+            GetImageProviders_CanRefreshImages_Tester(nameof(IImageProvider), supports, expected, errorOnSupported: errorOnSupported);
+        }
+
+        [Theory]
+        [InlineData(nameof(ILocalImageProvider), false, true)]
+        [InlineData(nameof(ILocalImageProvider), true, true)]
+        [InlineData(nameof(IImageProvider), false, false)]
+        [InlineData(nameof(IImageProvider), true, true)]
+        public void GetImageProviders_CanRefreshImagesLocked_WhenLocalOrFullRefresh(string providerType, bool fullRefresh, bool expected)
+        {
+            GetImageProviders_CanRefreshImages_Tester(providerType, true, expected, itemLocked: true, fullRefresh: fullRefresh);
+        }
+
+        [Theory]
+        [InlineData(nameof(ILocalImageProvider), false, true)]
+        [InlineData(nameof(IRemoteImageProvider), true, true)]
+        [InlineData(nameof(IDynamicImageProvider), true, true)]
+        [InlineData(nameof(IRemoteImageProvider), false, false)]
+        [InlineData(nameof(IDynamicImageProvider), false, false)]
+        public void GetImageProviders_CanRefreshImagesBaseItemEnabled_WhenLocalOrEnabled(string providerType, bool enabled, bool expected)
+        {
+            GetImageProviders_CanRefreshImages_Tester(providerType, true, expected, baseItemEnabled: enabled);
+        }
+
+        private static void GetImageProviders_CanRefreshImages_Tester(
+            string providerType,
+            bool supports,
+            bool expected,
+            bool errorOnSupported = false,
+            bool itemLocked = false,
+            bool fullRefresh = false,
+            bool baseItemEnabled = true)
+        {
+            var item = new Movie
+            {
+                IsLocked = itemLocked
+            };
+
+            var providerName = "provider";
+            IImageProvider provider = providerType switch
+            {
+                "IImageProvider" => MockIImageProvider<IImageProvider>(providerName, item, supports: supports, errorOnSupported: errorOnSupported),
+                "ILocalImageProvider" => MockIImageProvider<ILocalImageProvider>(providerName, item, supports: supports, errorOnSupported: errorOnSupported),
+                "IRemoteImageProvider" => MockIImageProvider<IRemoteImageProvider>(providerName, item, supports: supports, errorOnSupported: errorOnSupported),
+                "IDynamicImageProvider" => MockIImageProvider<IDynamicImageProvider>(providerName, item, supports: supports, errorOnSupported: errorOnSupported),
+                _ => throw new ArgumentException("Unexpected provider type")
+            };
+
+            var refreshOptions = new ImageRefreshOptions(Mock.Of<IDirectoryService>(MockBehavior.Strict))
+            {
+                ImageRefreshMode = fullRefresh ? MetadataRefreshMode.FullRefresh : MetadataRefreshMode.Default
+            };
+
+            var baseItemManager = new Mock<IBaseItemManager>(MockBehavior.Strict);
+            baseItemManager.Setup(i => i.IsImageFetcherEnabled(item, It.IsAny<TypeOptions>(), providerName))
+                .Returns(baseItemEnabled);
+
+            using var providerManager = GetProviderManager(baseItemManager: baseItemManager.Object);
+            AddParts(providerManager, imageProviders: new[] { provider });
+
+            var actualProviders = providerManager.GetImageProviders(item, refreshOptions).ToArray();
+
+            Assert.Equal(expected ? 1 : 0, actualProviders.Length);
+        }
+
+        public static TheoryData<string[], int[]?, int[]?, int[]?, int[]?, int?[]?, int[]> GetMetadataProvidersOrderData()
+        {
+            var l = nameof(ILocalMetadataProvider);
+            var r = nameof(IRemoteMetadataProvider);
+            return new()
+            {
+                { new[] { l, l, r, r }, null, null, null, null, null, new[] { 0, 1, 2, 3 } }, // no order options set
+
+                // library options ordering
+                { new[] { l, l, r, r }, Array.Empty<int>(), Array.Empty<int>(), null, null, null, new[] { 0, 1, 2, 3 } }, // no order provided
+                // local only
+                { new[] { r, l, l, l }, new[] { 2 }, null, null, null, null, new[] { 2, 0, 1, 3 } }, // one item in order
+                { new[] { r, l, l, l }, new[] { 3, 2, 1 }, null, null, null, null, new[] { 3, 2, 1, 0 } }, // full reverse order
+                // remote only
+                { new[] { l, r, r, r }, null, new[] { 2 }, null, null, null, new[] { 2, 0, 1, 3 } }, // one item in order
+                { new[] { l, r, r, r }, null, new[] { 3, 2, 1 }, null, null, null, new[] { 3, 2, 1, 0 } }, // full reverse order
+                // local and remote, note that results will be interleaved (odd but expected)
+                { new[] { l, l, r, r }, new[] { 1 }, new[] { 3 }, null, null, null, new[] { 1, 3, 0, 2 } }, // one item in each order
+                { new[] { l, l, l, r, r, r }, new[] { 2, 1, 0 }, new[] { 5, 4, 3 }, null, null, null, new[] { 2, 5, 1, 4, 0, 3 } }, // full reverse order
+
+                // // server options ordering
+                { new[] { l, l, r, r }, null, null, Array.Empty<int>(), Array.Empty<int>(), null, new[] { 0, 1, 2, 3 } }, // no order provided
+                // local only
+                { new[] { r, l, l, l }, null, null, new[] { 2 }, null, null, new[] { 2, 0, 1, 3 } }, // one item in order
+                { new[] { r, l, l, l }, null, null, new[] { 3, 2, 1 }, null, null, new[] { 3, 2, 1, 0 } }, // full reverse order
+                // remote only
+                { new[] { l, r, r, r }, null, null, null, new[] { 2 }, null, new[] { 2, 0, 1, 3 } }, // one item in order
+                { new[] { l, r, r, r }, null, null, null, new[] { 3, 2, 1 }, null, new[] { 3, 2, 1, 0 } }, // full reverse order
+                // local and remote, note that results will be interleaved (odd but expected)
+                { new[] { l, l, r, r }, null, null, new[] { 1 }, new[] { 3 }, null, new[] { 1, 3, 0, 2 } }, // one item in each order
+                { new[] { l, l, l, r, r, r }, null, null, new[] { 2, 1, 0 }, new[] { 5, 4, 3 }, null, new[] { 2, 5, 1, 4, 0, 3 } }, // full reverse order
+
+                // IHasOrder ordering (not interleaved, doesn't care about types)
+                { new[] { l, l, r, r }, null, null, null, null, new int?[] { 2, null, 1, null }, new[] { 2, 0, 1, 3 } }, // partially defined
+                { new[] { l, l, r, r }, null, null, null, null, new int?[] { 3, 2, 1, 0 }, new[] { 3, 2, 1, 0 } }, // full reverse order
+
+                // multiple orders set
+                { new[] { l, l, l, r, r, r }, new[] { 1 }, new[] { 4 }, new[] { 2, 1, 0 }, new[] { 5, 4, 3 }, null, new[] { 1, 4, 0, 2, 3, 5 } }, // partial library order first, server order ignored
+                { new[] { l, l, l }, new[] { 1 }, null, null, null, new int?[] { 2, 0, 1 }, new[] { 1, 2, 0 } }, // library order first, then orderby
+                { new[] { l, l, l, r, r, r }, new[] { 2, 1, 0 }, new[] { 5, 4, 3 }, new[] { 1, 2, 0 }, new[] { 4, 5, 3 }, new int?[] { 5, 4, 1, 6, 3, 2 }, new[] { 2, 5, 4, 1, 0, 3 } }, // library order wins (with orderby between local/remote)
+            };
+        }
+
+        [Theory]
+        [MemberData(nameof(GetMetadataProvidersOrderData))]
+        public void GetMetadataProviders_ProviderOrder_MatchesExpected(
+            string[] providers,
+            int[]? libraryLocalOrder,
+            int[]? libraryRemoteOrder,
+            int[]? serverLocalOrder,
+            int[]? serverRemoteOrder,
+            int?[]? hasOrderOrder,
+            int[] expectedOrder)
+        {
+            var item = new MetadataTestItem();
+
+            var nameProvider = new Func<int, string>(i => "Provider" + i);
+
+            var providerList = new List<IMetadataProvider<MetadataTestItem>>();
+            for (var i = 0; i < providers.Length; i++)
+            {
+                var order = hasOrderOrder?[i];
+                providerList.Add(MockIMetadataProviderMapper<MetadataTestItem, MetadataTestItemInfo>(providers[i], nameProvider(i), order: order));
+            }
+
+            var libraryOptions = CreateLibraryOptions(
+                item.GetType().Name,
+                localMetadataReaderOrder: libraryLocalOrder?.Select(nameProvider).ToArray(),
+                metadataFetcherOrder: libraryRemoteOrder?.Select(nameProvider).ToArray());
+            var serverConfiguration = CreateServerConfiguration(
+                item.GetType().Name,
+                localMetadataReaderOrder: serverLocalOrder?.Select(nameProvider).ToArray(),
+                metadataFetcherOrder: serverRemoteOrder?.Select(nameProvider).ToArray());
+
+            var baseItemManager = new Mock<IBaseItemManager>(MockBehavior.Strict);
+            baseItemManager.Setup(i => i.IsMetadataFetcherEnabled(item, It.IsAny<TypeOptions>(), It.IsAny<string>()))
+                .Returns(true);
+
+            using var providerManager = GetProviderManager(serverConfiguration: serverConfiguration, baseItemManager: baseItemManager.Object);
+            AddParts(providerManager, metadataProviders: providerList);
+
+            var actualProviders = providerManager.GetMetadataProviders<MetadataTestItem>(item, libraryOptions).ToList();
+
+            Assert.Equal(providerList.Count, actualProviders.Count);
+            var actualOrder = actualProviders.Select(i => providerList.IndexOf(i)).ToArray();
+            Assert.Equal(expectedOrder, actualOrder);
+        }
+
+        [Theory]
+        [InlineData(nameof(IMetadataProvider))]
+        [InlineData(nameof(ILocalMetadataProvider))]
+        [InlineData(nameof(IRemoteMetadataProvider))]
+        [InlineData(nameof(ICustomMetadataProvider))]
+        public void GetMetadataProviders_CanRefreshMetadataBasic_ReturnsTrue(string providerType)
+        {
+            GetMetadataProviders_CanRefreshMetadata_Tester(providerType, true);
+        }
+
+        [Theory]
+        [InlineData(nameof(ILocalMetadataProvider), false, true)]
+        [InlineData(nameof(IRemoteMetadataProvider), false, false)]
+        [InlineData(nameof(ICustomMetadataProvider), false, false)]
+        [InlineData(nameof(ILocalMetadataProvider), true, true)]
+        [InlineData(nameof(ICustomMetadataProvider), true, false)]
+        public void GetMetadataProviders_CanRefreshMetadataLocked_WhenLocalOrForced(string providerType, bool forced, bool expected)
+        {
+            GetMetadataProviders_CanRefreshMetadata_Tester(providerType, expected, itemLocked: true, providerForced: forced);
+        }
+
+        [Theory]
+        [InlineData(nameof(ILocalMetadataProvider), false, true)]
+        [InlineData(nameof(ICustomMetadataProvider), false, true)]
+        [InlineData(nameof(IRemoteMetadataProvider), false, false)]
+        [InlineData(nameof(IRemoteMetadataProvider), true, true)]
+        public void GetMetadataProviders_CanRefreshMetadataBaseItemEnabled_WhenEnabledOrNotRemote(string providerType, bool baseItemEnabled, bool expected)
+        {
+            GetMetadataProviders_CanRefreshMetadata_Tester(providerType, expected, baseItemEnabled: baseItemEnabled);
+        }
+
+        [Theory]
+        [InlineData(nameof(IRemoteMetadataProvider), false, true)]
+        [InlineData(nameof(ICustomMetadataProvider), false, true)]
+        [InlineData(nameof(ILocalMetadataProvider), false, false)]
+        [InlineData(nameof(ILocalMetadataProvider), true, true)]
+        public void GetMetadataProviders_CanRefreshMetadataSupportsLocal_WhenSupportsOrNotLocal(string providerType, bool supportsLocalMetadata, bool expected)
+        {
+            GetMetadataProviders_CanRefreshMetadata_Tester(providerType, expected, supportsLocalMetadata: supportsLocalMetadata);
+        }
+
+        [Theory]
+        [InlineData(nameof(ICustomMetadataProvider), true)]
+        [InlineData(nameof(IRemoteMetadataProvider), true)]
+        [InlineData(nameof(ILocalMetadataProvider), false)]
+        public void GetMetadataProviders_CanRefreshMetadataOwned_WhenNotLocal(string providerType, bool expected)
+        {
+            GetMetadataProviders_CanRefreshMetadata_Tester(providerType, expected, ownedItem: true);
+        }
+
+        private static void GetMetadataProviders_CanRefreshMetadata_Tester(
+            string providerType,
+            bool expected,
+            bool itemLocked = false,
+            bool baseItemEnabled = true,
+            bool providerForced = false,
+            bool supportsLocalMetadata = true,
+            bool ownedItem = false)
+        {
+            var item = new MetadataTestItem
+            {
+                IsLocked = itemLocked,
+                OwnerId = ownedItem ? Guid.NewGuid() : Guid.Empty,
+                EnableLocalMetadata = supportsLocalMetadata
+            };
+
+            var providerName = "provider";
+            var provider = MockIMetadataProviderMapper<MetadataTestItem, MetadataTestItemInfo>(providerType, providerName, forced: providerForced);
+
+            var baseItemManager = new Mock<IBaseItemManager>(MockBehavior.Strict);
+            baseItemManager.Setup(i => i.IsMetadataFetcherEnabled(item, It.IsAny<TypeOptions>(), providerName))
+                .Returns(baseItemEnabled);
+
+            using var providerManager = GetProviderManager(baseItemManager: baseItemManager.Object);
+            AddParts(providerManager, metadataProviders: new[] { provider });
+
+            var actualProviders = providerManager.GetMetadataProviders<MetadataTestItem>(item, new LibraryOptions()).ToArray();
+
+            Assert.Equal(expected ? 1 : 0, actualProviders.Length);
+        }
+
+        private static Mock<IMetadataService> MockIMetadataService(bool refreshPrimary, bool canRefresh, int order = 0)
+        {
+            var service = new Mock<IMetadataService>(MockBehavior.Strict);
+            service.Setup(s => s.Order)
+                .Returns(order);
+            service.Setup(s => s.CanRefreshPrimary(It.IsAny<Type>()))
+                .Returns(refreshPrimary);
+            service.Setup(s => s.CanRefresh(It.IsAny<BaseItem>()))
+                .Returns(canRefresh);
+            service.Setup(s => s.RefreshMetadata(It.IsAny<BaseItem>(), It.IsAny<MetadataRefreshOptions>(), It.IsAny<CancellationToken>()))
+                .Returns(Task.FromResult(ItemUpdateType.MetadataDownload));
+            return service;
+        }
+
+        private static IImageProvider MockIImageProvider<TProviderType>(string name, BaseItem expectedType, bool supports = true, int? order = null, bool errorOnSupported = false)
+            where TProviderType : class, IImageProvider
+        {
+            Mock<IHasOrder>? hasOrder = null;
+            if (order != null)
+            {
+                hasOrder = new Mock<IHasOrder>(MockBehavior.Strict);
+                hasOrder.Setup(i => i.Order)
+                    .Returns((int)order);
+            }
+
+            var provider = hasOrder == null
+                ? new Mock<TProviderType>(MockBehavior.Strict)
+                : hasOrder.As<TProviderType>();
+            provider.Setup(p => p.Name)
+                .Returns(name);
+            if (errorOnSupported)
+            {
+                provider.Setup(p => p.Supports(It.IsAny<BaseItem>()))
+                    .Throws(new ArgumentException("Provider threw exception on Supports(item)"));
+            }
+            else
+            {
+                provider.Setup(p => p.Supports(expectedType))
+                    .Returns(supports);
+            }
+
+            return provider.Object;
+        }
+
+        private static IMetadataProvider<TItemType> MockIMetadataProviderMapper<TItemType, TLookupInfoType>(string typeName, string providerName, int? order = null, bool forced = false)
+            where TItemType : BaseItem, IHasLookupInfo<TLookupInfoType>
+            where TLookupInfoType : ItemLookupInfo, new()
+            => typeName switch
+            {
+                "ILocalMetadataProvider" => MockIMetadataProvider<ILocalMetadataProvider<TItemType>, TItemType>(providerName, order, forced),
+                "IRemoteMetadataProvider" => MockIMetadataProvider<IRemoteMetadataProvider<TItemType, TLookupInfoType>, TItemType>(providerName, order, forced),
+                "ICustomMetadataProvider" => MockIMetadataProvider<ICustomMetadataProvider<TItemType>, TItemType>(providerName, order, forced),
+                _ => MockIMetadataProvider<IMetadataProvider<TItemType>, TItemType>(providerName, order, forced)
+            };
+
+        private static IMetadataProvider<TItemType> MockIMetadataProvider<TProviderType, TItemType>(string name, int? order = null, bool forced = false)
+            where TProviderType : class, IMetadataProvider<TItemType>
+            where TItemType : BaseItem
+        {
+            Mock<IForcedProvider>? forcedProvider = null;
+            if (forced)
+            {
+                forcedProvider = new Mock<IForcedProvider>();
+            }
+
+            Mock<IHasOrder>? hasOrder = null;
+            if (order != null)
+            {
+                hasOrder = forcedProvider == null ? new Mock<IHasOrder>() : forcedProvider.As<IHasOrder>();
+                hasOrder.Setup(i => i.Order)
+                    .Returns((int)order);
+            }
+
+            var provider = hasOrder == null
+                ? new Mock<TProviderType>(MockBehavior.Strict)
+                : hasOrder.As<TProviderType>();
+            provider.Setup(p => p.Name)
+                .Returns(name);
+
+            return provider.Object;
+        }
+
+        private static LibraryOptions CreateLibraryOptions(
+            string typeName,
+            string[]? imageFetcherOrder = null,
+            string[]? localMetadataReaderOrder = null,
+            string[]? metadataFetcherOrder = null)
+        {
+            var libraryOptions = new LibraryOptions
+            {
+                LocalMetadataReaderOrder = localMetadataReaderOrder
+            };
+
+            // only create type options if populating it with something
+            if (imageFetcherOrder != null || metadataFetcherOrder != null)
+            {
+                imageFetcherOrder ??= Array.Empty<string>();
+                metadataFetcherOrder ??= Array.Empty<string>();
+
+                libraryOptions.TypeOptions = new[]
+                {
+                    new TypeOptions
+                    {
+                        Type = typeName,
+                        ImageFetcherOrder = imageFetcherOrder,
+                        MetadataFetcherOrder = metadataFetcherOrder
+                    }
+                };
+            }
+
+            return libraryOptions;
+        }
+
+        private static ServerConfiguration CreateServerConfiguration(
+            string typeName,
+            string[]? imageFetcherOrder = null,
+            string[]? localMetadataReaderOrder = null,
+            string[]? metadataFetcherOrder = null)
+        {
+            var serverConfiguration = new ServerConfiguration();
+
+            // only create type options if populating it with something
+            if (imageFetcherOrder != null || localMetadataReaderOrder != null || metadataFetcherOrder != null)
+            {
+                imageFetcherOrder ??= Array.Empty<string>();
+                localMetadataReaderOrder ??= Array.Empty<string>();
+                metadataFetcherOrder ??= Array.Empty<string>();
+
+                serverConfiguration.MetadataOptions = new[]
+                {
+                    new MetadataOptions
+                    {
+                        ItemType = typeName,
+                        ImageFetcherOrder = imageFetcherOrder,
+                        LocalMetadataReaderOrder = localMetadataReaderOrder,
+                        MetadataFetcherOrder = metadataFetcherOrder
+                    }
+                };
+            }
+
+            return serverConfiguration;
+        }
+
+        private static ProviderManager GetProviderManager(
+            ServerConfiguration? serverConfiguration = null,
+            LibraryOptions? libraryOptions = null,
+            IBaseItemManager? baseItemManager = null)
+        {
+            var serverConfigurationManager = new Mock<IServerConfigurationManager>(MockBehavior.Strict);
+            serverConfigurationManager.Setup(i => i.Configuration)
+                .Returns(serverConfiguration ?? new ServerConfiguration());
+
+            var libraryManager = new Mock<ILibraryManager>(MockBehavior.Strict);
+            libraryManager.Setup(i => i.GetLibraryOptions(It.IsAny<BaseItem>()))
+                .Returns(libraryOptions ?? new LibraryOptions());
+
+            var providerManager = new ProviderManager(
+                Mock.Of<IHttpClientFactory>(),
+                Mock.Of<ISubtitleManager>(),
+                serverConfigurationManager.Object,
+                Mock.Of<ILibraryMonitor>(),
+                _logger,
+                Mock.Of<IFileSystem>(),
+                Mock.Of<IServerApplicationPaths>(),
+                libraryManager.Object,
+                baseItemManager!);
+
+            return providerManager;
+        }
+
+        private static void AddParts(
+            ProviderManager providerManager,
+            IEnumerable<IImageProvider>? imageProviders = null,
+            IEnumerable<IMetadataService>? metadataServices = null,
+            IEnumerable<IMetadataProvider>? metadataProviders = null,
+            IEnumerable<IMetadataSaver>? metadataSavers = null,
+            IEnumerable<IExternalId>? externalIds = null)
+        {
+            imageProviders ??= Array.Empty<IImageProvider>();
+            metadataServices ??= Array.Empty<IMetadataService>();
+            metadataProviders ??= Array.Empty<IMetadataProvider>();
+            metadataSavers ??= Array.Empty<IMetadataSaver>();
+            externalIds ??= Array.Empty<IExternalId>();
+
+            providerManager.AddParts(imageProviders, metadataServices, metadataProviders, metadataSavers, externalIds);
+        }
+
+        /// <summary>
+        /// Simple <see cref="BaseItem"/> extension to make SupportsLocalMetadata directly settable.
+        /// </summary>
+        internal class MetadataTestItem : BaseItem, IHasLookupInfo<MetadataTestItemInfo>
+        {
+            public bool EnableLocalMetadata { get; set; } = true;
+
+            public override bool SupportsLocalMetadata => EnableLocalMetadata;
+
+            public MetadataTestItemInfo GetLookupInfo()
+            {
+                return GetItemLookupInfo<MetadataTestItemInfo>();
+            }
+        }
+
+        internal class MetadataTestItemInfo : ItemLookupInfo
+        {
+        }
+    }
+}

tests/Jellyfin.Providers.Tests/MediaInfo/MediaInfoResolverTests.cs

@@ -227,7 +227,7 @@ public class MediaInfoResolverTests
             });
 
         // filename has metadata
-        file = "My.Video.Title1.default.forced.en.srt";
+        file = "My.Video.Title1.default.forced.sdh.en.srt";
         data.Add(
             file,
             new[]
@@ -236,7 +236,7 @@ public class MediaInfoResolverTests
             },
             new[]
             {
-                CreateMediaStream(VideoDirectoryPath + "/" + file, "eng", "Title1", 0, true, true)
+                CreateMediaStream(VideoDirectoryPath + "/" + file, "eng", "Title1", 0, true, true, true)
             });
 
         // single stream with metadata
@@ -245,15 +245,15 @@ public class MediaInfoResolverTests
             file,
             new[]
             {
-                CreateMediaStream(VideoDirectoryPath + "/" + file, "eng", "Title", 0, true, true)
+                CreateMediaStream(VideoDirectoryPath + "/" + file, "eng", "Title", 0, true, true, true)
             },
             new[]
             {
-                CreateMediaStream(VideoDirectoryPath + "/" + file, "eng", "Title", 0, true, true)
+                CreateMediaStream(VideoDirectoryPath + "/" + file, "eng", "Title", 0, true, true, true)
             });
 
         // stream wins for title/language, filename wins for flags when conflicting
-        file = "My.Video.Title2.default.forced.en.srt";
+        file = "My.Video.Title2.default.forced.sdh.en.srt";
         data.Add(
             file,
             new[]
@@ -262,7 +262,7 @@ public class MediaInfoResolverTests
             },
             new[]
             {
-                CreateMediaStream(VideoDirectoryPath + "/" + file, "fra", "Metadata", 0, true, true)
+                CreateMediaStream(VideoDirectoryPath + "/" + file, "fra", "Metadata", 0, true, true, true)
             });
 
         // multiple stream with metadata - filename flags ignored but other data filled in when missing from stream
@@ -324,6 +324,7 @@ public class MediaInfoResolverTests
             Assert.Equal(expected.Path, actual.Path);
             Assert.Equal(expected.IsDefault, actual.IsDefault);
             Assert.Equal(expected.IsForced, actual.IsForced);
+            Assert.Equal(expected.IsHearingImpaired, actual.IsHearingImpaired);
             Assert.Equal(expected.Language, actual.Language);
             Assert.Equal(expected.Title, actual.Title);
         }
@@ -396,7 +397,7 @@ public class MediaInfoResolverTests
         }
     }
 
-    private static MediaStream CreateMediaStream(string path, string? language, string? title, int index, bool isForced = false, bool isDefault = false)
+    private static MediaStream CreateMediaStream(string path, string? language, string? title, int index, bool isForced = false, bool isDefault = false, bool isHearingImpaired = false)
     {
         return new MediaStream
         {
@@ -405,6 +406,7 @@ public class MediaInfoResolverTests
             Path = path,
             IsDefault = isDefault,
             IsForced = isForced,
+            IsHearingImpaired = isHearingImpaired,
             Language = language,
             Title = title
         };

tests/Jellyfin.Server.Implementations.Tests/LiveTv/Listings/XmlTvListingsProviderTests.cs

@@ -0,0 +1,70 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using AutoFixture;
+using AutoFixture.AutoMoq;
+using Emby.Server.Implementations.LiveTv.Listings;
+using MediaBrowser.Model.LiveTv;
+using Moq;
+using Moq.Protected;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.LiveTv.Listings;
+
+public class XmlTvListingsProviderTests
+{
+    private readonly Fixture _fixture;
+    private readonly XmlTvListingsProvider _xmlTvListingsProvider;
+
+    public XmlTvListingsProviderTests()
+    {
+        var messageHandler = new Mock<HttpMessageHandler>();
+        messageHandler.Protected()
+            .Setup<Task<HttpResponseMessage>>("SendAsync", ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>())
+            .Returns<HttpRequestMessage, CancellationToken>(
+                (m, _) =>
+                {
+                    return Task.FromResult(new HttpResponseMessage()
+                    {
+                        Content = new StreamContent(File.OpenRead(Path.Combine("Test Data/LiveTv/Listings/XmlTv", m.RequestUri!.Segments[^1])))
+                    });
+                });
+
+        var http = new Mock<IHttpClientFactory>();
+        http.Setup(x => x.CreateClient(It.IsAny<string>()))
+            .Returns(new HttpClient(messageHandler.Object));
+        _fixture = new Fixture();
+        _fixture.Customize(new AutoMoqCustomization
+        {
+            ConfigureMembers = true
+        }).Inject(http);
+        _xmlTvListingsProvider = _fixture.Create<XmlTvListingsProvider>();
+    }
+
+    [Theory]
+    [InlineData("Test Data/LiveTv/Listings/XmlTv/notitle.xml")]
+    [InlineData("https://example.com/notitle.xml")]
+    public async Task GetProgramsAsync_NoTitle_Success(string path)
+    {
+        var info = new ListingsProviderInfo()
+        {
+            Path = path
+        };
+
+        var startDate = new DateTime(2022, 11, 4);
+        var programs = await _xmlTvListingsProvider.GetProgramsAsync(info, "3297", startDate, startDate.AddDays(1), CancellationToken.None);
+        var programsList = programs.ToList();
+        Assert.Single(programsList);
+        var program = programsList[0];
+        Assert.Null(program.Name);
+        Assert.Null(program.SeriesId);
+        Assert.Null(program.EpisodeTitle);
+        Assert.True(program.IsSports);
+        Assert.True(program.HasImage);
+        Assert.Equal("https://domain.tld/image.png", program.ImageUrl);
+        Assert.Equal("3297", program.ChannelId);
+    }
+}

tests/Jellyfin.Server.Implementations.Tests/Test Data/LiveTv/Listings/XmlTv/notitle.xml

@@ -0,0 +1,10 @@
+<tv date="20221104">
+  <programme channel="3297" start="20221104130000 -0400" stop="20221105235959 -0400">
+    <category lang="en">sports</category>
+    <episode-num system="original-air-date">2022-11-04 13:00:00</episode-num>
+    <icon height="" src="https://domain.tld/image.png" width=""/>
+    <credits/>
+    <video/>
+    <date/>
+  </programme>
+</tv>

tests/Jellyfin.Server.Integration.Tests/Controllers/DlnaControllerTests.cs

@@ -34,8 +34,8 @@ namespace Jellyfin.Server.Integration.Tests.Controllers
             var client = _factory.CreateClient();
             client.DefaultRequestHeaders.AddAuthHeader(_accessToken ??= await AuthHelper.CompleteStartupAsync(client).ConfigureAwait(false));
 
-            using var getResponse = await client.GetAsync("/Dlna/Profiles/" + NonExistentProfile).ConfigureAwait(false);
-            Assert.Equal(HttpStatusCode.NotFound, getResponse.StatusCode);
+            using var response = await client.GetAsync("/Dlna/Profiles/" + NonExistentProfile).ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
         }
 
         [Fact]
@@ -45,8 +45,8 @@ namespace Jellyfin.Server.Integration.Tests.Controllers
             var client = _factory.CreateClient();
             client.DefaultRequestHeaders.AddAuthHeader(_accessToken ??= await AuthHelper.CompleteStartupAsync(client).ConfigureAwait(false));
 
-            using var getResponse = await client.DeleteAsync("/Dlna/Profiles/" + NonExistentProfile).ConfigureAwait(false);
-            Assert.Equal(HttpStatusCode.NotFound, getResponse.StatusCode);
+            using var response = await client.DeleteAsync("/Dlna/Profiles/" + NonExistentProfile).ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
         }
 
         [Fact]
@@ -61,8 +61,8 @@ namespace Jellyfin.Server.Integration.Tests.Controllers
                 Name = "ThisProfileDoesNotExist"
             };
 
-            using var getResponse = await client.PostAsJsonAsync("/Dlna/Profiles/" + NonExistentProfile, deviceProfile, _jsonOptions).ConfigureAwait(false);
-            Assert.Equal(HttpStatusCode.NotFound, getResponse.StatusCode);
+            using var response = await client.PostAsJsonAsync("/Dlna/Profiles/" + NonExistentProfile, deviceProfile, _jsonOptions).ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
         }
 
         [Fact]
@@ -77,8 +77,8 @@ namespace Jellyfin.Server.Integration.Tests.Controllers
                 Name = "ThisProfileIsNew"
             };
 
-            using var getResponse = await client.PostAsJsonAsync("/Dlna/Profiles", deviceProfile, _jsonOptions).ConfigureAwait(false);
-            Assert.Equal(HttpStatusCode.NoContent, getResponse.StatusCode);
+            using var response = await client.PostAsJsonAsync("/Dlna/Profiles", deviceProfile, _jsonOptions).ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
         }
 
         [Fact]
@@ -115,20 +115,46 @@ namespace Jellyfin.Server.Integration.Tests.Controllers
                 Id = _newDeviceProfileId
             };
 
-            using var getResponse = await client.PostAsJsonAsync("/Dlna/Profiles", updatedProfile, _jsonOptions).ConfigureAwait(false);
-            Assert.Equal(HttpStatusCode.NoContent, getResponse.StatusCode);
+            using var postResponse = await client.PostAsJsonAsync("/Dlna/Profiles/" + _newDeviceProfileId, updatedProfile, _jsonOptions).ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.NoContent, postResponse.StatusCode);
+
+            // Verify that the profile got updated
+            using var response = await client.GetAsync("/Dlna/ProfileInfos").ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            Assert.Equal(MediaTypeNames.Application.Json, response.Content.Headers.ContentType?.MediaType);
+            Assert.Equal(Encoding.UTF8.BodyName, response.Content.Headers.ContentType?.CharSet);
+
+            var profiles = await JsonSerializer.DeserializeAsync<DeviceProfileInfo[]>(
+                await response.Content.ReadAsStreamAsync().ConfigureAwait(false),
+                _jsonOptions).ConfigureAwait(false);
+
+            Assert.Null(profiles?.FirstOrDefault(x => string.Equals(x.Name, "ThisProfileIsNew", StringComparison.Ordinal)));
+            var newProfile = profiles?.FirstOrDefault(x => string.Equals(x.Name, "ThisProfileIsUpdated", StringComparison.Ordinal));
+            Assert.NotNull(newProfile);
+            _newDeviceProfileId = newProfile!.Id;
         }
 
         [Fact]
-        [Priority(4)]
+        [Priority(5)]
         public async Task DeleteProfile_Valid_NoContent()
         {
             var client = _factory.CreateClient();
             client.DefaultRequestHeaders.AddAuthHeader(_accessToken ??= await AuthHelper.CompleteStartupAsync(client).ConfigureAwait(false));
 
-            using var getResponse = await client.DeleteAsync("/Dlna/Profiles/" + _newDeviceProfileId).ConfigureAwait(false);
-            Console.WriteLine(await getResponse.Content.ReadAsStringAsync().ConfigureAwait(false));
-            Assert.Equal(HttpStatusCode.NoContent, getResponse.StatusCode);
+            using var deleteResponse = await client.DeleteAsync("/Dlna/Profiles/" + _newDeviceProfileId).ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.NoContent, deleteResponse.StatusCode);
+
+            // Verify that the profile got deleted
+            using var response = await client.GetAsync("/Dlna/ProfileInfos").ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            Assert.Equal(MediaTypeNames.Application.Json, response.Content.Headers.ContentType?.MediaType);
+            Assert.Equal(Encoding.UTF8.BodyName, response.Content.Headers.ContentType?.CharSet);
+
+            var profiles = await JsonSerializer.DeserializeAsync<DeviceProfileInfo[]>(
+                await response.Content.ReadAsStreamAsync().ConfigureAwait(false),
+                _jsonOptions).ConfigureAwait(false);
+
+            Assert.Null(profiles?.FirstOrDefault(x => string.Equals(x.Name, "ThisProfileIsUpdated", StringComparison.Ordinal)));
         }
     }
 }

tests/Jellyfin.Server.Integration.Tests/JellyfinApplicationFactory.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Concurrent;
+using System.Globalization;
 using System.IO;
 using System.Threading;
 using Emby.Server.Implementations;
@@ -28,7 +29,9 @@ namespace Jellyfin.Server.Integration.Tests
         static JellyfinApplicationFactory()
         {
             // Perform static initialization that only needs to happen once per test-run
-            Log.Logger = new LoggerConfiguration().WriteTo.Console().CreateLogger();
+            Log.Logger = new LoggerConfiguration()
+                .WriteTo.Console(formatProvider: CultureInfo.InvariantCulture)
+                .CreateLogger();
             Program.PerformStaticInitialization();
         }
 

tests/Jellyfin.XbmcMetadata.Tests/Parsers/MusicAlbumNfoProviderTests.cs

@@ -7,7 +7,7 @@ using MediaBrowser.Controller.Providers;
 using MediaBrowser.Model.Configuration;
 using MediaBrowser.Model.Entities;
 using MediaBrowser.Model.Providers;
-using MediaBrowser.Providers.Music;
+using MediaBrowser.Providers.Plugins.MusicBrainz;
 using MediaBrowser.XbmcMetadata.Parsers;
 using Microsoft.Extensions.Logging.Abstractions;
 using Moq;

tests/Jellyfin.XbmcMetadata.Tests/Parsers/MusicArtistNfoParserTests.cs

@@ -7,7 +7,7 @@ using MediaBrowser.Controller.Providers;
 using MediaBrowser.Model.Configuration;
 using MediaBrowser.Model.Entities;
 using MediaBrowser.Model.Providers;
-using MediaBrowser.Providers.Music;
+using MediaBrowser.Providers.Plugins.MusicBrainz;
 using MediaBrowser.XbmcMetadata.Parsers;
 using Microsoft.Extensions.Logging.Abstractions;
 using Moq;