Merge branch 'master' into studios-images-plugin

# Conflicts:
#	MediaBrowser.Providers/MediaBrowser.Providers.csproj

173 files changed, 10258 insertions, 1201 deletions

diff --git a/tests/Jellyfin.Api.Tests/Auth/CustomAuthenticationHandlerTests.cs b/tests/Jellyfin.Api.Tests/Auth/CustomAuthenticationHandlerTests.cs
index ee20cc573..6f5c0ed0c 100644
--- a/tests/Jellyfin.Api.Tests/Auth/CustomAuthenticationHandlerTests.cs
+++ b/tests/Jellyfin.Api.Tests/Auth/CustomAuthenticationHandlerTests.cs
@@ -128,13 +128,17 @@ namespace Jellyfin.Api.Tests.Auth
         {
             var authorizationInfo = _fixture.Create<AuthorizationInfo>();
             authorizationInfo.User = _fixture.Create<User>();
+            authorizationInfo.User.AddDefaultPermissions();
+            authorizationInfo.User.AddDefaultPreferences();
             authorizationInfo.User.SetPermission(PermissionKind.IsAdministrator, isAdmin);
             authorizationInfo.IsApiKey = false;
+            authorizationInfo.HasToken = true;
+            authorizationInfo.Token = "fake-token";
 
             _jellyfinAuthServiceMock.Setup(
                     a => a.Authenticate(
                         It.IsAny<HttpRequest>()))
-                .Returns(authorizationInfo);
+                .Returns(Task.FromResult(authorizationInfo));
 
             return authorizationInfo;
         }
diff --git a/tests/Jellyfin.Api.Tests/Auth/DefaultAuthorizationPolicy/DefaultAuthorizationHandlerTests.cs b/tests/Jellyfin.Api.Tests/Auth/DefaultAuthorizationPolicy/DefaultAuthorizationHandlerTests.cs
index a62fd8d5a..23c51999f 100644
--- a/tests/Jellyfin.Api.Tests/Auth/DefaultAuthorizationPolicy/DefaultAuthorizationHandlerTests.cs
+++ b/tests/Jellyfin.Api.Tests/Auth/DefaultAuthorizationPolicy/DefaultAuthorizationHandlerTests.cs
@@ -4,6 +4,7 @@ using AutoFixture;
 using AutoFixture.AutoMoq;
 using Jellyfin.Api.Auth.DefaultAuthorizationPolicy;
 using Jellyfin.Api.Constants;
+using Jellyfin.Server.Implementations.Security;
 using MediaBrowser.Common.Configuration;
 using MediaBrowser.Controller.Library;
 using Microsoft.AspNetCore.Authorization;
@@ -49,5 +50,61 @@ namespace Jellyfin.Api.Tests.Auth.DefaultAuthorizationPolicy
             await _sut.HandleAsync(context);
             Assert.True(context.HasSucceeded);
         }
+
+        [Theory]
+        [MemberData(nameof(GetParts_ValidAuthHeader_Success_Data))]
+        public void GetParts_ValidAuthHeader_Success(string input, Dictionary<string, string> parts)
+        {
+            var dict = AuthorizationContext.GetParts(input);
+            foreach (var (key, value) in parts)
+            {
+                Assert.Equal(dict[key], value);
+            }
+        }
+
+        private static TheoryData<string, Dictionary<string, string>> GetParts_ValidAuthHeader_Success_Data()
+        {
+            var data = new TheoryData<string, Dictionary<string, string>>();
+
+            data.Add(
+                "x=\"123,123\",y=\"123\"",
+                new Dictionary<string, string>
+                {
+                    { "x", "123,123" },
+                    { "y", "123" }
+                });
+
+            data.Add(
+                "x=\"123,123\",         y=\"123\",z=\"'hi'\"",
+                new Dictionary<string, string>
+                {
+                    { "x", "123,123" },
+                    { "y", "123" },
+                    { "z", "'hi'" }
+                });
+
+            data.Add(
+                "x=\"ab\"",
+                new Dictionary<string, string>
+                {
+                    { "x", "ab" }
+                });
+
+            data.Add(
+                "param=Hörbücher",
+                new Dictionary<string, string>
+                {
+                    { "param", "Hörbücher" }
+                });
+
+            data.Add(
+                "param=%22%Hörbücher",
+                new Dictionary<string, string>
+                {
+                    { "param", "\"%Hörbücher" }
+                });
+
+            return data;
+        }
     }
 }
diff --git a/tests/Jellyfin.Api.Tests/Auth/LocalAccessPolicy/LocalAccessHandlerTests.cs b/tests/Jellyfin.Api.Tests/Auth/LocalAccessPolicy/LocalAccessHandlerTests.cs
index 09ffa8468..5b3d784ff 100644
--- a/tests/Jellyfin.Api.Tests/Auth/LocalAccessPolicy/LocalAccessHandlerTests.cs
+++ b/tests/Jellyfin.Api.Tests/Auth/LocalAccessPolicy/LocalAccessHandlerTests.cs
@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Net;
 using System.Threading.Tasks;
 using AutoFixture;
 using AutoFixture.AutoMoq;
@@ -41,7 +42,7 @@ namespace Jellyfin.Api.Tests.Auth.LocalAccessPolicy
         public async Task LocalAccessOnly(bool isInLocalNetwork, bool shouldSucceed)
         {
             _networkManagerMock
-                .Setup(n => n.IsInLocalNetwork(It.IsAny<string>()))
+                .Setup(n => n.IsInLocalNetwork(It.IsAny<IPAddress>()))
                 .Returns(isInLocalNetwork);
 
             TestHelpers.SetupConfigurationManager(_configurationManagerMock, true);
diff --git a/tests/Jellyfin.Api.Tests/Controllers/DynamicHlsControllerTests.cs b/tests/Jellyfin.Api.Tests/Controllers/DynamicHlsControllerTests.cs
new file mode 100644
index 000000000..1f06e8fde
--- /dev/null
+++ b/tests/Jellyfin.Api.Tests/Controllers/DynamicHlsControllerTests.cs
@@ -0,0 +1,45 @@
+using System;
+using Jellyfin.Api.Controllers;
+using Xunit;
+
+namespace Jellyfin.Api.Tests.Controllers
+{
+    public class DynamicHlsControllerTests
+    {
+        [Theory]
+        [MemberData(nameof(GetSegmentLengths_Success_TestData))]
+        public void GetSegmentLengths_Success(long runtimeTicks, int segmentlength, double[] expected)
+        {
+            var res = DynamicHlsController.GetSegmentLengthsInternal(runtimeTicks, segmentlength);
+            Assert.Equal(expected.Length, res.Length);
+            for (int i = 0; i < expected.Length; i++)
+            {
+                Assert.Equal(expected[i], res[i]);
+            }
+        }
+
+        public static TheoryData<long, int, double[]> GetSegmentLengths_Success_TestData()
+        {
+            var data = new TheoryData<long, int, double[]>();
+            data.Add(0, 6, Array.Empty<double>());
+            data.Add(
+                TimeSpan.FromSeconds(3).Ticks,
+                6,
+                new double[] { 3 });
+            data.Add(
+                TimeSpan.FromSeconds(6).Ticks,
+                6,
+                new double[] { 6 });
+            data.Add(
+                TimeSpan.FromSeconds(3.3333333).Ticks,
+                6,
+                new double[] { 3.3333333 });
+            data.Add(
+                TimeSpan.FromSeconds(9.3333333).Ticks,
+                6,
+                new double[] { 6, 3.3333333 });
+
+            return data;
+        }
+    }
+}
diff --git a/tests/Jellyfin.Api.Tests/Helpers/RequestHelpersTests.cs b/tests/Jellyfin.Api.Tests/Helpers/RequestHelpersTests.cs
new file mode 100644
index 000000000..c4640bd22
--- /dev/null
+++ b/tests/Jellyfin.Api.Tests/Helpers/RequestHelpersTests.cs
@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using Jellyfin.Api.Helpers;
+using Jellyfin.Data.Enums;
+using Xunit;
+
+namespace Jellyfin.Api.Tests.Helpers
+{
+    public static class RequestHelpersTests
+    {
+        [Theory]
+        [MemberData(nameof(GetOrderBy_Success_TestData))]
+        public static void GetOrderBy_Success(IReadOnlyList<string> sortBy, IReadOnlyList<SortOrder> requestedSortOrder, (string, SortOrder)[] expected)
+        {
+            Assert.Equal(expected, RequestHelpers.GetOrderBy(sortBy, requestedSortOrder));
+        }
+
+        public static TheoryData<IReadOnlyList<string>, IReadOnlyList<SortOrder>, (string, SortOrder)[]> GetOrderBy_Success_TestData()
+        {
+            var data = new TheoryData<IReadOnlyList<string>, IReadOnlyList<SortOrder>, (string, SortOrder)[]>();
+
+            data.Add(
+                Array.Empty<string>(),
+                Array.Empty<SortOrder>(),
+                Array.Empty<(string, SortOrder)>());
+
+            data.Add(
+                new string[]
+                {
+                    "IsFavoriteOrLiked",
+                    "Random"
+                },
+                Array.Empty<SortOrder>(),
+                new (string, SortOrder)[]
+                {
+                    ("IsFavoriteOrLiked", SortOrder.Ascending),
+                    ("Random", SortOrder.Ascending),
+                });
+
+            data.Add(
+                new string[]
+                {
+                    "SortName",
+                    "ProductionYear"
+                },
+                new SortOrder[]
+                {
+                    SortOrder.Descending
+                },
+                new (string, SortOrder)[]
+                {
+                    ("SortName", SortOrder.Descending),
+                    ("ProductionYear", SortOrder.Descending),
+                });
+
+            return data;
+        }
+    }
+}
diff --git a/tests/Jellyfin.Api.Tests/Jellyfin.Api.Tests.csproj b/tests/Jellyfin.Api.Tests/Jellyfin.Api.Tests.csproj
index 07972bb42..bcbe9c1be 100644
--- a/tests/Jellyfin.Api.Tests/Jellyfin.Api.Tests.csproj
+++ b/tests/Jellyfin.Api.Tests/Jellyfin.Api.Tests.csproj
@@ -6,39 +6,34 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
     <IsPackable>false</IsPackable>
-    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-    <Nullable>enable</Nullable>
+    <CodeAnalysisRuleSet>../jellyfin-tests.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="AutoFixture" Version="4.15.0" />
-    <PackageReference Include="AutoFixture.AutoMoq" Version="4.15.0" />
-    <PackageReference Include="AutoFixture.Xunit2" Version="4.15.0" />
-    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="5.0.1" />
-    <PackageReference Include="Microsoft.Extensions.Options" Version="5.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3" />
+    <PackageReference Include="AutoFixture" Version="4.17.0" />
+    <PackageReference Include="AutoFixture.AutoMoq" Version="4.17.0" />
+    <PackageReference Include="AutoFixture.Xunit2" Version="4.17.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="6.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Options" Version="6.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" />
-    <PackageReference Include="coverlet.collector" Version="3.0.0" />
-    <PackageReference Include="Moq" Version="4.15.2" />
+    <PackageReference Include="coverlet.collector" Version="3.1.0" />
+    <PackageReference Include="Moq" Version="4.16.1" />
   </ItemGroup>
 
   <!-- Code Analyzers -->
   <ItemGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="2.9.8" PrivateAssets="All" />
     <PackageReference Include="SerilogAnalyzer" Version="0.15.0" PrivateAssets="All" />
     <PackageReference Include="StyleCop.Analyzers" Version="1.1.118" PrivateAssets="All" />
     <PackageReference Include="SmartAnalyzers.MultithreadingAnalyzer" Version="1.1.31" PrivateAssets="All" />
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\..\Jellyfin.Server\Jellyfin.Server.csproj" />
+    <ProjectReference Include="../../Jellyfin.Api/Jellyfin.Api.csproj" />
+    <ProjectReference Include="../../Jellyfin.Server.Implementations/Jellyfin.Server.Implementations.csproj" />
   </ItemGroup>
 
-  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <CodeAnalysisRuleSet>../jellyfin-tests.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-
 </Project>
diff --git a/tests/Jellyfin.Api.Tests/ModelBinders/TestType.cs b/tests/Jellyfin.Api.Tests/ModelBinders/TestType.cs
index 544a74637..92c534eae 100644
--- a/tests/Jellyfin.Api.Tests/ModelBinders/TestType.cs
+++ b/tests/Jellyfin.Api.Tests/ModelBinders/TestType.cs
@@ -1,17 +1,11 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
 namespace Jellyfin.Api.Tests.ModelBinders
 {
     public enum TestType
     {
-#pragma warning disable SA1602 // Enumeration items should be documented
         How,
         Much,
         Is,
         The,
         Fish
-#pragma warning restore SA1602 // Enumeration items should be documented
     }
 }
diff --git a/tests/Jellyfin.Api.Tests/TestHelpers.cs b/tests/Jellyfin.Api.Tests/TestHelpers.cs
index f27cdf7b6..f9bca4146 100644
--- a/tests/Jellyfin.Api.Tests/TestHelpers.cs
+++ b/tests/Jellyfin.Api.Tests/TestHelpers.cs
@@ -26,8 +26,11 @@ namespace Jellyfin.Api.Tests
         {
             var user = new User(
                 "jellyfin",
-                typeof(DefaultAuthenticationProvider).FullName,
-                typeof(DefaultPasswordResetProvider).FullName);
+                typeof(DefaultAuthenticationProvider).FullName!,
+                typeof(DefaultPasswordResetProvider).FullName!);
+
+            user.AddDefaultPermissions();
+            user.AddDefaultPreferences();
 
             // Set administrator flag.
             user.SetPermission(PermissionKind.IsAdministrator, role.Equals(UserRoles.Administrator, StringComparison.OrdinalIgnoreCase));
diff --git a/tests/Jellyfin.Common.Tests/Crc32Tests.cs b/tests/Jellyfin.Common.Tests/Crc32Tests.cs
new file mode 100644
index 000000000..e95a2867f
--- /dev/null
+++ b/tests/Jellyfin.Common.Tests/Crc32Tests.cs
@@ -0,0 +1,33 @@
+using System;
+using System.Text;
+using MediaBrowser.Common;
+using Xunit;
+
+namespace Jellyfin.Common.Tests
+{
+    public static class Crc32Tests
+    {
+        [Fact]
+        public static void Compute_Empty_Zero()
+        {
+            Assert.Equal<uint>(0, Crc32.Compute(Array.Empty<byte>()));
+        }
+
+        [Theory]
+        [InlineData(0x414fa339, "The quick brown fox jumps over the lazy dog")]
+        public static void Compute_Valid_Success(uint expected, string data)
+        {
+            Assert.Equal(expected, Crc32.Compute(Encoding.UTF8.GetBytes(data)));
+        }
+
+        [Theory]
+        [InlineData(0x414fa339, "54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F67")]
+        [InlineData(0x190a55ad, "0000000000000000000000000000000000000000000000000000000000000000")]
+        [InlineData(0xff6cab0b, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")]
+        [InlineData(0x91267e8a, "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F")]
+        public static void Compute_ValidHex_Success(uint expected, string data)
+        {
+            Assert.Equal(expected, Crc32.Compute(Convert.FromHexString(data)));
+        }
+    }
+}
diff --git a/tests/Jellyfin.Common.Tests/Extensions/StringExtensionsTests.cs b/tests/Jellyfin.Common.Tests/Extensions/StringExtensionsTests.cs
deleted file mode 100644
index 8bf613f05..000000000
--- a/tests/Jellyfin.Common.Tests/Extensions/StringExtensionsTests.cs
+++ /dev/null
@@ -1,43 +0,0 @@
-using System;
-using MediaBrowser.Common.Extensions;
-using Xunit;
-
-namespace Jellyfin.Common.Tests.Extensions
-{
-    public class StringExtensionsTests
-    {
-        [Theory]
-        [InlineData("", 'q', "")]
-        [InlineData("Banana split", ' ', "Banana")]
-        [InlineData("Banana split", 'q', "Banana split")]
-        public void LeftPart_ValidArgsCharNeedle_Correct(string str, char needle, string expectedResult)
-        {
-            var result = str.AsSpan().LeftPart(needle).ToString();
-            Assert.Equal(expectedResult, result);
-        }
-
-        [Theory]
-        [InlineData("", "", "")]
-        [InlineData("", "q", "")]
-        [InlineData("Banana split", "", "")]
-        [InlineData("Banana split", " ", "Banana")]
-        [InlineData("Banana split test", " split", "Banana")]
-        public void LeftPart_ValidArgsWithoutStringComparison_Correct(string str, string needle, string expectedResult)
-        {
-            var result = str.AsSpan().LeftPart(needle).ToString();
-            Assert.Equal(expectedResult, result);
-        }
-
-        [Theory]
-        [InlineData("", "", StringComparison.Ordinal, "")]
-        [InlineData("Banana split", " ", StringComparison.Ordinal, "Banana")]
-        [InlineData("Banana split test", " split", StringComparison.Ordinal, "Banana")]
-        [InlineData("Banana split test", " Split", StringComparison.Ordinal, "Banana split test")]
-        [InlineData("Banana split test", " Splït", StringComparison.InvariantCultureIgnoreCase, "Banana split test")]
-        public void LeftPart_ValidArgs_Correct(string str, string needle, StringComparison stringComparison, string expectedResult)
-        {
-            var result = str.AsSpan().LeftPart(needle, stringComparison).ToString();
-            Assert.Equal(expectedResult, result);
-        }
-    }
-}
diff --git a/tests/Jellyfin.Common.Tests/Jellyfin.Common.Tests.csproj b/tests/Jellyfin.Common.Tests/Jellyfin.Common.Tests.csproj
index fdeeda5a3..ce607b2ec 100644
--- a/tests/Jellyfin.Common.Tests/Jellyfin.Common.Tests.csproj
+++ b/tests/Jellyfin.Common.Tests/Jellyfin.Common.Tests.csproj
@@ -6,22 +6,21 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
     <IsPackable>false</IsPackable>
-    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-    <Nullable>enable</Nullable>
+    <CodeAnalysisRuleSet>../jellyfin-tests.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" />
-    <PackageReference Include="coverlet.collector" Version="3.0.0" />
+    <PackageReference Include="coverlet.collector" Version="3.1.0" />
+    <PackageReference Include="FsCheck.Xunit" Version="2.16.3" />
   </ItemGroup>
 
   <!-- Code Analyzers -->
   <ItemGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="2.9.8" PrivateAssets="All" />
     <PackageReference Include="SerilogAnalyzer" Version="0.15.0" PrivateAssets="All" />
     <PackageReference Include="StyleCop.Analyzers" Version="1.1.118" PrivateAssets="All" />
     <PackageReference Include="SmartAnalyzers.MultithreadingAnalyzer" Version="1.1.31" PrivateAssets="All" />
@@ -32,8 +31,4 @@
     <ProjectReference Include="../../MediaBrowser.Providers/MediaBrowser.Providers.csproj" />
   </ItemGroup>
 
-  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <CodeAnalysisRuleSet>../jellyfin-tests.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-
 </Project>
diff --git a/tests/Jellyfin.Common.Tests/Json/JsonBoolNumberTests.cs b/tests/Jellyfin.Common.Tests/Json/JsonBoolNumberTests.cs
deleted file mode 100644
index 9ded01f2b..000000000
--- a/tests/Jellyfin.Common.Tests/Json/JsonBoolNumberTests.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-using System.Text.Json;
-using MediaBrowser.Common.Json.Converters;
-using Xunit;
-
-namespace Jellyfin.Common.Tests.Json
-{
-    public static class JsonBoolNumberTests
-    {
-        [Theory]
-        [InlineData("1", true)]
-        [InlineData("0", false)]
-        [InlineData("2", true)]
-        [InlineData("true", true)]
-        [InlineData("false", false)]
-        public static void Deserialize_Number_Valid_Success(string input, bool? output)
-        {
-            var options = new JsonSerializerOptions();
-            options.Converters.Add(new JsonBoolNumberConverter());
-            var value = JsonSerializer.Deserialize<bool>(input, options);
-            Assert.Equal(value, output);
-        }
-
-        [Theory]
-        [InlineData(true, "true")]
-        [InlineData(false, "false")]
-        public static void Serialize_Bool_Success(bool input, string output)
-        {
-            var options = new JsonSerializerOptions();
-            options.Converters.Add(new JsonBoolNumberConverter());
-            var value = JsonSerializer.Serialize(input, options);
-            Assert.Equal(value, output);
-        }
-    }
-}
\ No newline at end of file
diff --git a/tests/Jellyfin.Common.Tests/PasswordHashTests.cs b/tests/Jellyfin.Common.Tests/PasswordHashTests.cs
deleted file mode 100644
index c4422bd10..000000000
--- a/tests/Jellyfin.Common.Tests/PasswordHashTests.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-using System;
-using MediaBrowser.Common;
-using MediaBrowser.Common.Cryptography;
-using Xunit;
-
-namespace Jellyfin.Common.Tests
-{
-    public class PasswordHashTests
-    {
-        [Theory]
-        [InlineData(
-            "$PBKDF2$iterations=1000$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D",
-            "PBKDF2",
-            "",
-            "62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D")]
-        public void ParseTest(string passwordHash, string id, string salt, string hash)
-        {
-            var pass = PasswordHash.Parse(passwordHash);
-            Assert.Equal(id, pass.Id);
-            Assert.Equal(salt, Convert.ToHexString(pass.Salt));
-            Assert.Equal(hash, Convert.ToHexString(pass.Hash));
-        }
-
-        [Theory]
-        [InlineData("$PBKDF2$iterations=1000$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D")]
-        public void ToStringTest(string passwordHash)
-        {
-            Assert.Equal(passwordHash, PasswordHash.Parse(passwordHash).ToString());
-        }
-    }
-}
diff --git a/tests/Jellyfin.Common.Tests/Providers/ProviderIdParserTests.cs b/tests/Jellyfin.Common.Tests/Providers/ProviderIdParserTests.cs
new file mode 100644
index 000000000..ef9d31cc1
--- /dev/null
+++ b/tests/Jellyfin.Common.Tests/Providers/ProviderIdParserTests.cs
@@ -0,0 +1,85 @@
+using System;
+using MediaBrowser.Common.Providers;
+using Xunit;
+
+namespace Jellyfin.Common.Tests.Providers
+{
+    public class ProviderIdParserTests
+    {
+        [Theory]
+        [InlineData("tt1234567", "tt1234567")]
+        [InlineData("tt12345678", "tt12345678")]
+        [InlineData("https://www.imdb.com/title/tt1234567", "tt1234567")]
+        [InlineData("https://www.imdb.com/title/tt12345678", "tt12345678")]
+        [InlineData(@"multiline\nhttps://www.imdb.com/title/tt1234567", "tt1234567")]
+        [InlineData(@"multiline\nhttps://www.imdb.com/title/tt12345678", "tt12345678")]
+        [InlineData("tt1234567tt7654321", "tt1234567")]
+        [InlineData("tt12345678tt7654321", "tt12345678")]
+        [InlineData("tt123456789", "tt12345678")]
+        public void FindImdbId_Valid_Success(string text, string expected)
+        {
+            Assert.True(ProviderIdParsers.TryFindImdbId(text, out ReadOnlySpan<char> parsedId));
+            Assert.Equal(expected, parsedId.ToString());
+        }
+
+        [Theory]
+        [InlineData("tt123456")]
+        [InlineData("https://www.imdb.com/title/tt123456")]
+        [InlineData("Jellyfin")]
+        public void FindImdbId_Invalid_Success(string text)
+        {
+            Assert.False(ProviderIdParsers.TryFindImdbId(text, out _));
+        }
+
+        [Theory]
+        [InlineData("https://www.themoviedb.org/movie/30287-fallo", "30287")]
+        [InlineData("themoviedb.org/movie/30287", "30287")]
+        public void FindTmdbMovieId_Valid_Success(string text, string expected)
+        {
+            Assert.True(ProviderIdParsers.TryFindTmdbMovieId(text, out ReadOnlySpan<char> parsedId));
+            Assert.Equal(expected, parsedId.ToString());
+        }
+
+        [Theory]
+        [InlineData("https://www.themoviedb.org/movie/fallo-30287")]
+        [InlineData("https://www.themoviedb.org/tv/1668-friends")]
+        public void FindTmdbMovieId_Invalid_Success(string text)
+        {
+            Assert.False(ProviderIdParsers.TryFindTmdbMovieId(text, out _));
+        }
+
+        [Theory]
+        [InlineData("https://www.themoviedb.org/tv/1668-friends", "1668")]
+        [InlineData("themoviedb.org/tv/1668", "1668")]
+        public void FindTmdbSeriesId_Valid_Success(string text, string expected)
+        {
+            Assert.True(ProviderIdParsers.TryFindTmdbSeriesId(text, out ReadOnlySpan<char> parsedId));
+            Assert.Equal(expected, parsedId.ToString());
+        }
+
+        [Theory]
+        [InlineData("https://www.themoviedb.org/tv/friends-1668")]
+        [InlineData("https://www.themoviedb.org/movie/30287-fallo")]
+        public void FindTmdbSeriesId_Invalid_Success(string text)
+        {
+            Assert.False(ProviderIdParsers.TryFindTmdbSeriesId(text, out _));
+        }
+
+        [Theory]
+        [InlineData("https://www.thetvdb.com/?tab=series&id=121361", "121361")]
+        [InlineData("thetvdb.com/?tab=series&id=121361", "121361")]
+        public void FindTvdbId_Valid_Success(string text, string expected)
+        {
+            Assert.True(ProviderIdParsers.TryFindTvdbId(text, out ReadOnlySpan<char> parsedId));
+            Assert.Equal(expected, parsedId.ToString());
+        }
+
+        [Theory]
+        [InlineData("thetvdb.com/?tab=series&id=Jellyfin121361")]
+        [InlineData("https://www.themoviedb.org/tv/1668-friends")]
+        public void FindTvdbId_Invalid_Success(string text)
+        {
+            Assert.False(ProviderIdParsers.TryFindTvdbId(text, out _));
+        }
+    }
+}
diff --git a/tests/Jellyfin.Controller.Tests/BaseItemManagerTests.cs b/tests/Jellyfin.Controller.Tests/BaseItemManagerTests.cs
new file mode 100644
index 000000000..463e17ad3
--- /dev/null
+++ b/tests/Jellyfin.Controller.Tests/BaseItemManagerTests.cs
@@ -0,0 +1,88 @@
+using System;
+using MediaBrowser.Controller.BaseItemManager;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Model.Configuration;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.Controller.Tests
+{
+    public class BaseItemManagerTests
+    {
+        [Theory]
+        [InlineData(typeof(Book), "LibraryEnabled", true)]
+        [InlineData(typeof(Book), "LibraryDisabled", false)]
+        [InlineData(typeof(MusicArtist), "Enabled", true)]
+        [InlineData(typeof(MusicArtist), "ServerDisabled", false)]
+        public void IsMetadataFetcherEnabled_ChecksOptions_ReturnsExpected(Type itemType, string fetcherName, bool expected)
+        {
+            BaseItem item = (BaseItem)Activator.CreateInstance(itemType)!;
+
+            var libraryOptions = new LibraryOptions
+            {
+                TypeOptions = new[]
+                {
+                    new TypeOptions
+                    {
+                        Type = "Book",
+                        MetadataFetchers = new[] { "LibraryEnabled" }
+                    }
+                }
+            };
+
+            var serverConfiguration = new ServerConfiguration();
+            foreach (var typeConfig in serverConfiguration.MetadataOptions)
+            {
+                typeConfig.DisabledMetadataFetchers = new[] { "ServerDisabled" };
+            }
+
+            var serverConfigurationManager = new Mock<IServerConfigurationManager>();
+            serverConfigurationManager.Setup(scm => scm.Configuration)
+                .Returns(serverConfiguration);
+
+            var baseItemManager = new BaseItemManager(serverConfigurationManager.Object);
+            var actual = baseItemManager.IsMetadataFetcherEnabled(item, libraryOptions, fetcherName);
+
+            Assert.Equal(expected, actual);
+        }
+
+        [Theory]
+        [InlineData(typeof(Book), "LibraryEnabled", true)]
+        [InlineData(typeof(Book), "LibraryDisabled", false)]
+        [InlineData(typeof(MusicArtist), "Enabled", true)]
+        [InlineData(typeof(MusicArtist), "ServerDisabled", false)]
+        public void IsImageFetcherEnabled_ChecksOptions_ReturnsExpected(Type itemType, string fetcherName, bool expected)
+        {
+            BaseItem item = (BaseItem)Activator.CreateInstance(itemType)!;
+
+            var libraryOptions = new LibraryOptions
+            {
+                TypeOptions = new[]
+                {
+                    new TypeOptions
+                    {
+                        Type = "Book",
+                        ImageFetchers = new[] { "LibraryEnabled" }
+                    }
+                }
+            };
+
+            var serverConfiguration = new ServerConfiguration();
+            foreach (var typeConfig in serverConfiguration.MetadataOptions)
+            {
+                typeConfig.DisabledImageFetchers = new[] { "ServerDisabled" };
+            }
+
+            var serverConfigurationManager = new Mock<IServerConfigurationManager>();
+            serverConfigurationManager.Setup(scm => scm.Configuration)
+                .Returns(serverConfiguration);
+
+            var baseItemManager = new BaseItemManager(serverConfigurationManager.Object);
+            var actual = baseItemManager.IsImageFetcherEnabled(item, libraryOptions, fetcherName);
+
+            Assert.Equal(expected, actual);
+        }
+    }
+}
diff --git a/tests/Jellyfin.Controller.Tests/DirectoryServiceTests.cs b/tests/Jellyfin.Controller.Tests/DirectoryServiceTests.cs
new file mode 100644
index 000000000..feffb50e8
--- /dev/null
+++ b/tests/Jellyfin.Controller.Tests/DirectoryServiceTests.cs
@@ -0,0 +1,200 @@
+using System.Linq;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.IO;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.Controller.Tests
+{
+    public class DirectoryServiceTests
+    {
+        private const string LowerCasePath = "/music/someartist";
+        private const string UpperCasePath = "/music/SOMEARTIST";
+
+        private static readonly FileSystemMetadata[] _lowerCaseFileSystemMetadata =
+        {
+            new ()
+            {
+                FullName = LowerCasePath + "/Artwork",
+                IsDirectory = true
+            },
+            new ()
+            {
+                FullName = LowerCasePath + "/Some Other Folder",
+                IsDirectory = true
+            },
+            new ()
+            {
+                FullName = LowerCasePath + "/Song 2.mp3",
+                IsDirectory = false
+            },
+            new ()
+            {
+                FullName = LowerCasePath + "/Song 3.mp3",
+                IsDirectory = false
+            }
+        };
+
+        private static readonly FileSystemMetadata[] _upperCaseFileSystemMetadata =
+        {
+            new ()
+            {
+                FullName = UpperCasePath + "/Lyrics",
+                IsDirectory = true
+            },
+            new ()
+            {
+                FullName = UpperCasePath + "/Song 1.mp3",
+                IsDirectory = false
+            }
+        };
+
+        [Fact]
+        public void GetFileSystemEntries_GivenPathsWithDifferentCasing_CachesAll()
+        {
+            var fileSystemMock = new Mock<IFileSystem>();
+            fileSystemMock.Setup(f => f.GetFileSystemEntries(It.Is<string>(x => x == UpperCasePath), false)).Returns(_upperCaseFileSystemMetadata);
+            fileSystemMock.Setup(f => f.GetFileSystemEntries(It.Is<string>(x => x == LowerCasePath), false)).Returns(_lowerCaseFileSystemMetadata);
+            var directoryService = new DirectoryService(fileSystemMock.Object);
+
+            var upperCaseResult = directoryService.GetFileSystemEntries(UpperCasePath);
+            var lowerCaseResult = directoryService.GetFileSystemEntries(LowerCasePath);
+
+            Assert.Equal(_upperCaseFileSystemMetadata, upperCaseResult);
+            Assert.Equal(_lowerCaseFileSystemMetadata, lowerCaseResult);
+        }
+
+        [Fact]
+        public void GetFiles_GivenPathsWithDifferentCasing_ReturnsCorrectFiles()
+        {
+            var fileSystemMock = new Mock<IFileSystem>();
+            fileSystemMock.Setup(f => f.GetFileSystemEntries(It.Is<string>(x => x == UpperCasePath), false)).Returns(_upperCaseFileSystemMetadata);
+            fileSystemMock.Setup(f => f.GetFileSystemEntries(It.Is<string>(x => x == LowerCasePath), false)).Returns(_lowerCaseFileSystemMetadata);
+            var directoryService = new DirectoryService(fileSystemMock.Object);
+
+            var upperCaseResult = directoryService.GetFiles(UpperCasePath);
+            var lowerCaseResult = directoryService.GetFiles(LowerCasePath);
+
+            Assert.Equal(_upperCaseFileSystemMetadata.Where(f => !f.IsDirectory), upperCaseResult);
+            Assert.Equal(_lowerCaseFileSystemMetadata.Where(f => !f.IsDirectory), lowerCaseResult);
+        }
+
+        [Fact]
+        public void GetFile_GivenFilePathsWithDifferentCasing_ReturnsCorrectFile()
+        {
+            const string lowerCasePath = "/music/someartist/song 1.mp3";
+            var lowerCaseFileSystemMetadata = new FileSystemMetadata
+            {
+                FullName = lowerCasePath,
+                Exists = true
+            };
+            const string upperCasePath = "/music/SOMEARTIST/SONG 1.mp3";
+            var upperCaseFileSystemMetadata = new FileSystemMetadata
+            {
+                FullName = upperCasePath,
+                Exists = false
+            };
+            var fileSystemMock = new Mock<IFileSystem>();
+            fileSystemMock.Setup(f => f.GetFileInfo(It.Is<string>(x => x == upperCasePath))).Returns(upperCaseFileSystemMetadata);
+            fileSystemMock.Setup(f => f.GetFileInfo(It.Is<string>(x => x == lowerCasePath))).Returns(lowerCaseFileSystemMetadata);
+            var directoryService = new DirectoryService(fileSystemMock.Object);
+
+            var lowerCaseResult = directoryService.GetFile(lowerCasePath);
+            var upperCaseResult = directoryService.GetFile(upperCasePath);
+
+            Assert.Equal(lowerCaseFileSystemMetadata, lowerCaseResult);
+            Assert.Null(upperCaseResult);
+        }
+
+        [Fact]
+        public void GetFile_GivenCachedPath_ReturnsCachedFile()
+        {
+            const string path = "/music/someartist/song 1.mp3";
+            var cachedFileSystemMetadata = new FileSystemMetadata
+            {
+                FullName = path,
+                Exists = true
+            };
+            var newFileSystemMetadata = new FileSystemMetadata
+            {
+                FullName = "/music/SOMEARTIST/song 1.mp3",
+                Exists = true
+            };
+
+            var fileSystemMock = new Mock<IFileSystem>();
+            fileSystemMock.Setup(f => f.GetFileInfo(It.Is<string>(x => x == path))).Returns(cachedFileSystemMetadata);
+            var directoryService = new DirectoryService(fileSystemMock.Object);
+
+            var result = directoryService.GetFile(path);
+            fileSystemMock.Setup(f => f.GetFileInfo(It.Is<string>(x => x == path))).Returns(newFileSystemMetadata);
+            var secondResult = directoryService.GetFile(path);
+
+            Assert.Equal(cachedFileSystemMetadata, result);
+            Assert.Equal(cachedFileSystemMetadata, secondResult);
+        }
+
+        [Fact]
+        public void GetFilePaths_GivenCachedFilePathWithoutClear_ReturnsOnlyCachedPaths()
+        {
+            const string path = "/music/someartist";
+
+            var cachedPaths = new[]
+            {
+                "/music/someartist/song 1.mp3",
+                "/music/someartist/song 2.mp3",
+                "/music/someartist/song 3.mp3",
+                "/music/someartist/song 4.mp3",
+            };
+            var newPaths = new[]
+            {
+                "/music/someartist/song 5.mp3",
+                "/music/someartist/song 6.mp3",
+                "/music/someartist/song 7.mp3",
+                "/music/someartist/song 8.mp3",
+            };
+
+            var fileSystemMock = new Mock<IFileSystem>();
+            fileSystemMock.Setup(f => f.GetFilePaths(It.Is<string>(x => x == path), false)).Returns(cachedPaths);
+            var directoryService = new DirectoryService(fileSystemMock.Object);
+
+            var result = directoryService.GetFilePaths(path);
+            fileSystemMock.Setup(f => f.GetFilePaths(It.Is<string>(x => x == path), false)).Returns(newPaths);
+            var secondResult = directoryService.GetFilePaths(path);
+
+            Assert.Equal(cachedPaths, result);
+            Assert.Equal(cachedPaths, secondResult);
+        }
+
+        [Fact]
+        public void GetFilePaths_GivenCachedFilePathWithClear_ReturnsNewPaths()
+        {
+            const string path = "/music/someartist";
+
+            var cachedPaths = new[]
+            {
+                "/music/someartist/song 1.mp3",
+                "/music/someartist/song 2.mp3",
+                "/music/someartist/song 3.mp3",
+                "/music/someartist/song 4.mp3",
+            };
+            var newPaths = new[]
+            {
+                "/music/someartist/song 5.mp3",
+                "/music/someartist/song 6.mp3",
+                "/music/someartist/song 7.mp3",
+                "/music/someartist/song 8.mp3",
+            };
+
+            var fileSystemMock = new Mock<IFileSystem>();
+            fileSystemMock.Setup(f => f.GetFilePaths(It.Is<string>(x => x == path), false)).Returns(cachedPaths);
+            var directoryService = new DirectoryService(fileSystemMock.Object);
+
+            var result = directoryService.GetFilePaths(path);
+            fileSystemMock.Setup(f => f.GetFilePaths(It.Is<string>(x => x == path), false)).Returns(newPaths);
+            var secondResult = directoryService.GetFilePaths(path, true);
+
+            Assert.Equal(cachedPaths, result);
+            Assert.Equal(newPaths, secondResult);
+        }
+    }
+}
diff --git a/tests/Jellyfin.Controller.Tests/Jellyfin.Controller.Tests.csproj b/tests/Jellyfin.Controller.Tests/Jellyfin.Controller.Tests.csproj
index 84655db24..0ffc19833 100644
--- a/tests/Jellyfin.Controller.Tests/Jellyfin.Controller.Tests.csproj
+++ b/tests/Jellyfin.Controller.Tests/Jellyfin.Controller.Tests.csproj
@@ -6,22 +6,21 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
     <IsPackable>false</IsPackable>
-    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-    <Nullable>enable</Nullable>
+    <CodeAnalysisRuleSet>../jellyfin-tests.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
+    <PackageReference Include="Moq" Version="4.16.1" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" />
-    <PackageReference Include="coverlet.collector" Version="3.0.0" />
+    <PackageReference Include="coverlet.collector" Version="3.1.0" />
   </ItemGroup>
 
   <!-- Code Analyzers -->
   <ItemGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="2.9.8" PrivateAssets="All" />
     <PackageReference Include="SerilogAnalyzer" Version="0.15.0" PrivateAssets="All" />
     <PackageReference Include="StyleCop.Analyzers" Version="1.1.118" PrivateAssets="All" />
     <PackageReference Include="SmartAnalyzers.MultithreadingAnalyzer" Version="1.1.31" PrivateAssets="All" />
@@ -31,8 +30,4 @@
     <ProjectReference Include="../../MediaBrowser.Controller/MediaBrowser.Controller.csproj" />
   </ItemGroup>
 
-  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <CodeAnalysisRuleSet>../jellyfin-tests.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-
 </Project>
diff --git a/tests/Jellyfin.Dlna.Tests/DlnaManagerTests.cs b/tests/Jellyfin.Dlna.Tests/DlnaManagerTests.cs
new file mode 100644
index 000000000..668bd8f87
--- /dev/null
+++ b/tests/Jellyfin.Dlna.Tests/DlnaManagerTests.cs
@@ -0,0 +1,131 @@
+using Emby.Dlna;
+using Emby.Dlna.PlayTo;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller;
+using MediaBrowser.Model.Dlna;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Model.Serialization;
+using Microsoft.Extensions.Logging;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.Dlna.Tests
+{
+    public class DlnaManagerTests
+    {
+        private DlnaManager GetManager()
+        {
+            var xmlSerializer = new Mock<IXmlSerializer>();
+            var fileSystem = new Mock<IFileSystem>();
+            var appPaths = new Mock<IApplicationPaths>();
+            var loggerFactory = new Mock<ILoggerFactory>();
+            var appHost = new Mock<IServerApplicationHost>();
+
+            return new DlnaManager(xmlSerializer.Object, fileSystem.Object, appPaths.Object, loggerFactory.Object, appHost.Object);
+        }
+
+        [Fact]
+        public void IsMatch_GivenMatchingName_ReturnsTrue()
+        {
+            var device = new DeviceInfo()
+            {
+                Name = "My Device",
+                Manufacturer = "LG Electronics",
+                ManufacturerUrl = "http://www.lge.com",
+                ModelDescription = "LG WebOSTV DMRplus",
+                ModelName = "LG TV",
+                ModelNumber = "1.0",
+            };
+
+            var profile = new DeviceProfile()
+            {
+                Name = "Test Profile",
+                FriendlyName = "My Device",
+                Manufacturer = "LG Electronics",
+                ManufacturerUrl = "http://www.lge.com",
+                ModelDescription = "LG WebOSTV DMRplus",
+                ModelName = "LG TV",
+                ModelNumber = "1.0",
+                Identification = new ()
+                {
+                    FriendlyName = "My Device",
+                    Manufacturer = "LG Electronics",
+                    ManufacturerUrl = "http://www.lge.com",
+                    ModelDescription = "LG WebOSTV DMRplus",
+                    ModelName = "LG TV",
+                    ModelNumber = "1.0",
+                }
+            };
+
+            var profile2 = new DeviceProfile()
+            {
+                Name = "Test Profile",
+                FriendlyName = "My Device",
+                Identification = new DeviceIdentification()
+                {
+                    FriendlyName = "My Device",
+                }
+            };
+
+            var deviceMatch = GetManager().IsMatch(device.ToDeviceIdentification(), profile2.Identification);
+            var deviceMatch2 = GetManager().IsMatch(device.ToDeviceIdentification(), profile.Identification);
+
+            Assert.True(deviceMatch);
+            Assert.True(deviceMatch2);
+        }
+
+        [Fact]
+        public void IsMatch_GivenNamesAndManufacturersDoNotMatch_ReturnsFalse()
+        {
+            var device = new DeviceInfo()
+            {
+                Name = "My Device",
+                Manufacturer = "JVC"
+            };
+
+            var profile = new DeviceProfile()
+            {
+                Name = "Test Profile",
+                FriendlyName = "My Device",
+                Manufacturer = "LG Electronics",
+                ManufacturerUrl = "http://www.lge.com",
+                ModelDescription = "LG WebOSTV DMRplus",
+                ModelName = "LG TV",
+                ModelNumber = "1.0",
+                Identification = new ()
+                {
+                    FriendlyName = "My Device",
+                    Manufacturer = "LG Electronics",
+                    ManufacturerUrl = "http://www.lge.com",
+                    ModelDescription = "LG WebOSTV DMRplus",
+                    ModelName = "LG TV",
+                    ModelNumber = "1.0",
+                }
+            };
+
+            var deviceMatch = GetManager().IsMatch(device.ToDeviceIdentification(), profile.Identification);
+
+            Assert.False(deviceMatch);
+        }
+
+        [Fact]
+        public void IsMatch_GivenNamesAndRegExMatch_ReturnsTrue()
+        {
+            var device = new DeviceInfo()
+            {
+                Name = "My Device"
+            };
+
+            var profile = new DeviceProfile()
+            {
+                Name = "Test Profile",
+                FriendlyName = "My .*",
+                Identification = new ()
+            };
+
+            var deviceMatch = GetManager().IsMatch(device.ToDeviceIdentification(), profile.Identification);
+
+            Assert.True(deviceMatch);
+        }
+    }
+}
diff --git a/tests/Jellyfin.Dlna.Tests/Jellyfin.Dlna.Tests.csproj b/tests/Jellyfin.Dlna.Tests/Jellyfin.Dlna.Tests.csproj
index c5b01f4db..098166001 100644
--- a/tests/Jellyfin.Dlna.Tests/Jellyfin.Dlna.Tests.csproj
+++ b/tests/Jellyfin.Dlna.Tests/Jellyfin.Dlna.Tests.csproj
@@ -1,22 +1,21 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
     <IsPackable>false</IsPackable>
-    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-    <Nullable>enable</Nullable>
+    <CodeAnalysisRuleSet>../jellyfin-tests.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
+    <PackageReference Include="Moq" Version="4.16.1" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" />
-    <PackageReference Include="coverlet.collector" Version="3.0.0" />
+    <PackageReference Include="coverlet.collector" Version="3.1.0" />
   </ItemGroup>
 
   <!-- Code Analyzers -->
   <ItemGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="2.9.8" PrivateAssets="All" />
     <PackageReference Include="SerilogAnalyzer" Version="0.15.0" PrivateAssets="All" />
     <PackageReference Include="StyleCop.Analyzers" Version="1.1.118" PrivateAssets="All" />
     <PackageReference Include="SmartAnalyzers.MultithreadingAnalyzer" Version="1.1.31" PrivateAssets="All" />
@@ -26,8 +25,4 @@
     <ProjectReference Include="../../Emby.Dlna/Emby.Dlna.csproj" />
   </ItemGroup>
 
-  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <CodeAnalysisRuleSet>../jellyfin-tests.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-
 </Project>
diff --git a/tests/Jellyfin.Controller.Tests/AlphanumComparatorTests.cs b/tests/Jellyfin.Extensions.Tests/AlphanumericComparatorTests.cs
index 0adf098c3..7730841a1 100644
--- a/tests/Jellyfin.Controller.Tests/AlphanumComparatorTests.cs
+++ b/tests/Jellyfin.Extensions.Tests/AlphanumericComparatorTests.cs
@@ -1,11 +1,10 @@
 using System;
 using System.Linq;
-using MediaBrowser.Controller.Sorting;
 using Xunit;
 
-namespace Jellyfin.Controller.Tests
+namespace Jellyfin.Extensions.Tests
 {
-    public class AlphanumComparatorTests
+    public class AlphanumericComparatorTests
     {
         // InlineData is pre-sorted
         [Theory]
@@ -20,10 +19,10 @@ namespace Jellyfin.Controller.Tests
         [InlineData("12345678912345678912345678913234567891", "12345678912345678912345678913234567892")]
         [InlineData("12345678912345678912345678913234567891a", "12345678912345678912345678913234567891a")]
         [InlineData("12345678912345678912345678913234567891a", "12345678912345678912345678913234567891b")]
-        public void AlphanumComparatorTest(params string?[] strings)
+        public void AlphanumericComparatorTest(params string?[] strings)
         {
             var copy = strings.Reverse().ToArray();
-            Array.Sort(copy, new AlphanumComparator());
+            Array.Sort(copy, new AlphanumericComparator());
             Assert.True(strings.SequenceEqual(copy));
         }
     }
diff --git a/tests/Jellyfin.Extensions.Tests/CopyToExtensionsTests.cs b/tests/Jellyfin.Extensions.Tests/CopyToExtensionsTests.cs
new file mode 100644
index 000000000..d46beedd9
--- /dev/null
+++ b/tests/Jellyfin.Extensions.Tests/CopyToExtensionsTests.cs
@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using Xunit;
+
+namespace Jellyfin.Extensions.Tests
+{
+    public static class CopyToExtensionsTests
+    {
+        public static TheoryData<IReadOnlyList<int>, IList<int>, int, IList<int>> CopyTo_Valid_Correct_TestData()
+        {
+            var data = new TheoryData<IReadOnlyList<int>, IList<int>, int, IList<int>>();
+
+            data.Add(
+                new[] { 0, 1, 2, 3, 4, 5 }, new[] { 0, 0, 0, 0, 0, 0 }, 0, new[] { 0, 1, 2, 3, 4, 5 });
+
+            data.Add(
+                new[] { 0, 1, 2 }, new[] { 5, 4, 3, 2, 1, 0 }, 2, new[] { 5, 4, 0, 1, 2, 0 } );
+
+            return data;
+        }
+
+        [Theory]
+        [MemberData(nameof(CopyTo_Valid_Correct_TestData))]
+        public static void CopyTo_Valid_Correct<T>(IReadOnlyList<T> source, IList<T> destination, int index, IList<T> expected)
+        {
+            source.CopyTo(destination, index);
+            Assert.Equal(expected, destination);
+        }
+
+        public static TheoryData<IReadOnlyList<int>, IList<int>, int> CopyTo_Invalid_ThrowsArgumentOutOfRangeException_TestData()
+        {
+            var data = new TheoryData<IReadOnlyList<int>, IList<int>, int>();
+
+            data.Add(
+                new[] { 0, 1, 2, 3, 4, 5 }, new[] { 0, 0, 0, 0, 0, 0 }, -1 );
+
+            data.Add(
+                new[] { 0, 1, 2 }, new[] { 5, 4, 3, 2, 1, 0 }, 6 );
+
+            data.Add(
+                new[] { 0, 1, 2 }, Array.Empty<int>(), 0 );
+
+            data.Add(
+                new[] { 0, 1, 2, 3, 4, 5 }, new[] { 0 }, 0 );
+
+            data.Add(
+                new[] { 0, 1, 2, 3, 4, 5 }, new[] { 0, 0, 0, 0, 0, 0 }, 1 );
+
+            return data;
+        }
+
+        [Theory]
+        [MemberData(nameof(CopyTo_Invalid_ThrowsArgumentOutOfRangeException_TestData))]
+        public static void CopyTo_Invalid_ThrowsArgumentOutOfRangeException<T>(IReadOnlyList<T> source, IList<T> destination, int index)
+        {
+            Assert.Throws<ArgumentOutOfRangeException>(() => source.CopyTo(destination, index));
+        }
+    }
+}
diff --git a/tests/Jellyfin.Extensions.Tests/Jellyfin.Extensions.Tests.csproj b/tests/Jellyfin.Extensions.Tests/Jellyfin.Extensions.Tests.csproj
new file mode 100644
index 000000000..ee3af7559
--- /dev/null
+++ b/tests/Jellyfin.Extensions.Tests/Jellyfin.Extensions.Tests.csproj
@@ -0,0 +1,35 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <IsPackable>false</IsPackable>
+    <CodeAnalysisRuleSet>../jellyfin-tests.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
+    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="coverlet.collector" Version="3.1.0">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="FsCheck.Xunit" Version="2.16.3" />
+  </ItemGroup>
+
+  <!-- Code Analyzers -->
+  <ItemGroup Condition=" '$(Configuration)' == 'Debug' ">
+    <PackageReference Include="SerilogAnalyzer" Version="0.15.0" PrivateAssets="All" />
+    <PackageReference Include="StyleCop.Analyzers" Version="1.1.118" PrivateAssets="All" />
+    <PackageReference Include="SmartAnalyzers.MultithreadingAnalyzer" Version="1.1.31" PrivateAssets="All" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../../MediaBrowser.Model/MediaBrowser.Model.csproj" />
+    <ProjectReference Include="../../src/Jellyfin.Extensions/Jellyfin.Extensions.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/tests/Jellyfin.Extensions.Tests/Json/Converters/JsonBoolNumberTests.cs b/tests/Jellyfin.Extensions.Tests/Json/Converters/JsonBoolNumberTests.cs
new file mode 100644
index 000000000..125229ff9
--- /dev/null
+++ b/tests/Jellyfin.Extensions.Tests/Json/Converters/JsonBoolNumberTests.cs
@@ -0,0 +1,44 @@
+using System.Text.Json;
+using FsCheck;
+using FsCheck.Xunit;
+using Jellyfin.Extensions.Json.Converters;
+using Xunit;
+
+namespace Jellyfin.Extensions.Tests.Json.Converters
+{
+    public class JsonBoolNumberTests
+    {
+        private readonly JsonSerializerOptions _jsonOptions = new JsonSerializerOptions()
+        {
+            Converters =
+            {
+                new JsonBoolNumberConverter()
+            }
+        };
+
+        [Theory]
+        [InlineData("1", true)]
+        [InlineData("0", false)]
+        [InlineData("2", true)]
+        [InlineData("true", true)]
+        [InlineData("false", false)]
+        public void Deserialize_Number_Valid_Success(string input, bool? output)
+        {
+            var value = JsonSerializer.Deserialize<bool>(input, _jsonOptions);
+            Assert.Equal(value, output);
+        }
+
+        [Theory]
+        [InlineData(true, "true")]
+        [InlineData(false, "false")]
+        public void Serialize_Bool_Success(bool input, string output)
+        {
+            var value = JsonSerializer.Serialize(input, _jsonOptions);
+            Assert.Equal(value, output);
+        }
+
+        [Property]
+        public Property Deserialize_NonZeroInt_True(NonZeroInt input)
+            => JsonSerializer.Deserialize<bool>(input.ToString(), _jsonOptions).ToProperty();
+    }
+}
diff --git a/tests/Jellyfin.Common.Tests/Json/JsonCommaDelimitedArrayTests.cs b/tests/Jellyfin.Extensions.Tests/Json/Converters/JsonCommaDelimitedArrayTests.cs
index 0d2bdd1af..f2ca2ff08 100644
--- a/tests/Jellyfin.Common.Tests/Json/JsonCommaDelimitedArrayTests.cs
+++ b/tests/Jellyfin.Extensions.Tests/Json/Converters/JsonCommaDelimitedArrayTests.cs
@@ -1,14 +1,36 @@
-using System.Text.Json;
+using System;
+using System.Text.Json;
 using System.Text.Json.Serialization;
-using Jellyfin.Common.Tests.Models;
+using Jellyfin.Extensions.Tests.Json.Models;
 using MediaBrowser.Model.Session;
 using Xunit;
 
-namespace Jellyfin.Common.Tests.Json
+namespace Jellyfin.Extensions.Tests.Json.Converters
 {
     public static class JsonCommaDelimitedArrayTests
     {
         [Fact]
+        public static void Deserialize_String_Null_Success()
+        {
+            var options = new JsonSerializerOptions();
+            var value = JsonSerializer.Deserialize<GenericBodyArrayModel<string>>(@"{ ""Value"": null }", options);
+            Assert.Null(value?.Value);
+        }
+
+        [Fact]
+        public static void Deserialize_Empty_Success()
+        {
+            var desiredValue = new GenericBodyArrayModel<string>
+            {
+                Value = Array.Empty<string>()
+            };
+
+            var options = new JsonSerializerOptions();
+            var value = JsonSerializer.Deserialize<GenericBodyArrayModel<string>>(@"{ ""Value"": """" }", options);
+            Assert.Equal(desiredValue.Value, value?.Value);
+        }
+
+        [Fact]
         public static void Deserialize_String_Valid_Success()
         {
             var desiredValue = new GenericBodyArrayModel<string>
@@ -49,6 +71,34 @@ namespace Jellyfin.Common.Tests.Json
         }
 
         [Fact]
+        public static void Deserialize_GenericCommandType_EmptyEntry_Success()
+        {
+            var desiredValue = new GenericBodyArrayModel<GeneralCommandType>
+            {
+                Value = new[] { GeneralCommandType.MoveUp, GeneralCommandType.MoveDown }
+            };
+
+            var options = new JsonSerializerOptions();
+            options.Converters.Add(new JsonStringEnumConverter());
+            var value = JsonSerializer.Deserialize<GenericBodyArrayModel<GeneralCommandType>>(@"{ ""Value"": ""MoveUp,,MoveDown"" }", options);
+            Assert.Equal(desiredValue.Value, value?.Value);
+        }
+
+        [Fact]
+        public static void Deserialize_GenericCommandType_Invalid_Success()
+        {
+            var desiredValue = new GenericBodyArrayModel<GeneralCommandType>
+            {
+                Value = new[] { GeneralCommandType.MoveUp, GeneralCommandType.MoveDown }
+            };
+
+            var options = new JsonSerializerOptions();
+            options.Converters.Add(new JsonStringEnumConverter());
+            var value = JsonSerializer.Deserialize<GenericBodyArrayModel<GeneralCommandType>>(@"{ ""Value"": ""MoveUp,TotallyNotAVallidCommand,MoveDown"" }", options);
+            Assert.Equal(desiredValue.Value, value?.Value);
+        }
+
+        [Fact]
         public static void Deserialize_GenericCommandType_Space_Valid_Success()
         {
             var desiredValue = new GenericBodyArrayModel<GeneralCommandType>
diff --git a/tests/Jellyfin.Common.Tests/Json/JsonCommaDelimitedIReadOnlyListTests.cs b/tests/Jellyfin.Extensions.Tests/Json/Converters/JsonCommaDelimitedIReadOnlyListTests.cs
index 34ad9bac7..92886dcd2 100644
--- a/tests/Jellyfin.Common.Tests/Json/JsonCommaDelimitedIReadOnlyListTests.cs
+++ b/tests/Jellyfin.Extensions.Tests/Json/Converters/JsonCommaDelimitedIReadOnlyListTests.cs
@@ -1,10 +1,10 @@
-using System.Text.Json;
+using System.Text.Json;
 using System.Text.Json.Serialization;
-using Jellyfin.Common.Tests.Models;
+using Jellyfin.Extensions.Tests.Json.Models;
 using MediaBrowser.Model.Session;
 using Xunit;
 
-namespace Jellyfin.Common.Tests.Json
+namespace Jellyfin.Extensions.Tests.Json.Converters
 {
     public static class JsonCommaDelimitedIReadOnlyListTests
     {
diff --git a/tests/Jellyfin.Common.Tests/Json/JsonGuidConverterTests.cs b/tests/Jellyfin.Extensions.Tests/Json/Converters/JsonGuidConverterTests.cs
index 1e1cde957..8465d465a 100644
--- a/tests/Jellyfin.Common.Tests/Json/JsonGuidConverterTests.cs
+++ b/tests/Jellyfin.Extensions.Tests/Json/Converters/JsonGuidConverterTests.cs
@@ -1,10 +1,9 @@
 using System;
-using System.Globalization;
 using System.Text.Json;
-using MediaBrowser.Common.Json.Converters;
+using Jellyfin.Extensions.Json.Converters;
 using Xunit;
 
-namespace Jellyfin.Common.Tests.Json
+namespace Jellyfin.Extensions.Tests.Json.Converters
 {
     public class JsonGuidConverterTests
     {
diff --git a/tests/Jellyfin.Extensions.Tests/Json/Converters/JsonLowerCaseConverterTests.cs b/tests/Jellyfin.Extensions.Tests/Json/Converters/JsonLowerCaseConverterTests.cs
new file mode 100644
index 000000000..af9227de2
--- /dev/null
+++ b/tests/Jellyfin.Extensions.Tests/Json/Converters/JsonLowerCaseConverterTests.cs
@@ -0,0 +1,71 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Jellyfin.Extensions.Json.Converters;
+using MediaBrowser.Model.Entities;
+using Xunit;
+
+namespace Jellyfin.Extensions.Tests.Json.Converters
+{
+    public class JsonLowerCaseConverterTests
+    {
+        private readonly JsonSerializerOptions _jsonOptions = new JsonSerializerOptions()
+        {
+            Converters =
+            {
+                new JsonStringEnumConverter()
+            }
+        };
+
+        [Theory]
+        [InlineData(null, "{\"CollectionType\":null}")]
+        [InlineData(CollectionTypeOptions.Movies, "{\"CollectionType\":\"movies\"}")]
+        [InlineData(CollectionTypeOptions.MusicVideos, "{\"CollectionType\":\"musicvideos\"}")]
+        public void Serialize_CollectionTypeOptions_Correct(CollectionTypeOptions? collectionType, string expected)
+        {
+            Assert.Equal(expected, JsonSerializer.Serialize(new TestContainer(collectionType), _jsonOptions));
+        }
+
+        [Theory]
+        [InlineData("{\"CollectionType\":null}", null)]
+        [InlineData("{\"CollectionType\":\"movies\"}", CollectionTypeOptions.Movies)]
+        [InlineData("{\"CollectionType\":\"musicvideos\"}", CollectionTypeOptions.MusicVideos)]
+        public void Deserialize_CollectionTypeOptions_Correct(string json, CollectionTypeOptions? result)
+        {
+            var res = JsonSerializer.Deserialize<TestContainer>(json, _jsonOptions);
+            Assert.NotNull(res);
+            Assert.Equal(result, res!.CollectionType);
+        }
+
+        [Theory]
+        [InlineData(null)]
+        [InlineData(CollectionTypeOptions.Movies)]
+        [InlineData(CollectionTypeOptions.MusicVideos)]
+        public void RoundTrip_CollectionTypeOptions_Correct(CollectionTypeOptions? value)
+        {
+            var res = JsonSerializer.Deserialize<TestContainer>(JsonSerializer.Serialize(new TestContainer(value), _jsonOptions), _jsonOptions);
+            Assert.NotNull(res);
+            Assert.Equal(value, res!.CollectionType);
+        }
+
+        [Theory]
+        [InlineData("{\"CollectionType\":null}")]
+        [InlineData("{\"CollectionType\":\"movies\"}")]
+        [InlineData("{\"CollectionType\":\"musicvideos\"}")]
+        public void RoundTrip_String_Correct(string json)
+        {
+            var res = JsonSerializer.Serialize(JsonSerializer.Deserialize<TestContainer>(json, _jsonOptions), _jsonOptions);
+            Assert.Equal(json, res);
+        }
+
+        private class TestContainer
+        {
+            public TestContainer(CollectionTypeOptions? collectionType)
+            {
+                CollectionType = collectionType;
+            }
+
+            [JsonConverter(typeof(JsonLowerCaseConverter<CollectionTypeOptions?>))]
+            public CollectionTypeOptions? CollectionType { get; set; }
+        }
+    }
+}
diff --git a/tests/Jellyfin.Common.Tests/Json/JsonNullableGuidConverterTests.cs b/tests/Jellyfin.Extensions.Tests/Json/Converters/JsonNullableGuidConverterTests.cs
index 22bc7afb9..b0dbc09e4 100644
--- a/tests/Jellyfin.Common.Tests/Json/JsonNullableGuidConverterTests.cs
+++ b/tests/Jellyfin.Extensions.Tests/Json/Converters/JsonNullableGuidConverterTests.cs
@@ -1,10 +1,9 @@
 using System;
-using System.Globalization;
 using System.Text.Json;
-using MediaBrowser.Common.Json.Converters;
+using Jellyfin.Extensions.Json.Converters;
 using Xunit;
 
-namespace Jellyfin.Common.Tests.Json
+namespace Jellyfin.Extensions.Tests.Json.Converters
 {
     public class JsonNullableGuidConverterTests
     {
diff --git a/tests/Jellyfin.Extensions.Tests/Json/Converters/JsonStringConverterTests.cs b/tests/Jellyfin.Extensions.Tests/Json/Converters/JsonStringConverterTests.cs
new file mode 100644
index 000000000..655e07074
--- /dev/null
+++ b/tests/Jellyfin.Extensions.Tests/Json/Converters/JsonStringConverterTests.cs
@@ -0,0 +1,38 @@
+using System.Text.Json;
+using Jellyfin.Extensions.Json.Converters;
+using Xunit;
+
+namespace Jellyfin.Extensions.Tests.Json.Converters
+{
+    public class JsonStringConverterTests
+    {
+        private readonly JsonSerializerOptions _jsonSerializerOptions = new ()
+        {
+            Converters =
+            {
+                new JsonStringConverter()
+            }
+        };
+
+        [Theory]
+        [InlineData("\"test\"", "test")]
+        [InlineData("123", "123")]
+        [InlineData("123.45", "123.45")]
+        [InlineData("true", "true")]
+        [InlineData("false", "false")]
+        public void Deserialize_String_Valid_Success(string input, string output)
+        {
+            var deserialized = JsonSerializer.Deserialize<string>(input, _jsonSerializerOptions);
+            Assert.Equal(deserialized, output);
+        }
+
+        [Fact]
+        public void Deserialize_Int32asInt32_Valid_Success()
+        {
+            const string? input = "123";
+            const int output = 123;
+            var deserialized = JsonSerializer.Deserialize<int>(input, _jsonSerializerOptions);
+            Assert.Equal(deserialized, output);
+        }
+    }
+}
diff --git a/tests/Jellyfin.Extensions.Tests/Json/Converters/JsonVersionConverterTests.cs b/tests/Jellyfin.Extensions.Tests/Json/Converters/JsonVersionConverterTests.cs
new file mode 100644
index 000000000..5fbac7eab
--- /dev/null
+++ b/tests/Jellyfin.Extensions.Tests/Json/Converters/JsonVersionConverterTests.cs
@@ -0,0 +1,36 @@
+using System;
+using System.Text.Json;
+using Jellyfin.Extensions.Json.Converters;
+using Xunit;
+
+namespace Jellyfin.Extensions.Tests.Json.Converters
+{
+    public class JsonVersionConverterTests
+    {
+        private readonly JsonSerializerOptions _options;
+
+        public JsonVersionConverterTests()
+        {
+            _options = new JsonSerializerOptions();
+            _options.Converters.Add(new JsonVersionConverter());
+        }
+
+        [Fact]
+        public void Deserialize_Version_Success()
+        {
+            var input = "\"1.025.222\"";
+            var output = new Version(1, 25, 222);
+            var deserializedInput = JsonSerializer.Deserialize<Version>(input, _options);
+            Assert.Equal(output, deserializedInput);
+        }
+
+        [Fact]
+        public void Serialize_Version_Success()
+        {
+            var input = new Version(1, 09, 59);
+            var output = "\"1.9.59\"";
+            var serializedInput = JsonSerializer.Serialize(input, _options);
+            Assert.Equal(output, serializedInput);
+        }
+    }
+}
diff --git a/tests/Jellyfin.Common.Tests/Models/GenericBodyArrayModel.cs b/tests/Jellyfin.Extensions.Tests/Json/Models/GenericBodyArrayModel.cs
index 276e1bfbe..ef135278f 100644
--- a/tests/Jellyfin.Common.Tests/Models/GenericBodyArrayModel.cs
+++ b/tests/Jellyfin.Extensions.Tests/Json/Models/GenericBodyArrayModel.cs
@@ -1,8 +1,8 @@
-using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics.CodeAnalysis;
 using System.Text.Json.Serialization;
-using MediaBrowser.Common.Json.Converters;
+using Jellyfin.Extensions.Json.Converters;
 
-namespace Jellyfin.Common.Tests.Models
+namespace Jellyfin.Extensions.Tests.Json.Models
 {
     /// <summary>
     /// The generic body model.
diff --git a/tests/Jellyfin.Common.Tests/Models/GenericBodyIReadOnlyListModel.cs b/tests/Jellyfin.Extensions.Tests/Json/Models/GenericBodyIReadOnlyListModel.cs
index 627454b25..8e7b5a35b 100644
--- a/tests/Jellyfin.Common.Tests/Models/GenericBodyIReadOnlyListModel.cs
+++ b/tests/Jellyfin.Extensions.Tests/Json/Models/GenericBodyIReadOnlyListModel.cs
@@ -1,8 +1,8 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Text.Json.Serialization;
-using MediaBrowser.Common.Json.Converters;
+using Jellyfin.Extensions.Json.Converters;
 
-namespace Jellyfin.Common.Tests.Models
+namespace Jellyfin.Extensions.Tests.Json.Models
 {
     /// <summary>
     /// The generic body <c>IReadOnlyList</c> model.
diff --git a/tests/Jellyfin.Extensions.Tests/ShuffleExtensionsTests.cs b/tests/Jellyfin.Extensions.Tests/ShuffleExtensionsTests.cs
new file mode 100644
index 000000000..a73cfb078
--- /dev/null
+++ b/tests/Jellyfin.Extensions.Tests/ShuffleExtensionsTests.cs
@@ -0,0 +1,19 @@
+using System;
+using Xunit;
+
+namespace Jellyfin.Extensions.Tests
+{
+    public static class ShuffleExtensionsTests
+    {
+        [Fact]
+        public static void Shuffle_Valid_Correct()
+        {
+            byte[] original = new byte[1 << 6];
+            Random.Shared.NextBytes(original);
+            byte[] shuffled = (byte[])original.Clone();
+            shuffled.Shuffle();
+
+            Assert.NotEqual(original, shuffled);
+        }
+    }
+}
diff --git a/tests/Jellyfin.Extensions.Tests/StringExtensionsTests.cs b/tests/Jellyfin.Extensions.Tests/StringExtensionsTests.cs
new file mode 100644
index 000000000..7186cc023
--- /dev/null
+++ b/tests/Jellyfin.Extensions.Tests/StringExtensionsTests.cs
@@ -0,0 +1,41 @@
+using System;
+using Xunit;
+
+namespace Jellyfin.Extensions.Tests
+{
+    public class StringExtensionsTests
+    {
+        [Theory]
+        [InlineData("", '_', 0)]
+        [InlineData("___", '_', 3)]
+        [InlineData("test\x00", '\x00', 1)]
+        [InlineData("Imdb=tt0119567|Tmdb=330|TmdbCollection=328", '|', 2)]
+        public void ReadOnlySpan_Count_Success(string str, char needle, int count)
+        {
+            Assert.Equal(count, str.AsSpan().Count(needle));
+        }
+
+        [Theory]
+        [InlineData("", 'q', "")]
+        [InlineData("Banana split", ' ', "Banana")]
+        [InlineData("Banana split", 'q', "Banana split")]
+        [InlineData("Banana split 2", ' ', "Banana")]
+        public void LeftPart_ValidArgsCharNeedle_Correct(string str, char needle, string expectedResult)
+        {
+            var result = str.AsSpan().LeftPart(needle).ToString();
+            Assert.Equal(expectedResult, result);
+        }
+
+        [Theory]
+        [InlineData("", 'q', "")]
+        [InlineData("Banana split", ' ', "split")]
+        [InlineData("Banana split", 'q', "Banana split")]
+        [InlineData("Banana split.", '.', "")]
+        [InlineData("Banana split 2", ' ', "2")]
+        public void RightPart_ValidArgsCharNeedle_Correct(string str, char needle, string expectedResult)
+        {
+            var result = str.AsSpan().RightPart(needle).ToString();
+            Assert.Equal(expectedResult, result);
+        }
+    }
+}
diff --git a/tests/Jellyfin.MediaEncoding.Tests/EncoderValidatorTests.cs b/tests/Jellyfin.MediaEncoding.Tests/EncoderValidatorTests.cs
index 39fd8afda..c0c363d3d 100644
--- a/tests/Jellyfin.MediaEncoding.Tests/EncoderValidatorTests.cs
+++ b/tests/Jellyfin.MediaEncoding.Tests/EncoderValidatorTests.cs
@@ -1,6 +1,4 @@
 using System;
-using System.Collections;
-using System.Collections.Generic;
 using MediaBrowser.MediaEncoding.Encoder;
 using Microsoft.Extensions.Logging.Abstractions;
 using Xunit;
@@ -9,15 +7,18 @@ namespace Jellyfin.MediaEncoding.Tests
 {
     public class EncoderValidatorTests
     {
+        private readonly EncoderValidator _encoderValidator = new EncoderValidator(new NullLogger<EncoderValidatorTests>(), "ffmpeg");
+
         [Theory]
         [ClassData(typeof(GetFFmpegVersionTestData))]
         public void GetFFmpegVersionTest(string versionOutput, Version? version)
         {
-            var val = new EncoderValidator(new NullLogger<EncoderValidatorTests>());
-            Assert.Equal(version, val.GetFFmpegVersion(versionOutput));
+            Assert.Equal(version, _encoderValidator.GetFFmpegVersionInternal(versionOutput));
         }
 
         [Theory]
+        [InlineData(EncoderValidatorTestsData.FFmpegV44Output, true)]
+        [InlineData(EncoderValidatorTestsData.FFmpegV432Output, true)]
         [InlineData(EncoderValidatorTestsData.FFmpegV431Output, true)]
         [InlineData(EncoderValidatorTestsData.FFmpegV43Output, true)]
         [InlineData(EncoderValidatorTestsData.FFmpegV421Output, true)]
@@ -28,25 +29,24 @@ namespace Jellyfin.MediaEncoding.Tests
         [InlineData(EncoderValidatorTestsData.FFmpegGitUnknownOutput, false)]
         public void ValidateVersionInternalTest(string versionOutput, bool valid)
         {
-            var val = new EncoderValidator(new NullLogger<EncoderValidatorTests>());
-            Assert.Equal(valid, val.ValidateVersionInternal(versionOutput));
+            Assert.Equal(valid, _encoderValidator.ValidateVersionInternal(versionOutput));
         }
 
-        private class GetFFmpegVersionTestData : IEnumerable<object?[]>
+        private class GetFFmpegVersionTestData : TheoryData<string, Version?>
         {
-            public IEnumerator<object?[]> GetEnumerator()
+            public GetFFmpegVersionTestData()
             {
-                yield return new object?[] { EncoderValidatorTestsData.FFmpegV431Output, new Version(4, 3, 1) };
-                yield return new object?[] { EncoderValidatorTestsData.FFmpegV43Output, new Version(4, 3) };
-                yield return new object?[] { EncoderValidatorTestsData.FFmpegV421Output, new Version(4, 2, 1) };
-                yield return new object?[] { EncoderValidatorTestsData.FFmpegV42Output, new Version(4, 2) };
-                yield return new object?[] { EncoderValidatorTestsData.FFmpegV414Output, new Version(4, 1, 4) };
-                yield return new object?[] { EncoderValidatorTestsData.FFmpegV404Output, new Version(4, 0, 4) };
-                yield return new object?[] { EncoderValidatorTestsData.FFmpegGitUnknownOutput2, new Version(4, 0) };
-                yield return new object?[] { EncoderValidatorTestsData.FFmpegGitUnknownOutput, null };
+                Add(EncoderValidatorTestsData.FFmpegV44Output, new Version(4, 4));
+                Add(EncoderValidatorTestsData.FFmpegV432Output, new Version(4, 3, 2));
+                Add(EncoderValidatorTestsData.FFmpegV431Output, new Version(4, 3, 1));
+                Add(EncoderValidatorTestsData.FFmpegV43Output, new Version(4, 3));
+                Add(EncoderValidatorTestsData.FFmpegV421Output, new Version(4, 2, 1));
+                Add(EncoderValidatorTestsData.FFmpegV42Output, new Version(4, 2));
+                Add(EncoderValidatorTestsData.FFmpegV414Output, new Version(4, 1, 4));
+                Add(EncoderValidatorTestsData.FFmpegV404Output, new Version(4, 0, 4));
+                Add(EncoderValidatorTestsData.FFmpegGitUnknownOutput2, new Version(4, 0));
+                Add(EncoderValidatorTestsData.FFmpegGitUnknownOutput, null);
             }
-
-            IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
         }
     }
 }
diff --git a/tests/Jellyfin.MediaEncoding.Tests/EncoderValidatorTestsData.cs b/tests/Jellyfin.MediaEncoding.Tests/EncoderValidatorTestsData.cs
index 9f5bef9a8..02bf046ed 100644
--- a/tests/Jellyfin.MediaEncoding.Tests/EncoderValidatorTestsData.cs
+++ b/tests/Jellyfin.MediaEncoding.Tests/EncoderValidatorTestsData.cs
@@ -2,6 +2,30 @@ namespace Jellyfin.MediaEncoding.Tests
 {
     internal static class EncoderValidatorTestsData
     {
+        public const string FFmpegV44Output = @"ffmpeg version 4.4-Jellyfin Copyright (c) 2000-2021 the FFmpeg developers
+built with gcc 10.3.0 (Rev5, Built by MSYS2 project)
+configuration:  --disable-static --enable-shared --extra-version=Jellyfin --disable-ffplay --disable-debug --enable-gpl --enable-version3 --enable-bzlib --enable-iconv --enable-lzma --enable-zlib --enable-sdl2 --enable-fontconfig --enable-gmp --enable-libass --enable-libzimg --enable-libbluray --enable-libfreetype --enable-libmp3lame --enable-libopus --enable-libtheora --enable-libvorbis --enable-libwebp --enable-libvpx --enable-libx264 --enable-libx265 --enable-libdav1d --enable-opencl --enable-dxva2 --enable-d3d11va --enable-amf --enable-libmfx --enable-cuda --enable-cuda-llvm --enable-cuvid --enable-nvenc --enable-nvdec --enable-ffnvcodec --enable-gnutls
+libavutil      56. 70.100 / 56. 70.100
+libavcodec     58.134.100 / 58.134.100
+libavformat    58. 76.100 / 58. 76.100
+libavdevice    58. 13.100 / 58. 13.100
+libavfilter     7.110.100 /  7.110.100
+libswscale      5.  9.100 /  5.  9.100
+libswresample   3.  9.100 /  3.  9.100
+libpostproc    55.  9.100 / 55.  9.100";
+
+        public const string FFmpegV432Output = @"ffmpeg version n4.3.2-Jellyfin Copyright (c) 2000-2021 the FFmpeg developers
+built with gcc 10.2.0 (Rev9, Built by MSYS2 project)
+configuration:  --disable-static --enable-shared --cc='ccache gcc' --cxx='ccache g++' --extra-version=Jellyfin --disable-ffplay --disable-debug --enable-lto --enable-gpl --enable-version3 --enable-bzlib --enable-iconv --enable-lzma --enable-zlib --enable-sdl2 --enable-fontconfig --enable-gmp --enable-libass --enable-libzimg --enable-libbluray --enable-libfreetype --enable-libmp3lame --enable-libopus --enable-libtheora --enable-libvorbis --enable-libwebp --enable-libvpx --enable-libx264 --enable-libx265 --enable-libdav1d --enable-opencl --enable-dxva2 --enable-d3d11va --enable-amf --enable-libmfx --enable-cuda --enable-cuda-llvm --enable-cuvid --enable-nvenc --enable-nvdec --enable-ffnvcodec --enable-gnutls
+libavutil      56. 51.100 / 56. 51.100
+libavcodec     58. 91.100 / 58. 91.100
+libavformat    58. 45.100 / 58. 45.100
+libavdevice    58. 10.100 / 58. 10.100
+libavfilter     7. 85.100 /  7. 85.100
+libswscale      5.  7.100 /  5.  7.100
+libswresample   3.  7.100 /  3.  7.100
+libpostproc    55.  7.100 / 55.  7.100";
+
         public const string FFmpegV431Output = @"ffmpeg version n4.3.1 Copyright (c) 2000-2020 the FFmpeg developers
 built with gcc 10.1.0 (GCC)
 configuration: --prefix=/usr --disable-debug --disable-static --disable-stripping --enable-avisynth --enable-fontconfig --enable-gmp --enable-gnutls --enable-gpl --enable-ladspa --enable-libaom --enable-libass --enable-libbluray --enable-libdav1d --enable-libdrm --enable-libfreetype --enable-libfribidi --enable-libgsm --enable-libiec61883 --enable-libjack --enable-libmfx --enable-libmodplug --enable-libmp3lame --enable-libopencore_amrnb --enable-libopencore_amrwb --enable-libopenjpeg --enable-libopus --enable-libpulse --enable-librav1e --enable-libsoxr --enable-libspeex --enable-libsrt --enable-libssh --enable-libtheora --enable-libv4l2 --enable-libvidstab --enable-libvmaf --enable-libvorbis --enable-libvpx --enable-libwebp --enable-libx264 --enable-libx265 --enable-libxcb --enable-libxml2 --enable-libxvid --enable-nvdec --enable-nvenc --enable-omx --enable-shared --enable-version3
diff --git a/tests/Jellyfin.MediaEncoding.Tests/FFprobeParserTests.cs b/tests/Jellyfin.MediaEncoding.Tests/FFprobeParserTests.cs
index c39ef0ce9..97dbb3be0 100644
--- a/tests/Jellyfin.MediaEncoding.Tests/FFprobeParserTests.cs
+++ b/tests/Jellyfin.MediaEncoding.Tests/FFprobeParserTests.cs
@@ -1,8 +1,9 @@
 using System.IO;
 using System.Text.Json;
 using System.Threading.Tasks;
-using MediaBrowser.Common.Json;
+using Jellyfin.Extensions.Json;
 using MediaBrowser.MediaEncoding.Probing;
+using MediaBrowser.Model.IO;
 using Xunit;
 
 namespace Jellyfin.MediaEncoding.Tests
@@ -14,9 +15,10 @@ namespace Jellyfin.MediaEncoding.Tests
         public async Task Test(string fileName)
         {
             var path = Path.Join("Test Data", fileName);
-            using (var stream = File.OpenRead(path))
+            await using (var stream = AsyncFile.OpenRead(path))
             {
-                await JsonSerializer.DeserializeAsync<InternalMediaInfoResult>(stream, JsonDefaults.GetOptions()).ConfigureAwait(false);
+                var res = await JsonSerializer.DeserializeAsync<InternalMediaInfoResult>(stream, JsonDefaults.Options).ConfigureAwait(false);
+                Assert.NotNull(res);
             }
         }
     }
diff --git a/tests/Jellyfin.MediaEncoding.Tests/Jellyfin.MediaEncoding.Tests.csproj b/tests/Jellyfin.MediaEncoding.Tests/Jellyfin.MediaEncoding.Tests.csproj
index ed788bab8..dc4a42c19 100644
--- a/tests/Jellyfin.MediaEncoding.Tests/Jellyfin.MediaEncoding.Tests.csproj
+++ b/tests/Jellyfin.MediaEncoding.Tests/Jellyfin.MediaEncoding.Tests.csproj
@@ -6,10 +6,9 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
     <IsPackable>false</IsPackable>
-    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-    <Nullable>enable</Nullable>
+    <CodeAnalysisRuleSet>../jellyfin-tests.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
 
   <ItemGroup>
@@ -19,15 +18,18 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3" />
+    <PackageReference Include="AutoFixture" Version="4.17.0" />
+    <PackageReference Include="AutoFixture.AutoMoq" Version="4.17.0" />
+    <PackageReference Include="AutoFixture.Xunit2" Version="4.17.0" />
+    <PackageReference Include="coverlet.collector" Version="3.1.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
+    <PackageReference Include="Moq" Version="4.16.1" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" />
-    <PackageReference Include="coverlet.collector" Version="3.0.0" />
   </ItemGroup>
 
   <!-- Code Analyzers -->
   <ItemGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="2.9.8" PrivateAssets="All" />
     <PackageReference Include="SerilogAnalyzer" Version="0.15.0" PrivateAssets="All" />
     <PackageReference Include="StyleCop.Analyzers" Version="1.1.118" PrivateAssets="All" />
     <PackageReference Include="SmartAnalyzers.MultithreadingAnalyzer" Version="1.1.31" PrivateAssets="All" />
@@ -37,8 +39,4 @@
     <ProjectReference Include="../../MediaBrowser.MediaEncoding/MediaBrowser.MediaEncoding.csproj" />
   </ItemGroup>
 
-  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <CodeAnalysisRuleSet>../jellyfin-tests.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-
 </Project>
diff --git a/tests/Jellyfin.MediaEncoding.Tests/Probing/ProbeResultNormalizerTests.cs b/tests/Jellyfin.MediaEncoding.Tests/Probing/ProbeResultNormalizerTests.cs
new file mode 100644
index 000000000..0fc8724b6
--- /dev/null
+++ b/tests/Jellyfin.MediaEncoding.Tests/Probing/ProbeResultNormalizerTests.cs
@@ -0,0 +1,209 @@
+using System;
+using System.Globalization;
+using System.IO;
+using System.Text.Json;
+using Jellyfin.Extensions.Json;
+using MediaBrowser.MediaEncoding.Probing;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Globalization;
+using MediaBrowser.Model.MediaInfo;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.MediaEncoding.Tests.Probing
+{
+    public class ProbeResultNormalizerTests
+    {
+        private readonly JsonSerializerOptions _jsonOptions = JsonDefaults.Options;
+        private readonly ProbeResultNormalizer _probeResultNormalizer = new ProbeResultNormalizer(new NullLogger<EncoderValidatorTests>(), null);
+
+        [Theory]
+        [InlineData("2997/125", 23.976f)]
+        [InlineData("1/50", 0.02f)]
+        [InlineData("25/1", 25f)]
+        [InlineData("120/1", 120f)]
+        [InlineData("1704753000/71073479", 23.98578237601117f)]
+        [InlineData("0/0", null)]
+        [InlineData("1/1000", 0.001f)]
+        [InlineData("1/90000", 1.1111111E-05f)]
+        [InlineData("1/48000", 2.0833333E-05f)]
+        public void GetFrameRate_Success(string value, float? expected)
+            => Assert.Equal(expected, ProbeResultNormalizer.GetFrameRate(value));
+
+        [Fact]
+        public void GetMediaInfo_MetaData_Success()
+        {
+            var bytes = File.ReadAllBytes("Test Data/Probing/video_metadata.json");
+            var internalMediaInfoResult = JsonSerializer.Deserialize<InternalMediaInfoResult>(bytes, _jsonOptions);
+            MediaInfo res = _probeResultNormalizer.GetMediaInfo(internalMediaInfoResult, VideoType.VideoFile, false, "Test Data/Probing/video_metadata.mkv", MediaProtocol.File);
+
+            Assert.Single(res.MediaStreams);
+
+            Assert.NotNull(res.VideoStream);
+            Assert.Equal("4:3", res.VideoStream.AspectRatio);
+            Assert.Equal(25f, res.VideoStream.AverageFrameRate);
+            Assert.Equal(8, res.VideoStream.BitDepth);
+            Assert.Equal(69432, res.VideoStream.BitRate);
+            Assert.Equal("h264", res.VideoStream.Codec);
+            Assert.Equal("1/50", res.VideoStream.CodecTimeBase);
+            Assert.Equal(240, res.VideoStream.Height);
+            Assert.Equal(320, res.VideoStream.Width);
+            Assert.Equal(0, res.VideoStream.Index);
+            Assert.False(res.VideoStream.IsAnamorphic);
+            Assert.True(res.VideoStream.IsAVC);
+            Assert.True(res.VideoStream.IsDefault);
+            Assert.False(res.VideoStream.IsExternal);
+            Assert.False(res.VideoStream.IsForced);
+            Assert.False(res.VideoStream.IsInterlaced);
+            Assert.False(res.VideoStream.IsTextSubtitleStream);
+            Assert.Equal(13d, res.VideoStream.Level);
+            Assert.Equal("4", res.VideoStream.NalLengthSize);
+            Assert.Equal("yuv444p", res.VideoStream.PixelFormat);
+            Assert.Equal("High 4:4:4 Predictive", res.VideoStream.Profile);
+            Assert.Equal(25f, res.VideoStream.RealFrameRate);
+            Assert.Equal(1, res.VideoStream.RefFrames);
+            Assert.Equal("1/1000", res.VideoStream.TimeBase);
+            Assert.Equal(MediaStreamType.Video, res.VideoStream.Type);
+
+            Assert.Empty(res.Chapters);
+            Assert.Equal("Just color bars", res.Overview);
+        }
+
+        [Fact]
+        public void GetMediaInfo_Mp4MetaData_Success()
+        {
+            var bytes = File.ReadAllBytes("Test Data/Probing/video_mp4_metadata.json");
+            var internalMediaInfoResult = JsonSerializer.Deserialize<InternalMediaInfoResult>(bytes, _jsonOptions);
+
+            // subtitle handling requires a localization object, set a mock to return the input string
+            var mockLocalization = new Mock<ILocalizationManager>();
+            mockLocalization.Setup(x => x.GetLocalizedString(It.IsAny<string>())).Returns<string>(x => x);
+            ProbeResultNormalizer localizedProbeResultNormalizer = new ProbeResultNormalizer(new NullLogger<EncoderValidatorTests>(), mockLocalization.Object);
+
+            MediaInfo res = localizedProbeResultNormalizer.GetMediaInfo(internalMediaInfoResult, VideoType.VideoFile, false, "Test Data/Probing/video_mp4_metadata.mkv", MediaProtocol.File);
+
+            // [Video, Audio (Main), Audio (Commentary), Subtitle (Main, Spanish), Subtitle (Main, English), Subtitle (Commentary)
+            Assert.Equal(6, res.MediaStreams.Count);
+
+            Assert.NotNull(res.VideoStream);
+            Assert.Equal(res.MediaStreams[0], res.VideoStream);
+            Assert.Equal(0, res.VideoStream.Index);
+            Assert.Equal("h264", res.VideoStream.Codec);
+            Assert.Equal("High", res.VideoStream.Profile);
+            Assert.Equal(MediaStreamType.Video, res.VideoStream.Type);
+            Assert.Equal(358, res.VideoStream.Height);
+            Assert.Equal(720, res.VideoStream.Width);
+            Assert.Equal("2.40:1", res.VideoStream.AspectRatio);
+            Assert.Equal("yuv420p", res.VideoStream.PixelFormat);
+            Assert.Equal(31d, res.VideoStream.Level);
+            Assert.Equal(1, res.VideoStream.RefFrames);
+            Assert.True(res.VideoStream.IsAVC);
+            Assert.Equal(120f, res.VideoStream.RealFrameRate);
+            Assert.Equal("1/90000", res.VideoStream.TimeBase);
+            Assert.Equal(1147365, res.VideoStream.BitRate);
+            Assert.Equal(8, res.VideoStream.BitDepth);
+            Assert.True(res.VideoStream.IsDefault);
+            Assert.Equal("und", res.VideoStream.Language);
+
+            Assert.Equal(MediaStreamType.Audio, res.MediaStreams[1].Type);
+            Assert.Equal("aac", res.MediaStreams[1].Codec);
+            Assert.Equal(7, res.MediaStreams[1].Channels);
+            Assert.True(res.MediaStreams[1].IsDefault);
+            Assert.Equal("eng", res.MediaStreams[1].Language);
+            Assert.Equal("Surround 6.1", res.MediaStreams[1].Title);
+
+            Assert.Equal(MediaStreamType.Audio, res.MediaStreams[2].Type);
+            Assert.Equal("aac", res.MediaStreams[2].Codec);
+            Assert.Equal(2, res.MediaStreams[2].Channels);
+            Assert.False(res.MediaStreams[2].IsDefault);
+            Assert.Equal("eng", res.MediaStreams[2].Language);
+            Assert.Equal("Commentary", res.MediaStreams[2].Title);
+
+            Assert.Equal("spa", res.MediaStreams[3].Language);
+            Assert.Equal(MediaStreamType.Subtitle, res.MediaStreams[3].Type);
+            Assert.Equal("DVDSUB", res.MediaStreams[3].Codec);
+            Assert.Null(res.MediaStreams[3].Title);
+
+            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.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);
+        }
+
+        [Fact]
+        public void GetMediaInfo_MusicVideo_Success()
+        {
+            var bytes = File.ReadAllBytes("Test Data/Probing/music_video_metadata.json");
+            var internalMediaInfoResult = JsonSerializer.Deserialize<InternalMediaInfoResult>(bytes, _jsonOptions);
+            MediaInfo res = _probeResultNormalizer.GetMediaInfo(internalMediaInfoResult, VideoType.VideoFile, false, "Test Data/Probing/music_video.mkv", MediaProtocol.File);
+
+            Assert.Equal("The Title", res.Name);
+            Assert.Equal("Title, The", res.ForcedSortName);
+            Assert.Single(res.Artists);
+            Assert.Equal("The Artist", res.Artists[0]);
+            Assert.Equal("Album", res.Album);
+            Assert.Equal(2021, res.ProductionYear);
+            Assert.True(res.PremiereDate.HasValue);
+            Assert.Equal(DateTime.Parse("2021-01-01T00:00Z", DateTimeFormatInfo.CurrentInfo, DateTimeStyles.AdjustToUniversal), res.PremiereDate);
+        }
+
+        [Fact]
+        public void GetMediaInfo_GivenOriginalDateContainsOnlyYear_Success()
+        {
+            var bytes = File.ReadAllBytes("Test Data/Probing/music_year_only_metadata.json");
+            var internalMediaInfoResult = JsonSerializer.Deserialize<InternalMediaInfoResult>(bytes, _jsonOptions);
+            MediaInfo res = _probeResultNormalizer.GetMediaInfo(internalMediaInfoResult, null, true, "Test Data/Probing/music.flac", MediaProtocol.File);
+
+            Assert.Equal("Baker Street", res.Name);
+            Assert.Single(res.Artists);
+            Assert.Equal("Gerry Rafferty", res.Artists[0]);
+            Assert.Equal("City to City", res.Album);
+            Assert.Equal(1978, res.ProductionYear);
+            Assert.True(res.PremiereDate.HasValue);
+            Assert.Equal(DateTime.Parse("1978-01-01T00:00Z", DateTimeFormatInfo.CurrentInfo, DateTimeStyles.AdjustToUniversal), res.PremiereDate);
+            Assert.Contains("Electronic", res.Genres);
+            Assert.Contains("Ambient", res.Genres);
+            Assert.Contains("Pop", res.Genres);
+            Assert.Contains("Jazz", res.Genres);
+        }
+
+        [Fact]
+        public void GetMediaInfo_Music_Success()
+        {
+            var bytes = File.ReadAllBytes("Test Data/Probing/music_metadata.json");
+            var internalMediaInfoResult = JsonSerializer.Deserialize<InternalMediaInfoResult>(bytes, _jsonOptions);
+            MediaInfo res = _probeResultNormalizer.GetMediaInfo(internalMediaInfoResult, null, true, "Test Data/Probing/music.flac", MediaProtocol.File);
+
+            Assert.Equal("UP NO MORE", res.Name);
+            Assert.Single(res.Artists);
+            Assert.Equal("TWICE", res.Artists[0]);
+            Assert.Equal("Eyes wide open", res.Album);
+            Assert.Equal(2020, res.ProductionYear);
+            Assert.True(res.PremiereDate.HasValue);
+            Assert.Equal(DateTime.Parse("2020-10-26T00:00Z", DateTimeFormatInfo.CurrentInfo, DateTimeStyles.AdjustToUniversal), res.PremiereDate);
+            Assert.Equal(22, res.People.Length);
+            Assert.Equal("Krysta Youngs", res.People[0].Name);
+            Assert.Equal(PersonType.Composer, res.People[0].Type);
+            Assert.Equal("Julia Ross", res.People[1].Name);
+            Assert.Equal(PersonType.Composer, res.People[1].Type);
+            Assert.Equal("Yiwoomin", res.People[2].Name);
+            Assert.Equal(PersonType.Composer, res.People[2].Type);
+            Assert.Equal("Ji-hyo Park", res.People[3].Name);
+            Assert.Equal(PersonType.Lyricist, res.People[3].Type);
+            Assert.Equal("Yiwoomin", res.People[4].Name);
+            Assert.Equal(PersonType.Actor, res.People[4].Type);
+            Assert.Equal("Electric Piano", res.People[4].Role);
+            Assert.Equal(4, res.Genres.Length);
+            Assert.Contains("Electronic", res.Genres);
+            Assert.Contains("Trance", res.Genres);
+            Assert.Contains("Dance", res.Genres);
+            Assert.Contains("Jazz", res.Genres);
+        }
+    }
+}
diff --git a/tests/Jellyfin.MediaEncoding.Tests/SsaParserTests.cs b/tests/Jellyfin.MediaEncoding.Tests/SsaParserTests.cs
deleted file mode 100644
index d11cb242c..000000000
--- a/tests/Jellyfin.MediaEncoding.Tests/SsaParserTests.cs
+++ /dev/null
@@ -1,96 +0,0 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Text;
-using System.Threading;
-using MediaBrowser.MediaEncoding.Subtitles;
-using MediaBrowser.Model.MediaInfo;
-using Xunit;
-
-namespace Jellyfin.MediaEncoding.Tests
-{
-    public class SsaParserTests
-    {
-        // commonly shared invariant value between tests, assumes default format order
-        private const string InvariantDialoguePrefix = "[Events]\nDialogue: ,0:00:00.00,0:00:00.01,,,,,,,";
-
-        private SsaParser parser = new SsaParser();
-
-        [Theory]
-        [InlineData("[EvEnTs]\nDialogue: ,0:00:00.00,0:00:00.01,,,,,,,text", "text")] // label casing insensitivity
-        [InlineData("[Events]\n,0:00:00.00,0:00:00.01,,,,,,,labelless dialogue", "labelless dialogue")] // no "Dialogue:" label, it is optional
-        [InlineData("[Events]\nFormat: Text, Start, End, Layer, Effect, Style\nDialogue: reordered text,0:00:00.00,0:00:00.01", "reordered text")] // reordered formats
-        [InlineData(InvariantDialoguePrefix + "Cased TEXT", "Cased TEXT")] // preserve text casing
-        [InlineData(InvariantDialoguePrefix + "  text  ", "  text  ")] // do not trim text
-        [InlineData(InvariantDialoguePrefix + "text, more text", "text, more text")] // append excess dialogue values (> 10) to text
-        [InlineData(InvariantDialoguePrefix + "start {\\fnFont Name}text{\\fn} end", "start <font face=\"Font Name\">text</font> end")] // font name
-        [InlineData(InvariantDialoguePrefix + "start {\\fs10}text{\\fs} end", "start <font size=\"10\">text</font> end")] // font size
-        [InlineData(InvariantDialoguePrefix + "start {\\c&H112233}text{\\c} end", "start <font color=\"#332211\">text</font> end")] // color
-        [InlineData(InvariantDialoguePrefix + "start {\\1c&H112233}text{\\1c} end", "start <font color=\"#332211\">text</font> end")] // primay color
-        [InlineData(InvariantDialoguePrefix + "start {\\fnFont Name}text1 {\\fs10}text2{\\fs}{\\fn} {\\1c&H112233}text3{\\1c} end", "start <font face=\"Font Name\">text1 <font size=\"10\">text2</font></font> <font color=\"#332211\">text3</font> end")] // nested formatting
-        public void Parse(string ssa, string expectedText)
-        {
-            using (Stream stream = new MemoryStream(Encoding.UTF8.GetBytes(ssa)))
-            {
-                SubtitleTrackInfo subtitleTrackInfo = parser.Parse(stream, CancellationToken.None);
-                SubtitleTrackEvent actual = subtitleTrackInfo.TrackEvents[0];
-                Assert.Equal(expectedText, actual.Text);
-            }
-        }
-
-        [Theory]
-        [MemberData(nameof(Parse_MultipleDialogues_TestData))]
-        public void Parse_MultipleDialogues(string ssa, IReadOnlyList<SubtitleTrackEvent> expectedSubtitleTrackEvents)
-        {
-            using (Stream stream = new MemoryStream(Encoding.UTF8.GetBytes(ssa)))
-            {
-                SubtitleTrackInfo subtitleTrackInfo = parser.Parse(stream, CancellationToken.None);
-
-                Assert.Equal(expectedSubtitleTrackEvents.Count, subtitleTrackInfo.TrackEvents.Count);
-
-                for (int i = 0; i < expectedSubtitleTrackEvents.Count; ++i)
-                {
-                    SubtitleTrackEvent expected = expectedSubtitleTrackEvents[i];
-                    SubtitleTrackEvent actual = subtitleTrackInfo.TrackEvents[i];
-
-                    Assert.Equal(expected.StartPositionTicks, actual.StartPositionTicks);
-                    Assert.Equal(expected.EndPositionTicks, actual.EndPositionTicks);
-                    Assert.Equal(expected.Text, actual.Text);
-                }
-            }
-        }
-
-        public static IEnumerable<object[]> Parse_MultipleDialogues_TestData()
-        {
-            yield return new object[]
-            {
-                @"[Events]
-                Format: Layer, Start, End, Text
-                Dialogue: ,0:00:01.18,0:00:01.85,dialogue1
-                Dialogue: ,0:00:02.18,0:00:02.85,dialogue2
-                Dialogue: ,0:00:03.18,0:00:03.85,dialogue3
-                ",
-                new List<SubtitleTrackEvent>
-                {
-                    new SubtitleTrackEvent
-                    {
-                        StartPositionTicks = 11800000,
-                        EndPositionTicks = 18500000,
-                        Text = "dialogue1"
-                    },
-                    new SubtitleTrackEvent
-                    {
-                        StartPositionTicks = 21800000,
-                        EndPositionTicks = 28500000,
-                        Text = "dialogue2"
-                    },
-                    new SubtitleTrackEvent
-                    {
-                        StartPositionTicks = 31800000,
-                        EndPositionTicks = 38500000,
-                        Text = "dialogue3"
-                    }
-                }
-            };
-        }
-    }
-}
diff --git a/tests/Jellyfin.MediaEncoding.Tests/Subtitles/AssParserTests.cs b/tests/Jellyfin.MediaEncoding.Tests/Subtitles/AssParserTests.cs
index 14ad49839..3775555de 100644
--- a/tests/Jellyfin.MediaEncoding.Tests/Subtitles/AssParserTests.cs
+++ b/tests/Jellyfin.MediaEncoding.Tests/Subtitles/AssParserTests.cs
@@ -3,6 +3,7 @@ using System.Globalization;
 using System.IO;
 using System.Threading;
 using MediaBrowser.MediaEncoding.Subtitles;
+using Microsoft.Extensions.Logging.Abstractions;
 using Xunit;
 
 namespace Jellyfin.MediaEncoding.Subtitles.Tests
@@ -14,25 +15,15 @@ namespace Jellyfin.MediaEncoding.Subtitles.Tests
         {
             using (var stream = File.OpenRead("Test Data/example.ass"))
             {
-                var parsed = new AssParser().Parse(stream, CancellationToken.None);
+                var parsed = new AssParser(new NullLogger<AssParser>()).Parse(stream, CancellationToken.None);
                 Assert.Single(parsed.TrackEvents);
                 var trackEvent = parsed.TrackEvents[0];
 
                 Assert.Equal("1", trackEvent.Id);
                 Assert.Equal(TimeSpan.Parse("00:00:01.18", CultureInfo.InvariantCulture).Ticks, trackEvent.StartPositionTicks);
                 Assert.Equal(TimeSpan.Parse("00:00:06.85", CultureInfo.InvariantCulture).Ticks, trackEvent.EndPositionTicks);
-                Assert.Equal("Like an Angel with pity on nobody\r\nThe second line in subtitle", trackEvent.Text);
+                Assert.Equal("{\\pos(400,570)}Like an Angel with pity on nobody" + Environment.NewLine + "The second line in subtitle", trackEvent.Text);
             }
         }
-
-        [Fact]
-        public void ParseFieldHeaders_Valid_Success()
-        {
-            const string Line = "Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text";
-            var headers = AssParser.ParseFieldHeaders(Line);
-            Assert.Equal(1, headers["Start"]);
-            Assert.Equal(2, headers["End"]);
-            Assert.Equal(9, headers["Text"]);
-        }
     }
 }
diff --git a/tests/Jellyfin.MediaEncoding.Tests/Subtitles/SrtParserTests.cs b/tests/Jellyfin.MediaEncoding.Tests/Subtitles/SrtParserTests.cs
index 3e2d2de10..c07c9ea7d 100644
--- a/tests/Jellyfin.MediaEncoding.Tests/Subtitles/SrtParserTests.cs
+++ b/tests/Jellyfin.MediaEncoding.Tests/Subtitles/SrtParserTests.cs
@@ -22,7 +22,7 @@ namespace Jellyfin.MediaEncoding.Subtitles.Tests
                 Assert.Equal("1", trackEvent1.Id);
                 Assert.Equal(TimeSpan.Parse("00:02:17.440", CultureInfo.InvariantCulture).Ticks, trackEvent1.StartPositionTicks);
                 Assert.Equal(TimeSpan.Parse("00:02:20.375", CultureInfo.InvariantCulture).Ticks, trackEvent1.EndPositionTicks);
-                Assert.Equal("Senator, we're making\r\nour final approach into Coruscant.", trackEvent1.Text);
+                Assert.Equal("Senator, we're making" + Environment.NewLine + "our final approach into Coruscant.", trackEvent1.Text);
 
                 var trackEvent2 = parsed.TrackEvents[1];
                 Assert.Equal("2", trackEvent2.Id);
@@ -31,5 +31,27 @@ namespace Jellyfin.MediaEncoding.Subtitles.Tests
                 Assert.Equal("Very good, Lieutenant.", trackEvent2.Text);
             }
         }
+
+        [Fact]
+        public void Parse_EmptyNewlineBetweenText_Success()
+        {
+            using (var stream = File.OpenRead("Test Data/example2.srt"))
+            {
+                var parsed = new SrtParser(new NullLogger<SrtParser>()).Parse(stream, CancellationToken.None);
+                Assert.Equal(2, parsed.TrackEvents.Count);
+
+                var trackEvent1 = parsed.TrackEvents[0];
+                Assert.Equal("311", trackEvent1.Id);
+                Assert.Equal(TimeSpan.Parse("00:16:46.465", CultureInfo.InvariantCulture).Ticks, trackEvent1.StartPositionTicks);
+                Assert.Equal(TimeSpan.Parse("00:16:49.009", CultureInfo.InvariantCulture).Ticks, trackEvent1.EndPositionTicks);
+                Assert.Equal("Una vez que la gente se entere" + Environment.NewLine + Environment.NewLine + "de que ustedes están aquí,", trackEvent1.Text);
+
+                var trackEvent2 = parsed.TrackEvents[1];
+                Assert.Equal("312", trackEvent2.Id);
+                Assert.Equal(TimeSpan.Parse("00:16:49.092", CultureInfo.InvariantCulture).Ticks, trackEvent2.StartPositionTicks);
+                Assert.Equal(TimeSpan.Parse("00:16:51.470", CultureInfo.InvariantCulture).Ticks, trackEvent2.EndPositionTicks);
+                Assert.Equal("este lugar se convertirá" + Environment.NewLine + Environment.NewLine + "en un maldito zoológico.", trackEvent2.Text);
+            }
+        }
     }
 }
diff --git a/tests/Jellyfin.MediaEncoding.Tests/Subtitles/SsaParserTests.cs b/tests/Jellyfin.MediaEncoding.Tests/Subtitles/SsaParserTests.cs
new file mode 100644
index 000000000..56649db8f
--- /dev/null
+++ b/tests/Jellyfin.MediaEncoding.Tests/Subtitles/SsaParserTests.cs
@@ -0,0 +1,90 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Text;
+using System.Threading;
+using MediaBrowser.MediaEncoding.Subtitles;
+using MediaBrowser.Model.MediaInfo;
+using Microsoft.Extensions.Logging.Abstractions;
+using Xunit;
+
+namespace Jellyfin.MediaEncoding.Subtitles.Tests
+{
+    public class SsaParserTests
+    {
+        private readonly SsaParser _parser = new SsaParser(new NullLogger<AssParser>());
+
+        [Theory]
+        [MemberData(nameof(Parse_MultipleDialogues_TestData))]
+        public void Parse_MultipleDialogues_Success(string ssa, IReadOnlyList<SubtitleTrackEvent> expectedSubtitleTrackEvents)
+        {
+            using (Stream stream = new MemoryStream(Encoding.UTF8.GetBytes(ssa)))
+            {
+                SubtitleTrackInfo subtitleTrackInfo = _parser.Parse(stream, CancellationToken.None);
+
+                Assert.Equal(expectedSubtitleTrackEvents.Count, subtitleTrackInfo.TrackEvents.Count);
+
+                for (int i = 0; i < expectedSubtitleTrackEvents.Count; ++i)
+                {
+                    SubtitleTrackEvent expected = expectedSubtitleTrackEvents[i];
+                    SubtitleTrackEvent actual = subtitleTrackInfo.TrackEvents[i];
+
+                    Assert.Equal(expected.Id, actual.Id);
+                    Assert.Equal(expected.Text, actual.Text);
+                    Assert.Equal(expected.StartPositionTicks, actual.StartPositionTicks);
+                    Assert.Equal(expected.EndPositionTicks, actual.EndPositionTicks);
+                }
+            }
+        }
+
+        public static TheoryData<string, IReadOnlyList<SubtitleTrackEvent>> Parse_MultipleDialogues_TestData()
+        {
+            var data = new TheoryData<string, IReadOnlyList<SubtitleTrackEvent>>();
+
+            data.Add(
+                @"[Events]
+                Format: Layer, Start, End, Text
+                Dialogue: ,0:00:01.18,0:00:01.85,dialogue1
+                Dialogue: ,0:00:02.18,0:00:02.85,dialogue2
+                Dialogue: ,0:00:03.18,0:00:03.85,dialogue3
+                ",
+                new List<SubtitleTrackEvent>
+                {
+                    new SubtitleTrackEvent("1", "dialogue1")
+                    {
+                        StartPositionTicks = 11800000,
+                        EndPositionTicks = 18500000
+                    },
+                    new SubtitleTrackEvent("2", "dialogue2")
+                    {
+                        StartPositionTicks = 21800000,
+                        EndPositionTicks = 28500000
+                    },
+                    new SubtitleTrackEvent("3", "dialogue3")
+                    {
+                        StartPositionTicks = 31800000,
+                        EndPositionTicks = 38500000
+                    }
+                });
+
+            return data;
+        }
+
+        [Fact]
+        public void Parse_Valid_Success()
+        {
+            using (var stream = File.OpenRead("Test Data/example.ssa"))
+            {
+                var parsed = _parser.Parse(stream, CancellationToken.None);
+                Assert.Single(parsed.TrackEvents);
+                var trackEvent = parsed.TrackEvents[0];
+
+                Assert.Equal("1", trackEvent.Id);
+                Assert.Equal(TimeSpan.Parse("00:00:01.18", CultureInfo.InvariantCulture).Ticks, trackEvent.StartPositionTicks);
+                Assert.Equal(TimeSpan.Parse("00:00:06.85", CultureInfo.InvariantCulture).Ticks, trackEvent.EndPositionTicks);
+                Assert.Equal("{\\pos(400,570)}Like an angel with pity on nobody", trackEvent.Text);
+            }
+        }
+    }
+}
diff --git a/tests/Jellyfin.MediaEncoding.Tests/Subtitles/SubtitleEncoderTests.cs b/tests/Jellyfin.MediaEncoding.Tests/Subtitles/SubtitleEncoderTests.cs
new file mode 100644
index 000000000..639c364df
--- /dev/null
+++ b/tests/Jellyfin.MediaEncoding.Tests/Subtitles/SubtitleEncoderTests.cs
@@ -0,0 +1,83 @@
+using System.Threading;
+using System.Threading.Tasks;
+using AutoFixture;
+using AutoFixture.AutoMoq;
+using MediaBrowser.MediaEncoding.Subtitles;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.MediaInfo;
+using Xunit;
+
+namespace Jellyfin.MediaEncoding.Subtitles.Tests
+{
+    public class SubtitleEncoderTests
+    {
+        internal static TheoryData<MediaSourceInfo, MediaStream, SubtitleEncoder.SubtitleInfo> GetReadableFile_Valid_TestData()
+        {
+            var data = new TheoryData<MediaSourceInfo, MediaStream, SubtitleEncoder.SubtitleInfo>();
+
+            data.Add(
+                new MediaSourceInfo()
+                {
+                    Protocol = MediaProtocol.File
+                },
+                new MediaStream()
+                {
+                    Path = "/media/sub.ass",
+                    IsExternal = true
+                },
+                new SubtitleEncoder.SubtitleInfo("/media/sub.ass", MediaProtocol.File, "ass", true));
+
+            data.Add(
+                new MediaSourceInfo()
+                {
+                    Protocol = MediaProtocol.File
+                },
+                new MediaStream()
+                {
+                    Path = "/media/sub.ssa",
+                    IsExternal = true
+                },
+                new SubtitleEncoder.SubtitleInfo("/media/sub.ssa", MediaProtocol.File, "ssa", true));
+
+            data.Add(
+                new MediaSourceInfo()
+                {
+                    Protocol = MediaProtocol.File
+                },
+                new MediaStream()
+                {
+                    Path = "/media/sub.srt",
+                    IsExternal = true
+                },
+                new SubtitleEncoder.SubtitleInfo("/media/sub.srt", MediaProtocol.File, "srt", true));
+
+            data.Add(
+                new MediaSourceInfo()
+                {
+                    Protocol = MediaProtocol.Http
+                },
+                new MediaStream()
+                {
+                    Path = "/media/sub.ass",
+                    IsExternal = true
+                },
+                new SubtitleEncoder.SubtitleInfo("/media/sub.ass", MediaProtocol.File, "ass", true));
+
+            return data;
+        }
+
+        [Theory]
+        [MemberData(nameof(GetReadableFile_Valid_TestData))]
+        internal async Task GetReadableFile_Valid_Success(MediaSourceInfo mediaSource, MediaStream subtitleStream, SubtitleEncoder.SubtitleInfo subtitleInfo)
+        {
+            var fixture = new Fixture().Customize(new AutoMoqCustomization { ConfigureMembers = true });
+            var subtitleEncoder = fixture.Create<SubtitleEncoder>();
+            var result = await subtitleEncoder.GetReadableFile(mediaSource, subtitleStream, CancellationToken.None).ConfigureAwait(false);
+            Assert.Equal(subtitleInfo.Path, result.Path);
+            Assert.Equal(subtitleInfo.Protocol, result.Protocol);
+            Assert.Equal(subtitleInfo.Format, result.Format);
+            Assert.Equal(subtitleInfo.IsExternal, result.IsExternal);
+        }
+    }
+}
diff --git a/tests/Jellyfin.MediaEncoding.Tests/Test Data/Probing/music_metadata.json b/tests/Jellyfin.MediaEncoding.Tests/Test Data/Probing/music_metadata.json
new file mode 100644
index 000000000..6530629fe
--- /dev/null
+++ b/tests/Jellyfin.MediaEncoding.Tests/Test Data/Probing/music_metadata.json
@@ -0,0 +1,144 @@
+{
+    "streams": [
+        {
+            "index": 0,
+            "codec_name": "flac",
+            "codec_long_name": "FLAC (Free Lossless Audio Codec)",
+            "codec_type": "audio",
+            "codec_tag_string": "[0][0][0][0]",
+            "codec_tag": "0x0000",
+            "sample_fmt": "s16",
+            "sample_rate": "44100",
+            "channels": 2,
+            "channel_layout": "stereo",
+            "bits_per_sample": 0,
+            "r_frame_rate": "0/0",
+            "avg_frame_rate": "0/0",
+            "time_base": "1/44100",
+            "start_pts": 0,
+            "start_time": "0.000000",
+            "duration_ts": 9447984,
+            "duration": "214.240000",
+            "bits_per_raw_sample": "16",
+            "disposition": {
+                "default": 0,
+                "dub": 0,
+                "original": 0,
+                "comment": 0,
+                "lyrics": 0,
+                "karaoke": 0,
+                "forced": 0,
+                "hearing_impaired": 0,
+                "visual_impaired": 0,
+                "clean_effects": 0,
+                "attached_pic": 0,
+                "timed_thumbnails": 0
+            }
+        },
+        {
+            "index": 1,
+            "codec_name": "mjpeg",
+            "codec_long_name": "Motion JPEG",
+            "profile": "Baseline",
+            "codec_type": "video",
+            "codec_tag_string": "[0][0][0][0]",
+            "codec_tag": "0x0000",
+            "width": 500,
+            "height": 500,
+            "coded_width": 500,
+            "coded_height": 500,
+            "closed_captions": 0,
+            "has_b_frames": 0,
+            "sample_aspect_ratio": "1:1",
+            "display_aspect_ratio": "1:1",
+            "pix_fmt": "yuvj420p",
+            "level": -99,
+            "color_range": "pc",
+            "color_space": "bt470bg",
+            "chroma_location": "center",
+            "refs": 1,
+            "r_frame_rate": "90000/1",
+            "avg_frame_rate": "0/0",
+            "time_base": "1/90000",
+            "start_pts": 0,
+            "start_time": "0.000000",
+            "duration_ts": 19281600,
+            "duration": "214.240000",
+            "bits_per_raw_sample": "8",
+            "disposition": {
+                "default": 0,
+                "dub": 0,
+                "original": 0,
+                "comment": 0,
+                "lyrics": 0,
+                "karaoke": 0,
+                "forced": 0,
+                "hearing_impaired": 0,
+                "visual_impaired": 0,
+                "clean_effects": 0,
+                "attached_pic": 1,
+                "timed_thumbnails": 0
+            },
+            "tags": {
+                "comment": "Cover (front)"
+            }
+        }
+    ],
+    "format": {
+        "filename": "03 UP NO MORE.flac",
+        "nb_streams": 2,
+        "nb_programs": 0,
+        "format_name": "flac",
+        "format_long_name": "raw FLAC",
+        "start_time": "0.000000",
+        "duration": "214.240000",
+        "size": "28714641",
+        "bit_rate": "1072242",
+        "probe_score": 100,
+        "tags": {
+            "MUSICBRAINZ_RELEASEGROUPID": "aa05ff10-8589-4c9c-a0d4-6b024f4e4556",
+            "ORIGINALDATE": "2020-10-26",
+            "ORIGINALYEAR": "2020",
+            "RELEASETYPE": "album",
+            "MUSICBRAINZ_ALBUMID": "222e6610-75c9-400e-8dc3-bb61f9fc5ca7",
+            "SCRIPT": "Latn",
+            "ALBUM": "Eyes wide open",
+            "RELEASECOUNTRY": "JP",
+            "BARCODE": "190295105280",
+            "LABEL": "JYP Entertainment",
+            "RELEASESTATUS": "official",
+            "DATE": "2020-10-26",
+            "MUSICBRAINZ_ALBUMARTISTID": "8da127cc-c432-418f-b356-ef36210d82ac",
+            "album_artist": "TWICE",
+            "ALBUMARTISTSORT": "TWICE",
+            "TOTALDISCS": "1",
+            "TOTALTRACKS": "13",
+            "MEDIA": "Digital Media",
+            "disc": "1",
+            "MUSICBRAINZ_TRACKID": "7d1a1044-b564-480d-9df3-22f9656fdb97",
+            "TITLE": "UP NO MORE",
+            "ISRC": "US5TA2000136",
+            "PERFORMER": "Yiwoomin (electric piano);Yiwoomin (synthesizer);Yiwoomin (bass);Yiwoomin (guitar);TWICE;Tzu-yu Chou (vocals);Momo Hirai (vocals);Na-yeon Im (vocals);Da-hyun Kim (vocals);Sana Minatozaki (vocals);Mina Myoui (vocals);Ji-hyo Park (vocals);Chae-young Son (vocals);Jeong-yeon Yoo (vocals);Perrie (background vocals)",
+            "MIXER": "Bong Won Shin",
+            "ARRANGER": "Krysta Youngs;Julia Ross;Yiwoomin",
+            "MUSICBRAINZ_WORKID": "02b37083-0337-4721-9f17-bf31971043e8",
+            "LANGUAGE": "kor;eng",
+            "WORK": "Up No More",
+            "COMPOSER": "Krysta Youngs;Julia Ross;Yiwoomin",
+            "COMPOSERSORT": "Krysta Youngs;Ross, Julia;Yiwoomin",
+            "LYRICIST": "Ji-hyo Park",
+            "MUSICBRAINZ_ARTISTID": "8da127cc-c432-418f-b356-ef36210d82ac",
+            "ARTIST": "TWICE",
+            "ARTISTSORT": "TWICE",
+            "ARTISTS": "TWICE",
+            "MUSICBRAINZ_RELEASETRACKID": "ad49b840-da9e-4e7c-924b-29fdee187052",
+            "track": "3",
+            "GENRE": "Electronic;Trance;Dance;Jazz",
+            "WEBSITE": "http://twice.jype.com/;http://www.twicejapan.com/",
+            "ACOUSTID_ID": "aae2e972-108c-4d0c-8e31-9d078283e3dc",
+            "MOOD": "Not acoustic;Not aggressive;Electronic;Happy;Party;Not relaxed;Not sad",
+            "TRACKTOTAL": "13",
+            "DISCTOTAL": "1"
+        }
+    }
+}
diff --git a/tests/Jellyfin.MediaEncoding.Tests/Test Data/Probing/music_video_metadata.json b/tests/Jellyfin.MediaEncoding.Tests/Test Data/Probing/music_video_metadata.json
new file mode 100644
index 000000000..97d6600a4
--- /dev/null
+++ b/tests/Jellyfin.MediaEncoding.Tests/Test Data/Probing/music_video_metadata.json
@@ -0,0 +1,111 @@
+{
+    "streams": [
+        {
+            "index": 0,
+            "codec_name": "h264",
+            "codec_long_name": "H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10",
+            "profile": "High",
+            "codec_type": "video",
+            "codec_time_base": "1001/48000",
+            "codec_tag_string": "[0][0][0][0]",
+            "codec_tag": "0x0000",
+            "width": 1920,
+            "height": 1080,
+            "coded_width": 1920,
+            "coded_height": 1088,
+            "closed_captions": 0,
+            "has_b_frames": 0,
+            "sample_aspect_ratio": "1:1",
+            "display_aspect_ratio": "16:9",
+            "pix_fmt": "yuv420p",
+            "level": 42,
+            "chroma_location": "left",
+            "field_order": "progressive",
+            "refs": 1,
+            "is_avc": "true",
+            "nal_length_size": "4",
+            "r_frame_rate": "24000/1001",
+            "avg_frame_rate": "24000/1001",
+            "time_base": "1/1000",
+            "start_pts": 0,
+            "start_time": "0.000000",
+            "bits_per_raw_sample": "8",
+            "disposition": {
+                "default": 1,
+                "dub": 0,
+                "original": 0,
+                "comment": 0,
+                "lyrics": 0,
+                "karaoke": 0,
+                "forced": 0,
+                "hearing_impaired": 0,
+                "visual_impaired": 0,
+                "clean_effects": 0,
+                "attached_pic": 0,
+                "timed_thumbnails": 0
+            },
+            "tags": {
+                "language": "eng"
+            }
+        },
+        {
+            "index": 1,
+            "codec_name": "aac",
+            "codec_long_name": "AAC (Advanced Audio Coding)",
+            "profile": "LC",
+            "codec_type": "audio",
+            "codec_time_base": "1/48000",
+            "codec_tag_string": "[0][0][0][0]",
+            "codec_tag": "0x0000",
+            "sample_fmt": "fltp",
+            "sample_rate": "48000",
+            "channels": 2,
+            "channel_layout": "stereo",
+            "bits_per_sample": 0,
+            "r_frame_rate": "0/0",
+            "avg_frame_rate": "0/0",
+            "time_base": "1/1000",
+            "start_pts": 0,
+            "start_time": "0.000000",
+            "disposition": {
+                "default": 1,
+                "dub": 0,
+                "original": 0,
+                "comment": 0,
+                "lyrics": 0,
+                "karaoke": 0,
+                "forced": 0,
+                "hearing_impaired": 0,
+                "visual_impaired": 0,
+                "clean_effects": 0,
+                "attached_pic": 0,
+                "timed_thumbnails": 0
+            },
+            "tags": {
+                "language": "eng"
+            }
+        }
+    ],
+    "chapters": [
+    ],
+    "format": {
+        "filename": "music_video.mkv",
+        "nb_streams": 2,
+        "nb_programs": 0,
+        "format_name": "matroska,webm",
+        "format_long_name": "Matroska / WebM",
+        "start_time": "0.000000",
+        "duration": "180.000000",
+        "size": "500000000",
+        "bit_rate": "22222222",
+        "probe_score": 100,
+        "tags": {
+            "TITLE-eng": "The Title",
+            "TITLESORT": "Title, The",
+            "ARTIST": "The Artist",
+            "ARTISTSORT": "Artist, The",
+            "ALBUM": "Album",
+            "DATE_RELEASED": "2021-01-01"
+        }
+    }
+}
diff --git a/tests/Jellyfin.MediaEncoding.Tests/Test Data/Probing/music_year_only_metadata.json b/tests/Jellyfin.MediaEncoding.Tests/Test Data/Probing/music_year_only_metadata.json
new file mode 100644
index 000000000..ddf890c45
--- /dev/null
+++ b/tests/Jellyfin.MediaEncoding.Tests/Test Data/Probing/music_year_only_metadata.json
@@ -0,0 +1,147 @@
+{
+    "streams": [
+        {
+            "index": 0,
+            "codec_name": "flac",
+            "codec_long_name": "FLAC (Free Lossless Audio Codec)",
+            "codec_type": "audio",
+            "codec_tag_string": "[0][0][0][0]",
+            "codec_tag": "0x0000",
+            "sample_fmt": "s16",
+            "sample_rate": "44100",
+            "channels": 2,
+            "channel_layout": "stereo",
+            "bits_per_sample": 0,
+            "r_frame_rate": "0/0",
+            "avg_frame_rate": "0/0",
+            "time_base": "1/44100",
+            "start_pts": 0,
+            "start_time": "0.000000",
+            "duration_ts": 16394616,
+            "duration": "371.760000",
+            "bits_per_raw_sample": "16",
+            "disposition": {
+                "default": 0,
+                "dub": 0,
+                "original": 0,
+                "comment": 0,
+                "lyrics": 0,
+                "karaoke": 0,
+                "forced": 0,
+                "hearing_impaired": 0,
+                "visual_impaired": 0,
+                "clean_effects": 0,
+                "attached_pic": 0,
+                "timed_thumbnails": 0
+            }
+        },
+        {
+            "index": 1,
+            "codec_name": "mjpeg",
+            "codec_long_name": "Motion JPEG",
+            "profile": "Baseline",
+            "codec_type": "video",
+            "codec_tag_string": "[0][0][0][0]",
+            "codec_tag": "0x0000",
+            "width": 500,
+            "height": 498,
+            "coded_width": 500,
+            "coded_height": 498,
+            "closed_captions": 0,
+            "has_b_frames": 0,
+            "sample_aspect_ratio": "1:1",
+            "display_aspect_ratio": "250:249",
+            "pix_fmt": "yuvj420p",
+            "level": -99,
+            "color_range": "pc",
+            "color_space": "bt470bg",
+            "chroma_location": "center",
+            "refs": 1,
+            "r_frame_rate": "90000/1",
+            "avg_frame_rate": "0/0",
+            "time_base": "1/90000",
+            "start_pts": 0,
+            "start_time": "0.000000",
+            "duration_ts": 33458400,
+            "duration": "371.760000",
+            "bits_per_raw_sample": "8",
+            "disposition": {
+                "default": 0,
+                "dub": 0,
+                "original": 0,
+                "comment": 0,
+                "lyrics": 0,
+                "karaoke": 0,
+                "forced": 0,
+                "hearing_impaired": 0,
+                "visual_impaired": 0,
+                "clean_effects": 0,
+                "attached_pic": 1,
+                "timed_thumbnails": 0
+            },
+            "tags": {
+                "comment": "Cover (front)"
+            }
+        }
+    ],
+    "format": {
+        "filename": "02 Baker Street.flac",
+        "nb_streams": 2,
+        "nb_programs": 0,
+        "format_name": "flac",
+        "format_long_name": "raw FLAC",
+        "start_time": "0.000000",
+        "duration": "371.760000",
+        "size": "37072649",
+        "bit_rate": "797775",
+        "probe_score": 100,
+        "tags": {
+            "MUSICBRAINZ_RELEASEGROUPID": "238c3fb4-5792-342b-b217-02f66298b424",
+            "ORIGINALDATE": "1978",
+            "ORIGINALYEAR": "1978",
+            "RELEASETYPE": "album",
+            "MUSICBRAINZ_ALBUMID": "30156786-e511-3106-ac95-66f0e880b24b",
+            "ASIN": "B000007O5H",
+            "MUSICBRAINZ_ALBUMARTISTID": "563201cb-721c-4cfb-acca-c1ba69e3d1fb",
+            "album_artist": "Gerry Rafferty",
+            "ALBUMARTISTSORT": "Rafferty, Gerry",
+            "LABEL": "Liberty EMI Records UK",
+            "CATALOGNUMBER": "CDP 7 46049 2",
+            "DATE": "1989-07-26",
+            "RELEASECOUNTRY": "GB",
+            "BARCODE": "077774604925",
+            "ALBUM": "City to City",
+            "SCRIPT": "Latn",
+            "RELEASESTATUS": "official",
+            "TOTALDISCS": "1",
+            "disc": "1",
+            "MEDIA": "CD",
+            "TOTALTRACKS": "10",
+            "MUSICBRAINZ_TRACKID": "9235e22e-afbd-48f7-b329-21dae6da2810",
+            "ISRC": "GBAYE1100924;GBAYE7800619",
+            "PERFORMER": "Hugh Burns (electric guitar);Nigel Jenkins (electric guitar);Tommy Eyre (keyboard and Moog);Glen LeFleur (percussion);Raphael Ravenscroft (saxophone);Henry Spinetti (drums (drum set));Gary Taylor (bass);Gerry Rafferty (lead vocals)",
+            "ARRANGER": "Graham Preskett",
+            "MIXER": "Declan O’Doherty",
+            "PRODUCER": "Hugh Murphy;Gerry Rafferty",
+            "MUSICBRAINZ_WORKID": "a9eb3c45-784c-3c32-860c-4b406f03961b",
+            "LANGUAGE": "eng",
+            "WORK": "Baker Street",
+            "COMPOSER": "Gerry Rafferty",
+            "COMPOSERSORT": "Rafferty, Gerry",
+            "LYRICIST": "Gerry Rafferty",
+            "TITLE": "Baker Street",
+            "MUSICBRAINZ_ARTISTID": "563201cb-721c-4cfb-acca-c1ba69e3d1fb",
+            "ARTIST": "Gerry Rafferty",
+            "ARTISTSORT": "Rafferty, Gerry",
+            "ARTISTS": "Gerry Rafferty",
+            "MUSICBRAINZ_RELEASETRACKID": "407cf7f7-440d-3e76-8b89-8686198868ea",
+            "track": "2",
+            "GENRE": "Electronic;Ambient;Pop;Jazz",
+            "WEBSITE": "http://www.gerryrafferty.com/",
+            "ACOUSTID_ID": "68f8d979-a659-4aa0-a216-eb3721a951eb",
+            "MOOD": "Acoustic;Not aggressive;Not electronic;Not happy;Party;Relaxed;Not sad",
+            "TRACKTOTAL": "10",
+            "DISCTOTAL": "1"
+        }
+    }
+}
diff --git a/tests/Jellyfin.MediaEncoding.Tests/Test Data/Probing/video_metadata.json b/tests/Jellyfin.MediaEncoding.Tests/Test Data/Probing/video_metadata.json
new file mode 100644
index 000000000..720fc5c8f
--- /dev/null
+++ b/tests/Jellyfin.MediaEncoding.Tests/Test Data/Probing/video_metadata.json
@@ -0,0 +1,74 @@
+{
+    "streams": [
+        {
+            "index": 0,
+            "codec_name": "h264",
+            "codec_long_name": "H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10",
+            "profile": "High 4:4:4 Predictive",
+            "codec_type": "video",
+            "codec_time_base": "1/50",
+            "codec_tag_string": "[0][0][0][0]",
+            "codec_tag": "0x0000",
+            "width": 320,
+            "height": 240,
+            "coded_width": 320,
+            "coded_height": 240,
+            "closed_captions": 0,
+            "has_b_frames": 2,
+            "sample_aspect_ratio": "1:1",
+            "display_aspect_ratio": "4:3",
+            "pix_fmt": "yuv444p",
+            "level": 13,
+            "chroma_location": "left",
+            "field_order": "progressive",
+            "refs": 1,
+            "is_avc": "true",
+            "nal_length_size": "4",
+            "r_frame_rate": "25/1",
+            "avg_frame_rate": "25/1",
+            "time_base": "1/1000",
+            "start_pts": 0,
+            "start_time": "0.000000",
+            "bits_per_raw_sample": "8",
+            "disposition": {
+                "default": 1,
+                "dub": 0,
+                "original": 0,
+                "comment": 0,
+                "lyrics": 0,
+                "karaoke": 0,
+                "forced": 0,
+                "hearing_impaired": 0,
+                "visual_impaired": 0,
+                "clean_effects": 0,
+                "attached_pic": 0,
+                "timed_thumbnails": 0
+            },
+            "tags": {
+                "ENCODER": "Lavc57.107.100 libx264",
+                "DURATION": "00:00:01.000000000"
+            }
+        }
+    ],
+    "chapters": [
+
+    ],
+    "format": {
+        "filename": "some_metadata.mkv",
+        "nb_streams": 1,
+        "nb_programs": 0,
+        "format_name": "matroska,webm",
+        "format_long_name": "Matroska / WebM",
+        "start_time": "0.000000",
+        "duration": "1.000000",
+        "size": "8679",
+        "bit_rate": "69432",
+        "probe_score": 100,
+        "tags": {
+            "DESCRIPTION": "Just color bars",
+            "ARCHIVAL": "yes",
+            "PRESERVE_THIS": "okay",
+            "ENCODER": "Lavf57.83.100"
+        }
+    }
+}
diff --git a/tests/Jellyfin.MediaEncoding.Tests/Test Data/Probing/video_mp4_metadata.json b/tests/Jellyfin.MediaEncoding.Tests/Test Data/Probing/video_mp4_metadata.json
new file mode 100644
index 000000000..77e3def76
--- /dev/null
+++ b/tests/Jellyfin.MediaEncoding.Tests/Test Data/Probing/video_mp4_metadata.json
@@ -0,0 +1,260 @@
+{
+    "streams": [
+        {
+            "index": 0,
+            "codec_name": "h264",
+            "codec_long_name": "H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10",
+            "profile": "High",
+            "codec_type": "video",
+            "codec_tag_string": "avc1",
+            "codec_tag": "0x31637661",
+            "width": 720,
+            "height": 358,
+            "coded_width": 720,
+            "coded_height": 358,
+            "closed_captions": 0,
+            "has_b_frames": 2,
+            "sample_aspect_ratio": "32:27",
+            "display_aspect_ratio": "1280:537",
+            "pix_fmt": "yuv420p",
+            "level": 31,
+            "color_range": "tv",
+            "color_space": "smpte170m",
+            "color_transfer": "bt709",
+            "color_primaries": "smpte170m",
+            "chroma_location": "left",
+            "refs": 1,
+            "is_avc": "true",
+            "nal_length_size": "4",
+            "r_frame_rate": "120/1",
+            "avg_frame_rate": "1704753000/71073479",
+            "time_base": "1/90000",
+            "start_pts": 0,
+            "start_time": "0.000000",
+            "duration_ts": 1421469580,
+            "duration": "15794.106444",
+            "bit_rate": "1147365",
+            "bits_per_raw_sample": "8",
+            "nb_frames": "378834",
+            "disposition": {
+                "default": 1,
+                "dub": 0,
+                "original": 0,
+                "comment": 0,
+                "lyrics": 0,
+                "karaoke": 0,
+                "forced": 0,
+                "hearing_impaired": 0,
+                "visual_impaired": 0,
+                "clean_effects": 0,
+                "attached_pic": 0,
+                "timed_thumbnails": 0
+            },
+            "tags": {
+                "creation_time": "2021-09-13T22:42:42.000000Z",
+                "language": "und",
+                "handler_name": "VideoHandler",
+                "vendor_id": "[0][0][0][0]"
+            }
+        },
+        {
+            "index": 1,
+            "codec_name": "aac",
+            "codec_long_name": "AAC (Advanced Audio Coding)",
+            "profile": "LC",
+            "codec_type": "audio",
+            "codec_tag_string": "mp4a",
+            "codec_tag": "0x6134706d",
+            "sample_fmt": "fltp",
+            "sample_rate": "48000",
+            "channels": 7,
+            "bits_per_sample": 0,
+            "r_frame_rate": "0/0",
+            "avg_frame_rate": "0/0",
+            "time_base": "1/48000",
+            "start_pts": 0,
+            "start_time": "0.000000",
+            "duration_ts": 758115312,
+            "duration": "15794.069000",
+            "bit_rate": "224197",
+            "nb_frames": "740348",
+            "disposition": {
+                "default": 1,
+                "dub": 0,
+                "original": 0,
+                "comment": 0,
+                "lyrics": 0,
+                "karaoke": 0,
+                "forced": 0,
+                "hearing_impaired": 0,
+                "visual_impaired": 0,
+                "clean_effects": 0,
+                "attached_pic": 0,
+                "timed_thumbnails": 0
+            },
+            "tags": {
+                "creation_time": "2021-09-13T22:42:42.000000Z",
+                "language": "eng",
+                "handler_name": "Surround 6.1",
+                "vendor_id": "[0][0][0][0]"
+            }
+        },
+        {
+            "index": 2,
+            "codec_name": "aac",
+            "codec_long_name": "AAC (Advanced Audio Coding)",
+            "profile": "LC",
+            "codec_type": "audio",
+            "codec_tag_string": "mp4a",
+            "codec_tag": "0x6134706d",
+            "sample_fmt": "fltp",
+            "sample_rate": "48000",
+            "channels": 2,
+            "channel_layout": "stereo",
+            "bits_per_sample": 0,
+            "r_frame_rate": "0/0",
+            "avg_frame_rate": "0/0",
+            "time_base": "1/48000",
+            "start_pts": 0,
+            "start_time": "0.000000",
+            "duration_ts": 758114304,
+            "duration": "15794.048000",
+            "bit_rate": "160519",
+            "nb_frames": "740347",
+            "disposition": {
+                "default": 0,
+                "dub": 0,
+                "original": 0,
+                "comment": 0,
+                "lyrics": 0,
+                "karaoke": 0,
+                "forced": 0,
+                "hearing_impaired": 0,
+                "visual_impaired": 0,
+                "clean_effects": 0,
+                "attached_pic": 0,
+                "timed_thumbnails": 0
+            },
+            "tags": {
+                "creation_time": "2021-09-13T22:42:42.000000Z",
+                "language": "eng",
+                "handler_name": "Commentary",
+                "vendor_id": "[0][0][0][0]"
+            }
+        },
+        {
+            "index": 3,
+            "codec_name": "dvd_subtitle",
+            "codec_long_name": "DVD subtitles",
+            "codec_type": "subtitle",
+            "codec_tag_string": "mp4s",
+            "codec_tag": "0x7334706d",
+            "width": 720,
+            "height": 480,
+            "r_frame_rate": "0/0",
+            "avg_frame_rate": "0/0",
+            "time_base": "1/90000",
+            "start_pts": 0,
+            "start_time": "0.000000",
+            "duration_ts": 1300301588,
+            "duration": "14447.795422",
+            "bit_rate": "2653",
+            "nb_frames": "3545",
+            "disposition": {
+                "default": 0,
+                "dub": 0,
+                "original": 0,
+                "comment": 0,
+                "lyrics": 0,
+                "karaoke": 0,
+                "forced": 0,
+                "hearing_impaired": 0,
+                "visual_impaired": 0,
+                "clean_effects": 0,
+                "attached_pic": 0,
+                "timed_thumbnails": 0
+            },
+            "tags": {
+                "creation_time": "2021-09-13T22:42:42.000000Z",
+                "language": "spa",
+                "handler_name": "SubtitleHandler"
+            }
+        },
+        {
+            "index": 4,
+            "codec_name": "mov_text",
+            "codec_long_name": "MOV text",
+            "codec_type": "subtitle",
+            "codec_tag_string": "tx3g",
+            "codec_tag": "0x67337874",
+            "width": 853,
+            "height": 51,
+            "r_frame_rate": "0/0",
+            "avg_frame_rate": "0/0",
+            "time_base": "1/90000",
+            "start_pts": 0,
+            "start_time": "0.000000",
+            "duration_ts": 1401339330,
+            "duration": "15570.437000",
+            "bit_rate": "88",
+            "nb_frames": "5079",
+            "disposition": {
+                "default": 1,
+                "dub": 0,
+                "original": 0,
+                "comment": 0,
+                "lyrics": 0,
+                "karaoke": 0,
+                "forced": 0,
+                "hearing_impaired": 0,
+                "visual_impaired": 0,
+                "clean_effects": 0,
+                "attached_pic": 0,
+                "timed_thumbnails": 0
+            },
+            "tags": {
+                "creation_time": "2021-09-13T22:42:42.000000Z",
+                "language": "eng",
+                "handler_name": "SubtitleHandler"
+            }
+        },
+        {
+            "index": 5,
+            "codec_name": "mov_text",
+            "codec_long_name": "MOV text",
+            "codec_type": "subtitle",
+            "codec_tag_string": "tx3g",
+            "codec_tag": "0x67337874",
+            "width": 853,
+            "height": 51,
+            "r_frame_rate": "0/0",
+            "avg_frame_rate": "0/0",
+            "time_base": "1/90000",
+            "start_pts": 0,
+            "start_time": "0.000000",
+            "duration_ts": 1370580300,
+            "duration": "15228.670000",
+            "bit_rate": "18",
+            "nb_frames": "1563",
+            "disposition": {
+                "default": 0,
+                "dub": 0,
+                "original": 0,
+                "comment": 0,
+                "lyrics": 0,
+                "karaoke": 0,
+                "forced": 0,
+                "hearing_impaired": 0,
+                "visual_impaired": 0,
+                "clean_effects": 0,
+                "attached_pic": 0,
+                "timed_thumbnails": 0
+            },
+            "tags": {
+                "creation_time": "2021-09-13T22:42:42.000000Z",
+                "language": "eng",
+                "handler_name": "Commentary"
+            }
+        }
+    ]
+}
diff --git a/tests/Jellyfin.MediaEncoding.Tests/Test Data/example.ssa b/tests/Jellyfin.MediaEncoding.Tests/Test Data/example.ssa
new file mode 100644
index 000000000..dcbb972eb
--- /dev/null
+++ b/tests/Jellyfin.MediaEncoding.Tests/Test Data/example.ssa
@@ -0,0 +1,20 @@
+[Script Info]
+; This is a Sub Station Alpha v4 script.
+; For Sub Station Alpha info and downloads,
+; go to http://www.eswat.demon.co.uk/
+Title: Neon Genesis Evangelion - Episode 26 (neutral Spanish)
+Original Script: RoRo
+Script Updated By: version 2.8.01
+ScriptType: v4.00
+Collisions: Normal
+PlayResY: 600
+PlayDepth: 0
+Timer: 100,0000
+
+[V4 Styles]
+Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, TertiaryColour, BackColour, Bold, Italic, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, AlphaLevel, Encoding
+Style: DefaultVCD, Arial,28,11861244,11861244,11861244,-2147483640,-1,0,1,1,2,2,30,30,30,0,0
+
+[Events]
+Format: Marked, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+Dialogue: Marked=0,0:00:01.18,0:00:06.85,DefaultVCD, NTP,0000,0000,0000,,{\pos(400,570)}Like an angel with pity on nobody
diff --git a/tests/Jellyfin.MediaEncoding.Tests/Test Data/example2.srt b/tests/Jellyfin.MediaEncoding.Tests/Test Data/example2.srt
new file mode 100644
index 000000000..b14aa8ea3
--- /dev/null
+++ b/tests/Jellyfin.MediaEncoding.Tests/Test Data/example2.srt
@@ -0,0 +1,11 @@
+311
+00:16:46,465 --> 00:16:49,009
+Una vez que la gente se entere
+
+de que ustedes están aquí,
+
+312
+00:16:49,092 --> 00:16:51,470
+este lugar se convertirá
+
+en un maldito zoológico.
diff --git a/tests/Jellyfin.Model.Tests/Cryptography/PasswordHashTests.cs b/tests/Jellyfin.Model.Tests/Cryptography/PasswordHashTests.cs
new file mode 100644
index 000000000..6948280a3
--- /dev/null
+++ b/tests/Jellyfin.Model.Tests/Cryptography/PasswordHashTests.cs
@@ -0,0 +1,169 @@
+using System;
+using System.Collections.Generic;
+using MediaBrowser.Model.Cryptography;
+using Xunit;
+
+namespace Jellyfin.Model.Tests.Cryptography
+{
+    public static class PasswordHashTests
+    {
+        [Fact]
+        public static void Ctor_Null_ThrowsArgumentNullException()
+        {
+            Assert.Throws<ArgumentNullException>(() => new PasswordHash(null!, Array.Empty<byte>()));
+        }
+
+        [Fact]
+        public static void Ctor_Empty_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new PasswordHash(string.Empty, Array.Empty<byte>()));
+        }
+
+        public static TheoryData<string, PasswordHash> Parse_Valid_TestData()
+        {
+            var data = new TheoryData<string, PasswordHash>();
+            // Id
+            data.Add(
+                "$PBKDF2",
+                new PasswordHash("PBKDF2", Array.Empty<byte>()));
+
+            // Id + parameter
+            data.Add(
+                "$PBKDF2$iterations=1000",
+                new PasswordHash(
+                    "PBKDF2",
+                    Array.Empty<byte>(),
+                    Array.Empty<byte>(),
+                    new Dictionary<string, string>()
+                    {
+                        { "iterations", "1000" },
+                    }));
+
+            // Id + parameters
+            data.Add(
+                "$PBKDF2$iterations=1000,m=120",
+                new PasswordHash(
+                    "PBKDF2",
+                    Array.Empty<byte>(),
+                    Array.Empty<byte>(),
+                    new Dictionary<string, string>()
+                    {
+                        { "iterations", "1000" },
+                        { "m", "120" }
+                    }));
+
+            // Id + hash
+            data.Add(
+                "$PBKDF2$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D",
+                new PasswordHash(
+                    "PBKDF2",
+                    Convert.FromHexString("62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D"),
+                    Array.Empty<byte>(),
+                    new Dictionary<string, string>()));
+
+            // Id + salt + hash
+            data.Add(
+                "$PBKDF2$69F420$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D",
+                new PasswordHash(
+                    "PBKDF2",
+                    Convert.FromHexString("62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D"),
+                    Convert.FromHexString("69F420"),
+                    new Dictionary<string, string>()));
+
+            // Id + parameter + hash
+            data.Add(
+                "$PBKDF2$iterations=1000$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D",
+                new PasswordHash(
+                    "PBKDF2",
+                    Convert.FromHexString("62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D"),
+                    Array.Empty<byte>(),
+                    new Dictionary<string, string>()
+                    {
+                        { "iterations", "1000" }
+                    }));
+            // Id + parameters + hash
+            data.Add(
+                "$PBKDF2$iterations=1000,m=120$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D",
+                new PasswordHash(
+                    "PBKDF2",
+                    Convert.FromHexString("62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D"),
+                    Array.Empty<byte>(),
+                    new Dictionary<string, string>()
+                    {
+                        { "iterations", "1000" },
+                        { "m", "120" }
+                    }));
+            // Id + parameters + salt + hash
+            data.Add(
+                "$PBKDF2$iterations=1000,m=120$69F420$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D",
+                new PasswordHash(
+                    "PBKDF2",
+                    Convert.FromHexString("62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D"),
+                    Convert.FromHexString("69F420"),
+                    new Dictionary<string, string>()
+                    {
+                        { "iterations", "1000" },
+                        { "m", "120" }
+                    }));
+            return data;
+        }
+
+        [Theory]
+        [MemberData(nameof(Parse_Valid_TestData))]
+        public static void Parse_Valid_Success(string passwordHashString, PasswordHash expected)
+        {
+            var passwordHash = PasswordHash.Parse(passwordHashString);
+            Assert.Equal(expected.Id, passwordHash.Id);
+            Assert.Equal(expected.Parameters, passwordHash.Parameters);
+            Assert.Equal(expected.Salt.ToArray(), passwordHash.Salt.ToArray());
+            Assert.Equal(expected.Hash.ToArray(), passwordHash.Hash.ToArray());
+            Assert.Equal(expected.ToString(), passwordHash.ToString());
+        }
+
+        [Theory]
+        [InlineData("$PBKDF2")]
+        [InlineData("$PBKDF2$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D")]
+        [InlineData("$PBKDF2$69F420$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D")]
+        [InlineData("$PBKDF2$iterations=1000$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D")]
+        [InlineData("$PBKDF2$iterations=1000,m=120$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D")]
+        [InlineData("$PBKDF2$iterations=1000,m=120$69F420$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D")]
+        [InlineData("$PBKDF2$iterations=1000,m=120")]
+        public static void ToString_Roundtrip_Success(string passwordHash)
+        {
+            Assert.Equal(passwordHash, PasswordHash.Parse(passwordHash).ToString());
+        }
+
+        [Fact]
+        public static void Parse_Null_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => PasswordHash.Parse(null));
+        }
+
+        [Fact]
+        public static void Parse_Empty_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => PasswordHash.Parse(string.Empty));
+        }
+
+        [Theory]
+        [InlineData("$")] // No id
+        [InlineData("$$")] // Empty segments
+        [InlineData("PBKDF2$")] // Doesn't start with $
+        [InlineData("$PBKDF2$$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D")] // Empty segment
+        [InlineData("$PBKDF2$iterations=1000$$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D")] // Empty salt segment
+        [InlineData("$PBKDF2$iterations=1000$69F420$")] // Empty hash segment
+        [InlineData("$PBKDF2$=$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D")] // Invalid parmeter
+        [InlineData("$PBKDF2$=1000$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D")] // Invalid parmeter
+        [InlineData("$PBKDF2$iterations=$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D")] // Invalid parmeter
+        [InlineData("$PBKDF2$iterations=1000$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D$")] // Ends on $
+        [InlineData("$PBKDF2$iterations=1000$69F420$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D$")] // Extra segment
+        [InlineData("$PBKDF2$iterations=1000$69F420$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D$anotherone")] // Extra segment
+        [InlineData("$PBKDF2$iterations=1000$invalidstalt$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D")] // Invalid salt
+        [InlineData("$PBKDF2$iterations=1000$69F420$invalid hash")] // Invalid hash
+        [InlineData("$PBKDF2$69F420$")] // Empty hash
+        public static void Parse_InvalidFormat_ThrowsFormatException(string passwordHash)
+        {
+            Assert.Throws<FormatException>(() => PasswordHash.Parse(passwordHash));
+        }
+    }
+}
diff --git a/tests/Jellyfin.Model.Tests/Dlna/ContainerProfileTests.cs b/tests/Jellyfin.Model.Tests/Dlna/ContainerProfileTests.cs
new file mode 100644
index 000000000..cca056c28
--- /dev/null
+++ b/tests/Jellyfin.Model.Tests/Dlna/ContainerProfileTests.cs
@@ -0,0 +1,19 @@
+using MediaBrowser.Model.Dlna;
+using Xunit;
+
+namespace Jellyfin.Model.Tests.Dlna
+{
+    public class ContainerProfileTests
+    {
+        private readonly ContainerProfile _emptyContainerProfile = new ContainerProfile();
+
+        [Theory]
+        [InlineData(null)]
+        [InlineData("")]
+        [InlineData("mp4")]
+        public void ContainsContainer_EmptyContainerProfile_True(string? containers)
+        {
+            Assert.True(_emptyContainerProfile.ContainsContainer(containers));
+        }
+    }
+}
diff --git a/tests/Jellyfin.Model.Tests/Entities/MediaStreamTests.cs b/tests/Jellyfin.Model.Tests/Entities/MediaStreamTests.cs
new file mode 100644
index 000000000..0c97a90b4
--- /dev/null
+++ b/tests/Jellyfin.Model.Tests/Entities/MediaStreamTests.cs
@@ -0,0 +1,150 @@
+using MediaBrowser.Model.Entities;
+using Xunit;
+
+namespace Jellyfin.Model.Tests.Entities
+{
+    public class MediaStreamTests
+    {
+        public static TheoryData<MediaStream, string> Get_DisplayTitle_TestData()
+        {
+            var data = new TheoryData<MediaStream, string>();
+
+            data.Add(
+                    new MediaStream
+                    {
+                        Type = MediaStreamType.Subtitle,
+                        Title = "English",
+                        Language = string.Empty,
+                        IsForced = false,
+                        IsDefault = false,
+                        Codec = "ASS"
+                    },
+                    "English - Und - ASS");
+
+            data.Add(
+                new MediaStream
+                {
+                    Type = MediaStreamType.Subtitle,
+                    Title = "English",
+                    Language = string.Empty,
+                    IsForced = false,
+                    IsDefault = false,
+                    Codec = string.Empty
+                },
+                "English - Und");
+
+            data.Add(
+                new MediaStream
+                {
+                    Type = MediaStreamType.Subtitle,
+                    Title = "English",
+                    Language = "EN",
+                    IsForced = false,
+                    IsDefault = false,
+                    Codec = string.Empty
+                },
+                "English");
+
+            data.Add(
+                new MediaStream
+                {
+                    Type = MediaStreamType.Subtitle,
+                    Title = "English",
+                    Language = "EN",
+                    IsForced = true,
+                    IsDefault = true,
+                    Codec = "SRT"
+                },
+                "English - Default - Forced - SRT");
+
+            data.Add(
+                new MediaStream
+                {
+                    Type = MediaStreamType.Subtitle,
+                    Title = null,
+                    Language = null,
+                    IsForced = false,
+                    IsDefault = false,
+                    Codec = null
+                },
+                "Und");
+
+            return data;
+        }
+
+        [Theory]
+        [MemberData(nameof(Get_DisplayTitle_TestData))]
+        public void Get_DisplayTitle_should_return_valid_title(MediaStream mediaStream, string expected)
+        {
+            Assert.Equal(expected, mediaStream.DisplayTitle);
+        }
+
+        [Theory]
+        [InlineData(null, null, false, null)]
+        [InlineData(null, 0, false, null)]
+        [InlineData(0, null, false, null)]
+        [InlineData(640, 480, false, "480p")]
+        [InlineData(640, 480, true, "480i")]
+        [InlineData(720, 576, false, "576p")]
+        [InlineData(720, 576, true, "576i")]
+        [InlineData(960, 540, false, "540p")]
+        [InlineData(960, 540, true, "540i")]
+        [InlineData(1280, 720, false, "720p")]
+        [InlineData(1280, 720, true, "720i")]
+        [InlineData(1920, 1080, false, "1080p")]
+        [InlineData(1920, 1080, true, "1080i")]
+        [InlineData(4096, 3072, false, "4K")]
+        [InlineData(8192, 6144, false, "8K")]
+        [InlineData(512, 384, false, "480p")]
+        [InlineData(576, 336, false, "480p")]
+        [InlineData(624, 352, false, "480p")]
+        [InlineData(640, 352, false, "480p")]
+        [InlineData(704, 396, false, "480p")]
+        [InlineData(720, 404, false, "480p")]
+        [InlineData(720, 480, false, "480p")]
+        [InlineData(768, 576, false, "576p")]
+        [InlineData(960, 720, false, "720p")]
+        [InlineData(1280, 528, false, "720p")]
+        [InlineData(1280, 532, false, "720p")]
+        [InlineData(1280, 534, false, "720p")]
+        [InlineData(1280, 536, false, "720p")]
+        [InlineData(1280, 544, false, "720p")]
+        [InlineData(1280, 690, false, "720p")]
+        [InlineData(1280, 694, false, "720p")]
+        [InlineData(1280, 696, false, "720p")]
+        [InlineData(1280, 716, false, "720p")]
+        [InlineData(1280, 718, false, "720p")]
+        [InlineData(1912, 792, false, "1080p")]
+        [InlineData(1916, 1076, false, "1080p")]
+        [InlineData(1918, 1080, false, "1080p")]
+        [InlineData(1920, 796, false, "1080p")]
+        [InlineData(1920, 800, false, "1080p")]
+        [InlineData(1920, 802, false, "1080p")]
+        [InlineData(1920, 804, false, "1080p")]
+        [InlineData(1920, 808, false, "1080p")]
+        [InlineData(1920, 816, false, "1080p")]
+        [InlineData(1920, 856, false, "1080p")]
+        [InlineData(1920, 960, false, "1080p")]
+        [InlineData(1920, 1024, false, "1080p")]
+        [InlineData(1920, 1040, false, "1080p")]
+        [InlineData(1920, 1072, false, "1080p")]
+        [InlineData(1440, 1072, false, "1080p")]
+        [InlineData(1440, 1080, false, "1080p")]
+        [InlineData(3840, 1600, false, "4K")]
+        [InlineData(3840, 1606, false, "4K")]
+        [InlineData(3840, 1608, false, "4K")]
+        [InlineData(3840, 2160, false, "4K")]
+        [InlineData(7680, 4320, false, "8K")]
+        public void GetResolutionText_Valid(int? width, int? height, bool interlaced, string expected)
+        {
+            var mediaStream = new MediaStream()
+            {
+                Width = width,
+                Height = height,
+                IsInterlaced = interlaced
+            };
+
+            Assert.Equal(expected, mediaStream.GetResolutionText());
+        }
+    }
+}
diff --git a/tests/Jellyfin.Model.Tests/Entities/ProviderIdsExtensionsTests.cs b/tests/Jellyfin.Model.Tests/Entities/ProviderIdsExtensionsTests.cs
new file mode 100644
index 000000000..a1ace8476
--- /dev/null
+++ b/tests/Jellyfin.Model.Tests/Entities/ProviderIdsExtensionsTests.cs
@@ -0,0 +1,196 @@
+using System;
+using System.Collections.Generic;
+using MediaBrowser.Model.Entities;
+using Xunit;
+
+namespace Jellyfin.Model.Tests.Entities
+{
+    public class ProviderIdsExtensionsTests
+    {
+        private const string ExampleImdbId = "tt0113375";
+
+        [Fact]
+        public void HasProviderId_NullInstance_ThrowsArgumentNullException()
+        {
+            Assert.Throws<ArgumentNullException>(() => ProviderIdsExtensions.HasProviderId(null!, MetadataProvider.Imdb));
+        }
+
+        [Fact]
+        public void HasProviderId_NullProvider_False()
+        {
+            var nullProvider = new ProviderIdsExtensionsTestsObject
+            {
+                ProviderIds = null!
+            };
+
+            Assert.False(nullProvider.HasProviderId(MetadataProvider.Imdb));
+        }
+
+        [Fact]
+        public void HasProviderId_NullName_ThrowsArgumentNullException()
+        {
+            Assert.Throws<ArgumentNullException>(() => ProviderIdsExtensionsTestsObject.Empty.HasProviderId(null!));
+        }
+
+        [Fact]
+        public void HasProviderId_NotFoundName_False()
+        {
+            Assert.False(ProviderIdsExtensionsTestsObject.Empty.HasProviderId(MetadataProvider.Imdb));
+        }
+
+        [Fact]
+        public void HasProviderId_FoundName_True()
+        {
+            var provider = new ProviderIdsExtensionsTestsObject();
+            provider.ProviderIds[MetadataProvider.Imdb.ToString()] = ExampleImdbId;
+
+            Assert.True(provider.HasProviderId(MetadataProvider.Imdb));
+        }
+
+        [Fact]
+        public void HasProviderId_FoundNameEmptyValue_False()
+        {
+            var provider = new ProviderIdsExtensionsTestsObject();
+            provider.ProviderIds[MetadataProvider.Imdb.ToString()] = string.Empty;
+
+            Assert.False(provider.HasProviderId(MetadataProvider.Imdb));
+        }
+
+        [Fact]
+        public void GetProviderId_NullInstance_ThrowsArgumentNullException()
+        {
+            Assert.Throws<ArgumentNullException>(() => ProviderIdsExtensions.GetProviderId(null!, MetadataProvider.Imdb));
+        }
+
+        [Fact]
+        public void GetProviderId_NullName_ThrowsArgumentNullException()
+        {
+            Assert.Throws<ArgumentNullException>(() => ProviderIdsExtensionsTestsObject.Empty.GetProviderId(null!));
+        }
+
+        [Fact]
+        public void GetProviderId_NotFoundName_Null()
+        {
+            Assert.Null(ProviderIdsExtensionsTestsObject.Empty.GetProviderId(MetadataProvider.Imdb));
+        }
+
+        [Fact]
+        public void GetProviderId_NullProvider_Null()
+        {
+            var nullProvider = new ProviderIdsExtensionsTestsObject
+            {
+                ProviderIds = null!
+            };
+
+            Assert.Null(nullProvider.GetProviderId(MetadataProvider.Imdb));
+        }
+
+        [Fact]
+        public void TryGetProviderId_NotFoundName_False()
+        {
+            Assert.False(ProviderIdsExtensionsTestsObject.Empty.TryGetProviderId(MetadataProvider.Imdb, out _));
+        }
+
+        [Fact]
+        public void TryGetProviderId_NullProvider_False()
+        {
+            var nullProvider = new ProviderIdsExtensionsTestsObject
+            {
+                ProviderIds = null!
+            };
+
+            Assert.False(nullProvider.TryGetProviderId(MetadataProvider.Imdb, out _));
+        }
+
+        [Fact]
+        public void GetProviderId_FoundName_Id()
+        {
+            var provider = new ProviderIdsExtensionsTestsObject();
+            provider.ProviderIds[MetadataProvider.Imdb.ToString()] = ExampleImdbId;
+
+            Assert.Equal(ExampleImdbId, provider.GetProviderId(MetadataProvider.Imdb));
+        }
+
+        [Fact]
+        public void TryGetProviderId_FoundName_True()
+        {
+            var provider = new ProviderIdsExtensionsTestsObject();
+            provider.ProviderIds[MetadataProvider.Imdb.ToString()] = ExampleImdbId;
+
+            Assert.True(provider.TryGetProviderId(MetadataProvider.Imdb, out var id));
+            Assert.Equal(ExampleImdbId, id);
+        }
+
+        [Fact]
+        public void TryGetProviderId_FoundNameEmptyValue_False()
+        {
+            var provider = new ProviderIdsExtensionsTestsObject();
+            provider.ProviderIds[MetadataProvider.Imdb.ToString()] = string.Empty;
+
+            Assert.False(provider.TryGetProviderId(MetadataProvider.Imdb, out var id));
+            Assert.Null(id);
+        }
+
+        [Fact]
+        public void SetProviderId_NullInstance_ThrowsArgumentNullException()
+        {
+            Assert.Throws<ArgumentNullException>(() => ProviderIdsExtensions.SetProviderId(null!, MetadataProvider.Imdb, ExampleImdbId));
+        }
+
+        [Fact]
+        public void SetProviderId_Null_Remove()
+        {
+            var provider = new ProviderIdsExtensionsTestsObject();
+            provider.SetProviderId(MetadataProvider.Imdb, null!);
+            Assert.Empty(provider.ProviderIds);
+        }
+
+        [Fact]
+        public void SetProviderId_EmptyName_Remove()
+        {
+            var provider = new ProviderIdsExtensionsTestsObject();
+            provider.ProviderIds[MetadataProvider.Imdb.ToString()] = ExampleImdbId;
+            provider.SetProviderId(MetadataProvider.Imdb, string.Empty);
+            Assert.Empty(provider.ProviderIds);
+        }
+
+        [Fact]
+        public void SetProviderId_NonEmptyId_Success()
+        {
+            var provider = new ProviderIdsExtensionsTestsObject();
+            provider.SetProviderId(MetadataProvider.Imdb, ExampleImdbId);
+            Assert.Single(provider.ProviderIds);
+        }
+
+        [Fact]
+        public void SetProviderId_NullProvider_Success()
+        {
+            var nullProvider = new ProviderIdsExtensionsTestsObject
+            {
+                ProviderIds = null!
+            };
+
+            nullProvider.SetProviderId(MetadataProvider.Imdb, ExampleImdbId);
+            Assert.Single(nullProvider.ProviderIds);
+        }
+
+        [Fact]
+        public void SetProviderId_NullProviderAndEmptyName_Success()
+        {
+            var nullProvider = new ProviderIdsExtensionsTestsObject
+            {
+                ProviderIds = null!
+            };
+
+            nullProvider.SetProviderId(MetadataProvider.Imdb, string.Empty);
+            Assert.Null(nullProvider.ProviderIds);
+        }
+
+        private class ProviderIdsExtensionsTestsObject : IHasProviderIds
+        {
+            public static readonly ProviderIdsExtensionsTestsObject Empty = new ProviderIdsExtensionsTestsObject();
+
+            public Dictionary<string, string> ProviderIds { get; set; } = new Dictionary<string, string>();
+        }
+    }
+}
diff --git a/tests/Jellyfin.Model.Tests/Extensions/StringHelperTests.cs b/tests/Jellyfin.Model.Tests/Extensions/StringHelperTests.cs
index 51633e157..0a4e060df 100644
--- a/tests/Jellyfin.Model.Tests/Extensions/StringHelperTests.cs
+++ b/tests/Jellyfin.Model.Tests/Extensions/StringHelperTests.cs
@@ -1,4 +1,6 @@
 using System;
+using FsCheck;
+using FsCheck.Xunit;
 using MediaBrowser.Model.Extensions;
 using Xunit;
 
@@ -11,9 +13,20 @@ namespace Jellyfin.Model.Tests.Extensions
         [InlineData("banana", "Banana")]
         [InlineData("Banana", "Banana")]
         [InlineData("ä", "Ä")]
+        [InlineData("\027", "\027")]
         public void StringHelper_ValidArgs_Success(string input, string expectedResult)
         {
             Assert.Equal(expectedResult, StringHelper.FirstToUpper(input));
         }
+
+        [Property]
+        public Property FirstToUpper_RandomArg_Correct(NonEmptyString input)
+        {
+            var result = StringHelper.FirstToUpper(input.Item);
+
+            // We check IsLower instead of IsUpper because both return false for non-letters
+            return (!char.IsLower(result[0])).Label("First char is uppercase")
+                .And(input.Item.Length == 1 || result[1..].Equals(input.Item[1..], StringComparison.Ordinal)).Label("Remaining chars are unmodified");
+        }
     }
 }
diff --git a/tests/Jellyfin.Model.Tests/Jellyfin.Model.Tests.csproj b/tests/Jellyfin.Model.Tests/Jellyfin.Model.Tests.csproj
index 64d51e063..7e8397d9f 100644
--- a/tests/Jellyfin.Model.Tests/Jellyfin.Model.Tests.csproj
+++ b/tests/Jellyfin.Model.Tests/Jellyfin.Model.Tests.csproj
@@ -1,22 +1,21 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
     <IsPackable>false</IsPackable>
-    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-    <Nullable>enable</Nullable>
+    <CodeAnalysisRuleSet>../jellyfin-tests.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1" />
-    <PackageReference Include="coverlet.collector" Version="1.2.1" />
+    <PackageReference Include="coverlet.collector" Version="3.1.0" />
+    <PackageReference Include="FsCheck.Xunit" Version="2.16.3" />
   </ItemGroup>
 
   <!-- Code Analyzers -->
   <ItemGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="2.9.8" PrivateAssets="All" />
     <PackageReference Include="SerilogAnalyzer" Version="0.15.0" PrivateAssets="All" />
     <PackageReference Include="StyleCop.Analyzers" Version="1.1.118" PrivateAssets="All" />
     <PackageReference Include="SmartAnalyzers.MultithreadingAnalyzer" Version="1.1.31" PrivateAssets="All" />
@@ -26,8 +25,4 @@
     <ProjectReference Include="../../MediaBrowser.Model/MediaBrowser.Model.csproj" />
   </ItemGroup>
 
-  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <CodeAnalysisRuleSet>../jellyfin-tests.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-
 </Project>
diff --git a/tests/Jellyfin.Model.Tests/Net/MimeTypesTests.cs b/tests/Jellyfin.Model.Tests/Net/MimeTypesTests.cs
new file mode 100644
index 000000000..cbab455f0
--- /dev/null
+++ b/tests/Jellyfin.Model.Tests/Net/MimeTypesTests.cs
@@ -0,0 +1,159 @@
+using MediaBrowser.Model.Net;
+using Xunit;
+
+namespace Jellyfin.Model.Tests.Net
+{
+    public class MimeTypesTests
+    {
+        [Theory]
+        [InlineData(".dll", "application/octet-stream")]
+        [InlineData(".log", "text/plain")]
+        [InlineData(".srt", "application/x-subrip")]
+        [InlineData(".html", "text/html; charset=UTF-8")]
+        [InlineData(".htm", "text/html; charset=UTF-8")]
+        [InlineData(".7z", "application/x-7z-compressed")]
+        [InlineData(".azw", "application/vnd.amazon.ebook")]
+        [InlineData(".azw3", "application/vnd.amazon.ebook")]
+        [InlineData(".eot", "application/vnd.ms-fontobject")]
+        [InlineData(".epub", "application/epub+zip")]
+        [InlineData(".json", "application/json")]
+        [InlineData(".mobi", "application/x-mobipocket-ebook")]
+        [InlineData(".opf", "application/oebps-package+xml")]
+        [InlineData(".pdf", "application/pdf")]
+        [InlineData(".rar", "application/vnd.rar")]
+        [InlineData(".ttml", "application/ttml+xml")]
+        [InlineData(".wasm", "application/wasm")]
+        [InlineData(".xml", "application/xml")]
+        [InlineData(".zip", "application/zip")]
+        [InlineData(".bmp", "image/bmp")]
+        [InlineData(".gif", "image/gif")]
+        [InlineData(".ico", "image/vnd.microsoft.icon")]
+        [InlineData(".jpg", "image/jpeg")]
+        [InlineData(".jpeg", "image/jpeg")]
+        [InlineData(".png", "image/png")]
+        [InlineData(".svg", "image/svg+xml")]
+        [InlineData(".svgz", "image/svg+xml")]
+        [InlineData(".tbn", "image/jpeg")]
+        [InlineData(".tif", "image/tiff")]
+        [InlineData(".tiff", "image/tiff")]
+        [InlineData(".webp", "image/webp")]
+        [InlineData(".ttf", "font/ttf")]
+        [InlineData(".woff", "font/woff")]
+        [InlineData(".woff2", "font/woff2")]
+        [InlineData(".ass", "text/x-ssa")]
+        [InlineData(".ssa", "text/x-ssa")]
+        [InlineData(".css", "text/css")]
+        [InlineData(".csv", "text/csv")]
+        [InlineData(".edl", "text/plain")]
+        [InlineData(".txt", "text/plain")]
+        [InlineData(".vtt", "text/vtt")]
+        [InlineData(".3gp", "video/3gpp")]
+        [InlineData(".3g2", "video/3gpp2")]
+        [InlineData(".asf", "video/x-ms-asf")]
+        [InlineData(".avi", "video/x-msvideo")]
+        [InlineData(".flv", "video/x-flv")]
+        [InlineData(".mp4", "video/mp4")]
+        [InlineData(".m4v", "video/x-m4v")]
+        [InlineData(".mpegts", "video/mp2t")]
+        [InlineData(".mpg", "video/mpeg")]
+        [InlineData(".mkv", "video/x-matroska")]
+        [InlineData(".mov", "video/quicktime")]
+        [InlineData(".ogv", "video/ogg")]
+        [InlineData(".ts", "video/mp2t")]
+        [InlineData(".webm", "video/webm")]
+        [InlineData(".wmv", "video/x-ms-wmv")]
+        [InlineData(".aac", "audio/aac")]
+        [InlineData(".ac3", "audio/ac3")]
+        [InlineData(".ape", "audio/x-ape")]
+        [InlineData(".dsf", "audio/dsf")]
+        [InlineData(".dsp", "audio/dsp")]
+        [InlineData(".flac", "audio/flac")]
+        [InlineData(".m4a", "audio/mp4")]
+        [InlineData(".m4b", "audio/m4b")]
+        [InlineData(".mid", "audio/midi")]
+        [InlineData(".midi", "audio/midi")]
+        [InlineData(".mp3", "audio/mpeg")]
+        [InlineData(".oga", "audio/ogg")]
+        [InlineData(".ogg", "audio/ogg")]
+        [InlineData(".opus", "audio/ogg")]
+        [InlineData(".vorbis", "audio/vorbis")]
+        [InlineData(".wav", "audio/wav")]
+        [InlineData(".webma", "audio/webm")]
+        [InlineData(".wma", "audio/x-ms-wma")]
+        [InlineData(".wv", "audio/x-wavpack")]
+        [InlineData(".xsp", "audio/xsp")]
+        public void GetMimeType_Valid_ReturnsCorrectResult(string input, string expectedResult)
+        {
+            Assert.Equal(expectedResult, MimeTypes.GetMimeType(input, null));
+        }
+
+        [Theory]
+        [InlineData("application/epub+zip", ".epub")]
+        [InlineData("application/json", ".json")]
+        [InlineData("application/oebps-package+xml", ".opf")]
+        [InlineData("application/pdf", ".pdf")]
+        [InlineData("application/ttml+xml", ".ttml")]
+        [InlineData("application/vnd.amazon.ebook", ".azw")]
+        [InlineData("application/vnd.ms-fontobject", ".eot")]
+        [InlineData("application/vnd.rar", ".rar")]
+        [InlineData("application/wasm", ".wasm")]
+        [InlineData("application/x-7z-compressed", ".7z")]
+        [InlineData("application/x-cbz", ".cbz")]
+        [InlineData("application/x-javascript", ".js")]
+        [InlineData("application/x-mobipocket-ebook", ".mobi")]
+        [InlineData("application/x-mpegURL", ".m3u8")]
+        [InlineData("application/x-subrip", ".srt")]
+        [InlineData("application/xml", ".xml")]
+        [InlineData("application/zip", ".zip")]
+        [InlineData("audio/aac", ".aac")]
+        [InlineData("audio/ac3", ".ac3")]
+        [InlineData("audio/dsf", ".dsf")]
+        [InlineData("audio/dsp", ".dsp")]
+        [InlineData("audio/flac", ".flac")]
+        [InlineData("audio/m4b", ".m4b")]
+        [InlineData("audio/mp4", ".m4a")]
+        [InlineData("audio/vorbis", ".vorbis")]
+        [InlineData("audio/wav", ".wav")]
+        [InlineData("audio/x-aac", ".aac")]
+        [InlineData("audio/x-ape", ".ape")]
+        [InlineData("audio/x-ms-wma", ".wma")]
+        [InlineData("audio/x-wavpack", ".wv")]
+        [InlineData("audio/xsp", ".xsp")]
+        [InlineData("font/ttf", ".ttf")]
+        [InlineData("font/woff", ".woff")]
+        [InlineData("font/woff2", ".woff2")]
+        [InlineData("image/bmp", ".bmp")]
+        [InlineData("image/gif", ".gif")]
+        [InlineData("image/jpeg", ".jpg")]
+        [InlineData("image/png", ".png")]
+        [InlineData("image/svg+xml", ".svg")]
+        [InlineData("image/tiff", ".tif")]
+        [InlineData("image/vnd.microsoft.icon", ".ico")]
+        [InlineData("image/webp", ".webp")]
+        [InlineData("image/x-png", ".png")]
+        [InlineData("text/css", ".css")]
+        [InlineData("text/csv", ".csv")]
+        [InlineData("text/plain", ".txt")]
+        [InlineData("text/rtf", ".rtf")]
+        [InlineData("text/vtt", ".vtt")]
+        [InlineData("text/x-ssa", ".ssa")]
+        [InlineData("video/3gpp", ".3gp")]
+        [InlineData("video/3gpp2", ".3g2")]
+        [InlineData("video/mp2t", ".ts")]
+        [InlineData("video/mp4", ".mp4")]
+        [InlineData("video/ogg", ".ogv")]
+        [InlineData("video/quicktime", ".mov")]
+        [InlineData("video/vnd.mpeg.dash.mpd", ".mpd")]
+        [InlineData("video/webm", ".webm")]
+        [InlineData("video/x-flv", ".flv")]
+        [InlineData("video/x-m4v", ".m4v")]
+        [InlineData("video/x-matroska", ".mkv")]
+        [InlineData("video/x-ms-asf", ".asf")]
+        [InlineData("video/x-ms-wmv", ".wmv")]
+        [InlineData("video/x-msvideo", ".avi")]
+        public void ToExtension_Valid_ReturnsCorrectResult(string input, string expectedResult)
+        {
+            Assert.Equal(expectedResult, MimeTypes.ToExtension(input));
+        }
+    }
+}
diff --git a/tests/Jellyfin.Naming.Tests/AudioBook/AudioBookListResolverTests.cs b/tests/Jellyfin.Naming.Tests/AudioBook/AudioBookListResolverTests.cs
index e5768b620..d9e77dd2e 100644
--- a/tests/Jellyfin.Naming.Tests/AudioBook/AudioBookListResolverTests.cs
+++ b/tests/Jellyfin.Naming.Tests/AudioBook/AudioBookListResolverTests.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using Emby.Naming.AudioBook;
 using Emby.Naming.Common;
diff --git a/tests/Jellyfin.Naming.Tests/AudioBook/AudioBookResolverTests.cs b/tests/Jellyfin.Naming.Tests/AudioBook/AudioBookResolverTests.cs
index b3257ace3..c72a3315e 100644
--- a/tests/Jellyfin.Naming.Tests/AudioBook/AudioBookResolverTests.cs
+++ b/tests/Jellyfin.Naming.Tests/AudioBook/AudioBookResolverTests.cs
@@ -1,5 +1,3 @@
-using System;
-using System.Collections.Generic;
 using Emby.Naming.AudioBook;
 using Emby.Naming.Common;
 using Xunit;
@@ -10,33 +8,33 @@ namespace Jellyfin.Naming.Tests.AudioBook
     {
         private readonly NamingOptions _namingOptions = new NamingOptions();
 
-        public static IEnumerable<object[]> GetResolveFileTestData()
+        public static TheoryData<AudioBookFileInfo> Resolve_ValidFileNameTestData()
         {
-            yield return new object[]
-            {
+            var data = new TheoryData<AudioBookFileInfo>();
+
+            data.Add(
                 new AudioBookFileInfo(
                     @"/server/AudioBooks/Larry Potter/Larry Potter.mp3",
-                    "mp3")
-            };
-            yield return new object[]
-            {
+                    "mp3"));
+
+            data.Add(
                 new AudioBookFileInfo(
                     @"/server/AudioBooks/Berry Potter/Chapter 1 .ogg",
                     "ogg",
-                    chapterNumber: 1)
-            };
-            yield return new object[]
-            {
+                    chapterNumber: 1));
+
+            data.Add(
                 new AudioBookFileInfo(
                     @"/server/AudioBooks/Nerry Potter/Part 3 - Chapter 2.mp3",
                     "mp3",
                     chapterNumber: 2,
-                    partNumber: 3)
-            };
+                    partNumber: 3));
+
+            return data;
         }
 
         [Theory]
-        [MemberData(nameof(GetResolveFileTestData))]
+        [MemberData(nameof(Resolve_ValidFileNameTestData))]
         public void Resolve_ValidFileName_Success(AudioBookFileInfo expectedResult)
         {
             var result = new AudioBookResolver(_namingOptions).Resolve(expectedResult.Path);
diff --git a/tests/Jellyfin.Naming.Tests/Common/NamingOptionsTest.cs b/tests/Jellyfin.Naming.Tests/Common/NamingOptionsTest.cs
index 3892d00f6..58aaed023 100644
--- a/tests/Jellyfin.Naming.Tests/Common/NamingOptionsTest.cs
+++ b/tests/Jellyfin.Naming.Tests/Common/NamingOptionsTest.cs
@@ -10,7 +10,6 @@ namespace Jellyfin.Naming.Tests.Common
         {
             var options = new NamingOptions();
 
-            Assert.NotEmpty(options.VideoFileStackingRegexes);
             Assert.NotEmpty(options.CleanDateTimeRegexes);
             Assert.NotEmpty(options.CleanStringRegexes);
             Assert.NotEmpty(options.EpisodeWithoutSeasonRegexes);
diff --git a/tests/Jellyfin.Naming.Tests/Jellyfin.Naming.Tests.csproj b/tests/Jellyfin.Naming.Tests/Jellyfin.Naming.Tests.csproj
index f3b00dcab..4096873a3 100644
--- a/tests/Jellyfin.Naming.Tests/Jellyfin.Naming.Tests.csproj
+++ b/tests/Jellyfin.Naming.Tests/Jellyfin.Naming.Tests.csproj
@@ -6,17 +6,16 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
     <IsPackable>false</IsPackable>
-    <Nullable>enable</Nullable>
-    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <CodeAnalysisRuleSet>../jellyfin-tests.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" />
-    <PackageReference Include="coverlet.collector" Version="3.0.0" />
+    <PackageReference Include="coverlet.collector" Version="3.1.0" />
   </ItemGroup>
 
   <ItemGroup>
@@ -25,14 +24,9 @@
 
   <!-- Code Analyzers-->
   <ItemGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="2.9.8" PrivateAssets="All" />
     <PackageReference Include="SerilogAnalyzer" Version="0.15.0" PrivateAssets="All" />
     <PackageReference Include="StyleCop.Analyzers" Version="1.1.118" PrivateAssets="All" />
     <PackageReference Include="SmartAnalyzers.MultithreadingAnalyzer" Version="1.1.31" PrivateAssets="All" />
   </ItemGroup>
 
-  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <CodeAnalysisRuleSet>../jellyfin-tests.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-
 </Project>
diff --git a/tests/Jellyfin.Naming.Tests/Subtitles/SubtitleParserTests.cs b/tests/Jellyfin.Naming.Tests/Subtitles/SubtitleParserTests.cs
index f3abacb4f..2446660f3 100644
--- a/tests/Jellyfin.Naming.Tests/Subtitles/SubtitleParserTests.cs
+++ b/tests/Jellyfin.Naming.Tests/Subtitles/SubtitleParserTests.cs
@@ -1,4 +1,3 @@
-using System;
 using Emby.Naming.Common;
 using Emby.Naming.Subtitles;
 using Xunit;
diff --git a/tests/Jellyfin.Naming.Tests/TV/EpisodeNumberTests.cs b/tests/Jellyfin.Naming.Tests/TV/EpisodeNumberTests.cs
index 5e023bdb0..1e7fedb36 100644
--- a/tests/Jellyfin.Naming.Tests/TV/EpisodeNumberTests.cs
+++ b/tests/Jellyfin.Naming.Tests/TV/EpisodeNumberTests.cs
@@ -66,12 +66,17 @@ namespace Jellyfin.Naming.Tests.TV
         [InlineData("Season 2/2. Infestation.avi", 2)]
         [InlineData("The Wonder Years/The.Wonder.Years.S04.PDTV.x264-JCH/The Wonder Years s04e07 Christmas Party NTSC PDTV.avi", 7)]
         [InlineData("Running Man/Running Man S2017E368.mkv", 368)]
+        [InlineData("Season 2/[HorribleSubs] Hunter X Hunter - 136 [720p].mkv", 136)] // triple digit episode number
+        [InlineData("Log Horizon 2/[HorribleSubs] Log Horizon 2 - 03 [720p].mkv", 3)] // digit in series name
+        [InlineData("Season 1/seriesname 05.mkv", 5)] // no hyphen between series name and episode number
+        [InlineData("[BBT-RMX] Ranma ½ - 154 [50AC421A].mkv", 154)] // hyphens in the pre-name info, triple digit episode number
+        [InlineData("Season 2/Episode 21 - 94 Meetings.mp4", 21)] // Title starts with a number
+        [InlineData("/The.Legend.of.Condor.Heroes.2017.V2.web-dl.1080p.h264.aac-hdctv/The.Legend.of.Condor.Heroes.2017.E07.V2.web-dl.1080p.h264.aac-hdctv.mkv", 7)]
+        // [InlineData("Case Closed (1996-2007)/Case Closed - 317.mkv", 317)] // triple digit episode number
         // TODO: [InlineData("Season 2/16 12 Some Title.avi", 16)]
-        // TODO: [InlineData("/The.Legend.of.Condor.Heroes.2017.V2.web-dl.1080p.h264.aac-hdctv/The.Legend.of.Condor.Heroes.2017.E07.V2.web-dl.1080p.h264.aac-hdctv.mkv", 7)]
         // TODO: [InlineData("Season 4/Uchuu.Senkan.Yamato.2199.E03.avi", 3)]
         // TODO: [InlineData("Season 2/7 12 Angry Men.avi", 7)]
         // TODO: [InlineData("Season 02/02x03x04x15 - Ep Name.mp4", 2)]
-        // TODO: [InlineData("Season 2/[HorribleSubs] Hunter X Hunter - 136 [720p].mkv", 136)]
         public void GetEpisodeNumberFromFileTest(string path, int? expected)
         {
             var result = new EpisodePathParser(_namingOptions)
diff --git a/tests/Jellyfin.Naming.Tests/TV/SeriesPathParserTest.cs b/tests/Jellyfin.Naming.Tests/TV/SeriesPathParserTest.cs
new file mode 100644
index 000000000..ceb5f8b73
--- /dev/null
+++ b/tests/Jellyfin.Naming.Tests/TV/SeriesPathParserTest.cs
@@ -0,0 +1,28 @@
+using Emby.Naming.Common;
+using Emby.Naming.TV;
+using Xunit;
+
+namespace Jellyfin.Naming.Tests.TV
+{
+    public class SeriesPathParserTest
+    {
+        [Theory]
+        [InlineData("The.Show.S01", "The.Show")]
+        [InlineData("/The.Show.S01", "The.Show")]
+        [InlineData("/some/place/The.Show.S01", "The.Show")]
+        [InlineData("/something/The.Show.S01", "The.Show")]
+        [InlineData("The Show Season 10", "The Show")]
+        [InlineData("The Show S01E01", "The Show")]
+        [InlineData("The Show S01E01 Episode", "The Show")]
+        [InlineData("/something/The Show/Season 1", "The Show")]
+        [InlineData("/something/The Show/S01", "The Show")]
+        public void SeriesPathParserParseTest(string path, string name)
+        {
+            NamingOptions o = new NamingOptions();
+            var res = SeriesPathParser.Parse(o, path);
+
+            Assert.Equal(name, res.SeriesName);
+            Assert.True(res.Success);
+        }
+    }
+}
diff --git a/tests/Jellyfin.Naming.Tests/TV/SeriesResolverTests.cs b/tests/Jellyfin.Naming.Tests/TV/SeriesResolverTests.cs
new file mode 100644
index 000000000..97f4b4058
--- /dev/null
+++ b/tests/Jellyfin.Naming.Tests/TV/SeriesResolverTests.cs
@@ -0,0 +1,28 @@
+using Emby.Naming.Common;
+using Emby.Naming.TV;
+using Xunit;
+
+namespace Jellyfin.Naming.Tests.TV
+{
+    public class SeriesResolverTests
+    {
+        [Theory]
+        [InlineData("The.Show.S01", "The Show")]
+        [InlineData("The.Show.S01.COMPLETE", "The Show")]
+        [InlineData("S.H.O.W.S01", "S.H.O.W")]
+        [InlineData("The.Show.P.I.S01", "The Show P.I")]
+        [InlineData("The_Show_Season_1", "The Show")]
+        [InlineData("/something/The_Show/Season 10", "The Show")]
+        [InlineData("The Show", "The Show")]
+        [InlineData("/some/path/The Show", "The Show")]
+        [InlineData("/some/path/The Show s02e10 720p hdtv", "The Show")]
+        [InlineData("/some/path/The Show s02e10 the episode 720p hdtv", "The Show")]
+        public void SeriesResolverResolveTest(string path, string name)
+        {
+            NamingOptions o = new NamingOptions();
+            var res = SeriesResolver.Resolve(o, path);
+
+            Assert.Equal(name, res.Name);
+        }
+    }
+}
diff --git a/tests/Jellyfin.Naming.Tests/TV/SimpleEpisodeTests.cs b/tests/Jellyfin.Naming.Tests/TV/SimpleEpisodeTests.cs
index 89579c037..6d49ac832 100644
--- a/tests/Jellyfin.Naming.Tests/TV/SimpleEpisodeTests.cs
+++ b/tests/Jellyfin.Naming.Tests/TV/SimpleEpisodeTests.cs
@@ -21,7 +21,8 @@ namespace Jellyfin.Naming.Tests.TV
         [InlineData("[Baz-Bar]Foo - [1080p][Multiple Subtitle]/[Baz-Bar] Foo - 05 [1080p][Multiple Subtitle].mkv", "Foo", null, 5)]
         [InlineData(@"/Foo/The.Series.Name.S01E04.WEBRip.x264-Baz[Bar]/the.series.name.s01e04.webrip.x264-Baz[Bar].mkv", "The.Series.Name", 1, 4)]
         [InlineData(@"Love.Death.and.Robots.S01.1080p.NF.WEB-DL.DDP5.1.x264-NTG/Love.Death.and.Robots.S01E01.Sonnies.Edge.1080p.NF.WEB-DL.DDP5.1.x264-NTG.mkv", "Love.Death.and.Robots", 1, 1)]
-        // TODO: [InlineData("[Baz-Bar]Foo - 01 - 12[1080p][Multiple Subtitle]/[Baz-Bar] Foo - 05 [1080p][Multiple Subtitle].mkv", "Foo", null, 5)]
+        [InlineData("[YuiSubs] Tensura Nikki - Tensei Shitara Slime Datta Ken/[YuiSubs] Tensura Nikki - Tensei Shitara Slime Datta Ken - 12 (NVENC H.265 1080p).mkv", "Tensura Nikki - Tensei Shitara Slime Datta Ken", null, 12)]
+        [InlineData("[Baz-Bar]Foo - 01 - 12[1080p][Multiple Subtitle]/[Baz-Bar] Foo - 05 [1080p][Multiple Subtitle].mkv", "Foo", null, 5)]
         // TODO: [InlineData("E:\\Anime\\Yahari Ore no Seishun Love Comedy wa Machigatteiru\\Yahari Ore no Seishun Love Comedy wa Machigatteiru. Zoku\\Oregairu Zoku 11 - Hayama Hayato Always Renconds to Everyone's Expectations..mkv", "Yahari Ore no Seishun Love Comedy wa Machigatteiru", null, 11)]
         // TODO: [InlineData(@"/Library/Series/The Grand Tour (2016)/Season 1/S01E01 The Holy Trinity.mkv", "The Grand Tour", 1, 1)]
         public void TestSimple(string path, string seriesName, int? seasonNumber, int? episodeNumber)
diff --git a/tests/Jellyfin.Naming.Tests/Video/CleanDateTimeTests.cs b/tests/Jellyfin.Naming.Tests/Video/CleanDateTimeTests.cs
index 950899d7e..b1141df47 100644
--- a/tests/Jellyfin.Naming.Tests/Video/CleanDateTimeTests.cs
+++ b/tests/Jellyfin.Naming.Tests/Video/CleanDateTimeTests.cs
@@ -58,7 +58,7 @@ namespace Jellyfin.Naming.Tests.Video
         {
             input = Path.GetFileName(input);
 
-            var result = new VideoResolver(_namingOptions).CleanDateTime(input);
+            var result = VideoResolver.CleanDateTime(input, _namingOptions);
 
             Assert.Equal(expectedName, result.Name, true);
             Assert.Equal(expectedYear, result.Year);
diff --git a/tests/Jellyfin.Naming.Tests/Video/CleanStringTests.cs b/tests/Jellyfin.Naming.Tests/Video/CleanStringTests.cs
index fde06c5a1..1574bce58 100644
--- a/tests/Jellyfin.Naming.Tests/Video/CleanStringTests.cs
+++ b/tests/Jellyfin.Naming.Tests/Video/CleanStringTests.cs
@@ -1,4 +1,3 @@
-using System;
 using Emby.Naming.Common;
 using Emby.Naming.Video;
 using Xunit;
@@ -14,11 +13,6 @@ namespace Jellyfin.Naming.Tests.Video
         [InlineData("Super movie 480p 2001.mp4", "Super movie")]
         [InlineData("Super movie [480p].mp4", "Super movie")]
         [InlineData("480 Super movie [tmdbid=12345].mp4", "480 Super movie")]
-        [InlineData("Super movie(2009).mp4", "Super movie(2009).mp4")]
-        [InlineData("Run lola run (lola rennt) (2009).mp4", "Run lola run (lola rennt) (2009).mp4")]
-        [InlineData(@"American.Psycho.mkv", "American.Psycho.mkv")]
-        [InlineData(@"American Psycho.mkv", "American Psycho.mkv")]
-        [InlineData(@"[rec].mkv", "[rec].mkv")]
         [InlineData("Crouching.Tiger.Hidden.Dragon.4k.mkv", "Crouching.Tiger.Hidden.Dragon")]
         [InlineData("Crouching.Tiger.Hidden.Dragon.UltraHD.mkv", "Crouching.Tiger.Hidden.Dragon")]
         [InlineData("Crouching.Tiger.Hidden.Dragon.UHD.mkv", "Crouching.Tiger.Hidden.Dragon")]
@@ -28,18 +22,31 @@ namespace Jellyfin.Naming.Tests.Video
         [InlineData("Crouching.Tiger.Hidden.Dragon.BDrip.mkv", "Crouching.Tiger.Hidden.Dragon")]
         [InlineData("Crouching.Tiger.Hidden.Dragon.BDrip-HDC.mkv", "Crouching.Tiger.Hidden.Dragon")]
         [InlineData("Crouching.Tiger.Hidden.Dragon.4K.UltraHD.HDR.BDrip-HDC.mkv", "Crouching.Tiger.Hidden.Dragon")]
+        [InlineData("[HorribleSubs] Made in Abyss - 13 [720p].mkv", "Made in Abyss")]
+        [InlineData("[Tsundere] Kore wa Zombie Desu ka of the Dead [BDRip h264 1920x1080 FLAC]", "Kore wa Zombie Desu ka of the Dead")]
+        [InlineData("[Erai-raws] Jujutsu Kaisen - 03 [720p][Multiple Subtitle].mkv", "Jujutsu Kaisen")]
+        [InlineData("[OCN] 애타는 로맨스 720p-NEXT", "애타는 로맨스")]
+        [InlineData("[tvN] 혼술남녀.E01-E16.720p-NEXT", "혼술남녀")]
+        [InlineData("[tvN] 연애말고 결혼 E01~E16 END HDTV.H264.720p-WITH", "연애말고 결혼")]
         // FIXME: [InlineData("After The Sunset - [0004].mkv", "After The Sunset")]
-        public void CleanStringTest(string input, string expectedName)
+        public void CleanStringTest_NeedsCleaning_Success(string input, string expectedName)
         {
-            if (new VideoResolver(_namingOptions).TryCleanString(input, out ReadOnlySpan<char> newName))
-            {
-                // TODO: compare spans when XUnit supports it
-                Assert.Equal(expectedName, newName.ToString());
-            }
-            else
-            {
-                Assert.Equal(expectedName, input);
-            }
+            Assert.True(VideoResolver.TryCleanString(input, _namingOptions, out var newName));
+            Assert.Equal(expectedName, newName);
+        }
+
+        [Theory]
+        [InlineData(null)]
+        [InlineData("")]
+        [InlineData("Super movie(2009).mp4")]
+        [InlineData("[rec].mkv")]
+        [InlineData("American.Psycho.mkv")]
+        [InlineData("American Psycho.mkv")]
+        [InlineData("Run lola run (lola rennt) (2009).mp4")]
+        public void CleanStringTest_DoesntNeedCleaning_False(string? input)
+        {
+            Assert.False(VideoResolver.TryCleanString(input, _namingOptions, out var newName));
+            Assert.True(string.IsNullOrEmpty(newName));
         }
     }
 }
diff --git a/tests/Jellyfin.Naming.Tests/Video/ExtraTests.cs b/tests/Jellyfin.Naming.Tests/Video/ExtraTests.cs
index d34f65409..8dd637559 100644
--- a/tests/Jellyfin.Naming.Tests/Video/ExtraTests.cs
+++ b/tests/Jellyfin.Naming.Tests/Video/ExtraTests.cs
@@ -1,4 +1,3 @@
-using System;
 using Emby.Naming.Common;
 using Emby.Naming.Video;
 using MediaBrowser.Model.Entities;
@@ -19,30 +18,31 @@ namespace Jellyfin.Naming.Tests.Video
         [Fact]
         public void TestKodiExtras()
         {
-            Test("trailer.mp4", ExtraType.Trailer, _videoOptions);
-            Test("300-trailer.mp4", ExtraType.Trailer, _videoOptions);
+            Test("trailer.mp4", ExtraType.Trailer);
+            Test("300-trailer.mp4", ExtraType.Trailer);
 
-            Test("theme.mp3", ExtraType.ThemeSong, _videoOptions);
+            Test("theme.mp3", ExtraType.ThemeSong);
         }
 
         [Fact]
         public void TestExpandedExtras()
         {
-            Test("trailer.mp4", ExtraType.Trailer, _videoOptions);
-            Test("trailer.mp3", null, _videoOptions);
-            Test("300-trailer.mp4", ExtraType.Trailer, _videoOptions);
-
-            Test("theme.mp3", ExtraType.ThemeSong, _videoOptions);
-            Test("theme.mkv", null, _videoOptions);
-
-            Test("300-scene.mp4", ExtraType.Scene, _videoOptions);
-            Test("300-scene2.mp4", ExtraType.Scene, _videoOptions);
-            Test("300-clip.mp4", ExtraType.Clip, _videoOptions);
-
-            Test("300-deleted.mp4", ExtraType.DeletedScene, _videoOptions);
-            Test("300-deletedscene.mp4", ExtraType.DeletedScene, _videoOptions);
-            Test("300-interview.mp4", ExtraType.Interview, _videoOptions);
-            Test("300-behindthescenes.mp4", ExtraType.BehindTheScenes, _videoOptions);
+            Test("trailer.mp4", ExtraType.Trailer);
+            Test("trailer.mp3", null);
+            Test("300-trailer.mp4", ExtraType.Trailer);
+            Test("stuff trailerthings.mkv", null);
+
+            Test("theme.mp3", ExtraType.ThemeSong);
+            Test("theme.mkv", null);
+
+            Test("300-scene.mp4", ExtraType.Scene);
+            Test("300-scene2.mp4", ExtraType.Scene);
+            Test("300-clip.mp4", ExtraType.Clip);
+
+            Test("300-deleted.mp4", ExtraType.DeletedScene);
+            Test("300-deletedscene.mp4", ExtraType.DeletedScene);
+            Test("300-interview.mp4", ExtraType.Interview);
+            Test("300-behindthescenes.mp4", ExtraType.BehindTheScenes);
         }
 
         [Theory]
@@ -56,9 +56,9 @@ namespace Jellyfin.Naming.Tests.Video
         [InlineData(ExtraType.Unknown, "extras")]
         public void TestDirectories(ExtraType type, string dirName)
         {
-            Test(dirName + "/300.mp4", type, _videoOptions);
-            Test("300/" + dirName + "/something.mkv", type, _videoOptions);
-            Test("/data/something/Movies/300/" + dirName + "/whoknows.mp4", type, _videoOptions);
+            Test(dirName + "/300.mp4", type);
+            Test("300/" + dirName + "/something.mkv", type);
+            Test("/data/something/Movies/300/" + dirName + "/whoknows.mp4", type);
         }
 
         [Theory]
@@ -67,32 +67,23 @@ namespace Jellyfin.Naming.Tests.Video
         [InlineData("The Big Short")]
         public void TestNonExtraDirectories(string dirName)
         {
-            Test(dirName + "/300.mp4", null, _videoOptions);
-            Test("300/" + dirName + "/something.mkv", null, _videoOptions);
-            Test("/data/something/Movies/300/" + dirName + "/whoknows.mp4", null, _videoOptions);
-            Test("/data/something/Movies/" + dirName + "/" + dirName + ".mp4", null, _videoOptions);
+            Test(dirName + "/300.mp4", null);
+            Test("300/" + dirName + "/something.mkv", null);
+            Test("/data/something/Movies/300/" + dirName + "/whoknows.mp4", null);
+            Test("/data/something/Movies/" + dirName + "/" + dirName + ".mp4", null);
         }
 
         [Fact]
         public void TestSample()
         {
-            Test("300-sample.mp4", ExtraType.Sample, _videoOptions);
+            Test("300-sample.mp4", ExtraType.Sample);
         }
 
-        private void Test(string input, ExtraType? expectedType, NamingOptions videoOptions)
+        private void Test(string input, ExtraType? expectedType)
         {
-            var parser = GetExtraTypeParser(videoOptions);
-
-            var extraType = parser.GetExtraInfo(input).ExtraType;
-
-            if (expectedType == null)
-            {
-                Assert.Null(extraType);
-            }
-            else
-            {
-                Assert.Equal(expectedType, extraType);
-            }
+            var extraType = ExtraResolver.GetExtraInfo(input, _videoOptions).ExtraType;
+
+            Assert.Equal(expectedType, extraType);
         }
 
         [Fact]
@@ -100,21 +91,9 @@ namespace Jellyfin.Naming.Tests.Video
         {
             var rule = new ExtraRule(ExtraType.Unknown, ExtraRuleType.Regex, @"([eE]x(tra)?\.\w+)", MediaType.Video);
             var options = new NamingOptions { VideoExtraRules = new[] { rule } };
-            var res = GetExtraTypeParser(options).GetExtraInfo("extra.mp4");
+            var res = ExtraResolver.GetExtraInfo("extra.mp4", options);
 
             Assert.Equal(rule, res.Rule);
         }
-
-        [Fact]
-        public void TestFlagsParser()
-        {
-            var flags = new FlagParser(_videoOptions).GetFlags(string.Empty);
-            Assert.Empty(flags);
-        }
-
-        private ExtraResolver GetExtraTypeParser(NamingOptions videoOptions)
-        {
-            return new ExtraResolver(videoOptions);
-        }
     }
 }
diff --git a/tests/Jellyfin.Naming.Tests/Video/Format3DTests.cs b/tests/Jellyfin.Naming.Tests/Video/Format3DTests.cs
index 69de96a47..1762b91b9 100644
--- a/tests/Jellyfin.Naming.Tests/Video/Format3DTests.cs
+++ b/tests/Jellyfin.Naming.Tests/Video/Format3DTests.cs
@@ -22,8 +22,7 @@ namespace Jellyfin.Naming.Tests.Video
         [Fact]
         public void Test3DName()
         {
-            var result =
-                new VideoResolver(_namingOptions).ResolveFile(@"C:/Users/media/Desktop/Video Test/Movies/Oblivion/Oblivion.3d.hsbs.mkv");
+            var result = VideoResolver.ResolveFile(@"C:/Users/media/Desktop/Video Test/Movies/Oblivion/Oblivion.3d.hsbs.mkv", _namingOptions);
 
             Assert.Equal("hsbs", result?.Format3D);
             Assert.Equal("Oblivion", result?.Name);
@@ -58,15 +57,13 @@ namespace Jellyfin.Naming.Tests.Video
 
         private void Test(string input, bool is3D, string? format3D)
         {
-            var parser = new Format3DParser(_namingOptions);
-
-            var result = parser.Parse(input);
+            var result = Format3DParser.Parse(input, _namingOptions);
 
             Assert.Equal(is3D, result.Is3D);
 
             if (format3D == null)
             {
-                Assert.Null(result.Format3D);
+                Assert.Null(result?.Format3D);
             }
             else
             {
diff --git a/tests/Jellyfin.Naming.Tests/Video/MultiVersionTests.cs b/tests/Jellyfin.Naming.Tests/Video/MultiVersionTests.cs
index 9df6904ef..9a9a57be4 100644
--- a/tests/Jellyfin.Naming.Tests/Video/MultiVersionTests.cs
+++ b/tests/Jellyfin.Naming.Tests/Video/MultiVersionTests.cs
@@ -11,7 +11,6 @@ namespace Jellyfin.Naming.Tests.Video
     {
         private readonly NamingOptions _namingOptions = new NamingOptions();
 
-        // FIXME
         [Fact]
         public void TestMultiEdition1()
         {
@@ -23,19 +22,14 @@ namespace Jellyfin.Naming.Tests.Video
                 @"/movies/X-Men Days of Future Past/X-Men Days of Future Past [hsbs].mkv"
             };
 
-            var resolver = GetResolver();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
-
-            Assert.Single(result);
-            Assert.Single(result[0].Extras);
+            Assert.Single(result.Where(v => v.ExtraType == null));
+            Assert.Single(result.Where(v => v.ExtraType != null));
         }
 
-        // FIXME
         [Fact]
         public void TestMultiEdition2()
         {
@@ -47,16 +41,12 @@ namespace Jellyfin.Naming.Tests.Video
                 @"/movies/X-Men Days of Future Past/X-Men Days of Future Past [banana].mp4"
             };
 
-            var resolver = GetResolver();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
-
-            Assert.Single(result);
-            Assert.Single(result[0].Extras);
+            Assert.Single(result.Where(v => v.ExtraType == null));
+            Assert.Single(result.Where(v => v.ExtraType != null));
             Assert.Equal(2, result[0].AlternateVersions.Count);
         }
 
@@ -69,19 +59,14 @@ namespace Jellyfin.Naming.Tests.Video
                 @"/movies/The Phantom of the Opera (1925)/The Phantom of the Opera (1925) - 1929 version.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
             Assert.Single(result);
             Assert.Single(result[0].AlternateVersions);
         }
 
-        // FIXME
         [Fact]
         public void TestLetterFolders()
         {
@@ -96,20 +81,14 @@ namespace Jellyfin.Naming.Tests.Video
                 @"/movies/M/Movie 7.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
             Assert.Equal(7, result.Count);
-            Assert.Empty(result[0].Extras);
             Assert.Empty(result[0].AlternateVersions);
         }
 
-        // FIXME
         [Fact]
         public void TestMultiVersionLimit()
         {
@@ -125,20 +104,14 @@ namespace Jellyfin.Naming.Tests.Video
                 @"/movies/Movie/Movie-8.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
             Assert.Single(result);
-            Assert.Empty(result[0].Extras);
             Assert.Equal(7, result[0].AlternateVersions.Count);
         }
 
-        // FIXME
         [Fact]
         public void TestMultiVersionLimit2()
         {
@@ -155,20 +128,14 @@ namespace Jellyfin.Naming.Tests.Video
                 @"/movies/Mo/Movie 9.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
             Assert.Equal(9, result.Count);
-            Assert.Empty(result[0].Extras);
             Assert.Empty(result[0].AlternateVersions);
         }
 
-        // FIXME
         [Fact]
         public void TestMultiVersion3()
         {
@@ -181,20 +148,14 @@ namespace Jellyfin.Naming.Tests.Video
                 @"/movies/Movie/Movie 5.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
             Assert.Equal(5, result.Count);
-            Assert.Empty(result[0].Extras);
             Assert.Empty(result[0].AlternateVersions);
         }
 
-        // FIXME
         [Fact]
         public void TestMultiVersion4()
         {
@@ -209,16 +170,11 @@ namespace Jellyfin.Naming.Tests.Video
                 @"/movies/Iron Man/Iron Man (2011).mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
             Assert.Equal(5, result.Count);
-            Assert.Empty(result[0].Extras);
             Assert.Empty(result[0].AlternateVersions);
         }
 
@@ -237,23 +193,17 @@ namespace Jellyfin.Naming.Tests.Video
                 @"/movies/Iron Man/Iron Man[test].mkv",
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
             Assert.Single(result);
-            Assert.Empty(result[0].Extras);
             Assert.Equal(7, result[0].AlternateVersions.Count);
             Assert.False(result[0].AlternateVersions[2].Is3D);
             Assert.True(result[0].AlternateVersions[3].Is3D);
             Assert.True(result[0].AlternateVersions[4].Is3D);
         }
 
-        // FIXME
         [Fact]
         public void TestMultiVersion6()
         {
@@ -269,16 +219,11 @@ namespace Jellyfin.Naming.Tests.Video
                 @"/movies/Iron Man/Iron Man [test].mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
             Assert.Single(result);
-            Assert.Empty(result[0].Extras);
             Assert.Equal(7, result[0].AlternateVersions.Count);
             Assert.False(result[0].AlternateVersions[3].Is3D);
             Assert.True(result[0].AlternateVersions[4].Is3D);
@@ -294,13 +239,9 @@ namespace Jellyfin.Naming.Tests.Video
                 @"/movies/Iron Man/Iron Man - C (2007).mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
             Assert.Equal(2, result.Count);
         }
@@ -319,20 +260,12 @@ namespace Jellyfin.Naming.Tests.Video
                 @"/movies/Iron Man/Iron Man_3d.hsbs.mkv"
             };
 
-            var resolver = GetResolver();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
-
-            Assert.Single(result);
-            Assert.Empty(result[0].Extras);
-            Assert.Equal(6, result[0].AlternateVersions.Count);
-            Assert.False(result[0].AlternateVersions[2].Is3D);
-            Assert.True(result[0].AlternateVersions[3].Is3D);
-            Assert.True(result[0].AlternateVersions[4].Is3D);
+            Assert.Equal(7, result.Count);
+            Assert.Empty(result[0].AlternateVersions);
         }
 
         [Fact]
@@ -349,16 +282,11 @@ namespace Jellyfin.Naming.Tests.Video
                 @"/movies/Iron Man/Iron Man (2011).mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
             Assert.Equal(5, result.Count);
-            Assert.Empty(result[0].Extras);
             Assert.Empty(result[0].AlternateVersions);
         }
 
@@ -371,16 +299,11 @@ namespace Jellyfin.Naming.Tests.Video
                 @"/movies/Blade Runner (1982)/Blade Runner (1982) [EE by ADM] [480p HEVC AAC,AAC,AAC].mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
             Assert.Single(result);
-            Assert.Empty(result[0].Extras);
             Assert.Single(result[0].AlternateVersions);
         }
 
@@ -393,32 +316,53 @@ namespace Jellyfin.Naming.Tests.Video
                 @"/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) [2160p] Blu-ray.x265.AAC.mkv"
             };
 
-            var resolver = GetResolver();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
+            Assert.Single(result);
+            Assert.Single(result[0].AlternateVersions);
+        }
+
+        [Fact]
+        public void Resolve_GivenFolderNameWithBracketsAndHyphens_GroupsBasedOnFolderName()
+        {
+            var files = new[]
             {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
+                @"/movies/John Wick - Kapitel 3 (2019) [imdbid=tt6146586]/John Wick - Kapitel 3 (2019) [imdbid=tt6146586] - Version 1.mkv",
+                @"/movies/John Wick - Kapitel 3 (2019) [imdbid=tt6146586]/John Wick - Kapitel 3 (2019) [imdbid=tt6146586] - Version 2.mkv"
+            };
+
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
             Assert.Single(result);
-            Assert.Empty(result[0].Extras);
             Assert.Single(result[0].AlternateVersions);
         }
 
         [Fact]
-        public void TestEmptyList()
+        public void Resolve_GivenUnclosedBrackets_DoesNotGroup()
         {
-            var resolver = GetResolver();
+            var files = new[]
+            {
+                @"/movies/John Wick - Chapter 3 (2019)/John Wick - Chapter 3 (2019) [Version 1].mkv",
+                @"/movies/John Wick - Chapter 3 (2019)/John Wick - Chapter 3 (2019) [Version 2.mkv"
+            };
 
-            var result = resolver.Resolve(new List<FileSystemMetadata>()).ToList();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
-            Assert.Empty(result);
+            Assert.Equal(2, result.Count);
         }
 
-        private VideoListResolver GetResolver()
+        [Fact]
+        public void TestEmptyList()
         {
-            return new VideoListResolver(_namingOptions);
+            var result = VideoListResolver.Resolve(new List<VideoFileInfo>(), _namingOptions).ToList();
+
+            Assert.Empty(result);
         }
     }
 }
diff --git a/tests/Jellyfin.Naming.Tests/Video/StackTests.cs b/tests/Jellyfin.Naming.Tests/Video/StackTests.cs
index 8794d3ebe..368c3592e 100644
--- a/tests/Jellyfin.Naming.Tests/Video/StackTests.cs
+++ b/tests/Jellyfin.Naming.Tests/Video/StackTests.cs
@@ -22,9 +22,7 @@ namespace Jellyfin.Naming.Tests.Video
                 "Bad Boys (2006)-trailer.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.ResolveFiles(files).ToList();
+            var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
 
             Assert.Single(result);
             TestStackInfo(result[0], "Bad Boys (2006)", 4);
@@ -39,9 +37,7 @@ namespace Jellyfin.Naming.Tests.Video
                 "Bad Boys (2007).mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.ResolveFiles(files).ToList();
+            var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
 
             Assert.Empty(result);
         }
@@ -55,9 +51,7 @@ namespace Jellyfin.Naming.Tests.Video
                 "Bad Boys 2007.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.ResolveFiles(files).ToList();
+            var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
 
             Assert.Empty(result);
         }
@@ -71,9 +65,7 @@ namespace Jellyfin.Naming.Tests.Video
                 "300 (2007).mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.ResolveFiles(files).ToList();
+            var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
 
             Assert.Empty(result);
         }
@@ -87,9 +79,7 @@ namespace Jellyfin.Naming.Tests.Video
                 "300 2007.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.ResolveFiles(files).ToList();
+            var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
 
             Assert.Empty(result);
         }
@@ -103,9 +93,7 @@ namespace Jellyfin.Naming.Tests.Video
                 "Star Trek 2- The wrath of khan.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.ResolveFiles(files).ToList();
+            var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
             Assert.Empty(result);
         }
 
@@ -119,9 +107,7 @@ namespace Jellyfin.Naming.Tests.Video
                 "Red Riding in the Year of Our Lord 1974 (2009).mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.ResolveFiles(files).ToList();
+            var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
 
             Assert.Empty(result);
         }
@@ -135,16 +121,14 @@ namespace Jellyfin.Naming.Tests.Video
                 "d:/movies/300 2006 part2.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.ResolveFiles(files).ToList();
+            var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
 
             Assert.Single(result);
             TestStackInfo(result[0], "300 2006", 2);
         }
 
         [Fact]
-        public void TestDirtyNames()
+        public void ResolveFiles_GivenPartInMiddleOfName_ReturnsNoStack()
         {
             var files = new[]
             {
@@ -155,16 +139,13 @@ namespace Jellyfin.Naming.Tests.Video
                 "Bad Boys (2006)-trailer.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.ResolveFiles(files).ToList();
+            var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
 
-            Assert.Single(result);
-            TestStackInfo(result[0], "Bad Boys (2006).stv.unrated.multi.1080p.bluray.x264-rough", 4);
+            Assert.Empty(result);
         }
 
         [Fact]
-        public void TestNumberedFiles()
+        public void ResolveFiles_FileNamesWithMissingPartType_ReturnsNoStack()
         {
             var files = new[]
             {
@@ -175,9 +156,7 @@ namespace Jellyfin.Naming.Tests.Video
                 "Bad Boys (2006)-trailer.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.ResolveFiles(files).ToList();
+            var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
 
             Assert.Empty(result);
         }
@@ -194,9 +173,7 @@ namespace Jellyfin.Naming.Tests.Video
                 "300 (2006)-trailer.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.ResolveFiles(files).ToList();
+            var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
 
             Assert.Single(result);
             TestStackInfo(result[0], "300 (2006)", 4);
@@ -214,9 +191,7 @@ namespace Jellyfin.Naming.Tests.Video
                 "Bad Boys (2006)-trailer.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.ResolveFiles(files).ToList();
+            var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
 
             Assert.Single(result);
             TestStackInfo(result[0], "Bad Boys (2006)", 3);
@@ -238,9 +213,7 @@ namespace Jellyfin.Naming.Tests.Video
                 "300 (2006)-trailer.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.ResolveFiles(files).ToList();
+            var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
 
             Assert.Equal(2, result.Count);
             TestStackInfo(result[1], "Bad Boys (2006)", 4);
@@ -256,9 +229,7 @@ namespace Jellyfin.Naming.Tests.Video
                 "blah blah - cd 2"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.ResolveDirectories(files).ToList();
+            var result = StackResolver.ResolveDirectories(files, _namingOptions).ToList();
 
             Assert.Single(result);
             TestStackInfo(result[0], "blah blah", 2);
@@ -275,9 +246,7 @@ namespace Jellyfin.Naming.Tests.Video
                 "300-trailer.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.ResolveFiles(files).ToList();
+            var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
 
             Assert.Single(result);
 
@@ -297,9 +266,7 @@ namespace Jellyfin.Naming.Tests.Video
                 "Avengers part3.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.ResolveFiles(files).ToList();
+            var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
 
             Assert.Equal(2, result.Count);
 
@@ -328,9 +295,7 @@ namespace Jellyfin.Naming.Tests.Video
                 "300-trailer.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.ResolveFiles(files).ToList();
+            var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
 
             Assert.Equal(3, result.Count);
 
@@ -354,9 +319,7 @@ namespace Jellyfin.Naming.Tests.Video
                 "300 (2006)-trailer.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.ResolveFiles(files).ToList();
+            var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
 
             Assert.Single(result);
 
@@ -375,9 +338,7 @@ namespace Jellyfin.Naming.Tests.Video
                 new FileSystemMetadata { FullName = "300 (2006) part1", IsDirectory = true }
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files).ToList();
+            var result = StackResolver.Resolve(files, _namingOptions).ToList();
 
             Assert.Equal(2, result.Count);
             TestStackInfo(result[0], "300 (2006)", 3);
@@ -397,9 +358,7 @@ namespace Jellyfin.Naming.Tests.Video
                 "Harry Potter and the Deathly Hallows 4.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.ResolveFiles(files).ToList();
+            var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
 
             Assert.Empty(result);
         }
@@ -414,9 +373,7 @@ namespace Jellyfin.Naming.Tests.Video
                 "Neverland (2011)[720p][PG][Voted 6.5][Family-Fantasy]part2.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.ResolveFiles(files).ToList();
+            var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
 
             Assert.Single(result);
             Assert.Equal(2, result[0].Files.Count);
@@ -432,9 +389,7 @@ namespace Jellyfin.Naming.Tests.Video
                 @"M:/Movies (DVD)/Movies (Musical)/The Sound of Music/The Sound of Music (1965) (Disc 02)"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.ResolveDirectories(files).ToList();
+            var result = StackResolver.ResolveDirectories(files, _namingOptions).ToList();
 
             Assert.Single(result);
             Assert.Equal(2, result[0].Files.Count);
@@ -445,10 +400,5 @@ namespace Jellyfin.Naming.Tests.Video
             Assert.Equal(fileCount, stack.Files.Count);
             Assert.Equal(name, stack.Name);
         }
-
-        private StackResolver GetResolver()
-        {
-            return new StackResolver(_namingOptions);
-        }
     }
 }
diff --git a/tests/Jellyfin.Naming.Tests/Video/StubTests.cs b/tests/Jellyfin.Naming.Tests/Video/StubTests.cs
index 6e759c6d6..1d50df7a6 100644
--- a/tests/Jellyfin.Naming.Tests/Video/StubTests.cs
+++ b/tests/Jellyfin.Naming.Tests/Video/StubTests.cs
@@ -29,8 +29,7 @@ namespace Jellyfin.Naming.Tests.Video
         [Fact]
         public void TestStubName()
         {
-            var result =
-                new VideoResolver(_namingOptions).ResolveFile(@"C:/Users/media/Desktop/Video Test/Movies/Oblivion/Oblivion.dvd.disc");
+            var result = VideoResolver.ResolveFile(@"C:/Users/media/Desktop/Video Test/Movies/Oblivion/Oblivion.dvd.disc", _namingOptions);
 
             Assert.Equal("Oblivion", result?.Name);
         }
diff --git a/tests/Jellyfin.Naming.Tests/Video/VideoListResolverTests.cs b/tests/Jellyfin.Naming.Tests/Video/VideoListResolverTests.cs
index 215c7e540..b76187842 100644
--- a/tests/Jellyfin.Naming.Tests/Video/VideoListResolverTests.cs
+++ b/tests/Jellyfin.Naming.Tests/Video/VideoListResolverTests.cs
@@ -1,6 +1,8 @@
+using System;
 using System.Linq;
 using Emby.Naming.Common;
 using Emby.Naming.Video;
+using MediaBrowser.Model.Entities;
 using MediaBrowser.Model.IO;
 using Xunit;
 
@@ -10,9 +12,8 @@ namespace Jellyfin.Naming.Tests.Video
     {
         private readonly NamingOptions _namingOptions = new NamingOptions();
 
-        // FIXME
-        // [Fact]
-        private void TestStackAndExtras()
+        [Fact]
+        public void TestStackAndExtras()
         {
             // No stacking here because there is no part/disc/etc
             var files = new[]
@@ -40,23 +41,29 @@ namespace Jellyfin.Naming.Tests.Video
                 "WillyWonka-trailer.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
-
-            Assert.Equal(5, result.Count);
-
-            Assert.Equal(3, result[1].Files.Count);
-            Assert.Equal(3, result[1].Extras.Count);
-            Assert.Equal("Batman", result[1].Name);
-
-            Assert.Equal(4, result[2].Files.Count);
-            Assert.Equal(2, result[2].Extras.Count);
-            Assert.Equal("Harry Potter and the Deathly Hallows", result[2].Name);
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
+
+            Assert.Equal(11, result.Count);
+            var batman = result.FirstOrDefault(x => string.Equals(x.Name, "Batman", StringComparison.Ordinal));
+            Assert.NotNull(batman);
+            Assert.Equal(3, batman!.Files.Count);
+
+            var harry = result.FirstOrDefault(x => string.Equals(x.Name, "Harry Potter and the Deathly Hallows", StringComparison.Ordinal));
+            Assert.NotNull(harry);
+            Assert.Equal(4, harry!.Files.Count);
+
+            Assert.False(result[2].ExtraType.HasValue);
+
+            Assert.Equal(ExtraType.Trailer, result[3].ExtraType);
+            Assert.Equal(ExtraType.Trailer, result[4].ExtraType);
+            Assert.Equal(ExtraType.DeletedScene, result[5].ExtraType);
+            Assert.Equal(ExtraType.Sample, result[6].ExtraType);
+            Assert.Equal(ExtraType.Trailer, result[7].ExtraType);
+            Assert.Equal(ExtraType.Trailer, result[8].ExtraType);
+            Assert.Equal(ExtraType.Trailer, result[9].ExtraType);
+            Assert.Equal(ExtraType.Trailer, result[10].ExtraType);
         }
 
         [Fact]
@@ -68,13 +75,9 @@ namespace Jellyfin.Naming.Tests.Video
                 "300.nfo"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
             Assert.Single(result);
         }
@@ -88,15 +91,13 @@ namespace Jellyfin.Naming.Tests.Video
                 "300 trailer.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
-            Assert.Single(result);
+            Assert.Equal(2, result.Count);
+            Assert.False(result[0].ExtraType.HasValue);
+            Assert.Equal(ExtraType.Trailer, result[1].ExtraType);
         }
 
         [Fact]
@@ -108,15 +109,13 @@ namespace Jellyfin.Naming.Tests.Video
                 "X-Men Days of Future Past-trailer.mp4"
             };
 
-            var resolver = GetResolver();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
-
-            Assert.Single(result);
+            Assert.Equal(2, result.Count);
+            Assert.False(result[0].ExtraType.HasValue);
+            Assert.Equal(ExtraType.Trailer, result[1].ExtraType);
         }
 
         [Fact]
@@ -129,35 +128,52 @@ namespace Jellyfin.Naming.Tests.Video
                 "X-Men Days of Future Past-trailer2.mp4"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
-            Assert.Single(result);
+            Assert.Equal(3, result.Count);
+            Assert.False(result[0].ExtraType.HasValue);
+            Assert.Equal(ExtraType.Trailer, result[1].ExtraType);
+            Assert.Equal(ExtraType.Trailer, result[2].ExtraType);
         }
 
         [Fact]
-        public void TestDifferentNames()
+        public void Resolve_SameNameAndYear_ReturnsSingleItem()
         {
             var files = new[]
             {
                 "Looper (2012)-trailer.mkv",
+                "Looper 2012-trailer.mkv",
                 "Looper.2012.bluray.720p.x264.mkv"
             };
 
-            var resolver = GetResolver();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
+            Assert.Equal(3, result.Count);
+            Assert.False(result[0].ExtraType.HasValue);
+            Assert.Equal(ExtraType.Trailer, result[1].ExtraType);
+            Assert.Equal(ExtraType.Trailer, result[2].ExtraType);
+        }
+
+        [Fact]
+        public void Resolve_TrailerMatchesFolderName_ReturnsSingleItem()
+        {
+            var files = new[]
             {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
+                "/movies/Looper (2012)/Looper (2012)-trailer.mkv",
+                "/movies/Looper (2012)/Looper.bluray.720p.x264.mkv"
+            };
 
-            Assert.Single(result);
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
+
+            Assert.Equal(2, result.Count);
+            Assert.False(result[0].ExtraType.HasValue);
+            Assert.Equal(ExtraType.Trailer, result[1].ExtraType);
         }
 
         [Fact]
@@ -173,13 +189,9 @@ namespace Jellyfin.Naming.Tests.Video
                 "My video 5.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
             Assert.Equal(5, result.Count);
         }
@@ -193,13 +205,9 @@ namespace Jellyfin.Naming.Tests.Video
                 @"M:/Movies (DVD)/Movies (Musical)/Sound of Music (1965)/Sound of Music Disc 2"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = true,
-                FullName = i
-            }).ToList()).ToList();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, true, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
             Assert.Single(result);
         }
@@ -214,13 +222,9 @@ namespace Jellyfin.Naming.Tests.Video
                 @"My movie #2.mp4"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = true,
-                FullName = i
-            }).ToList()).ToList();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, true, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
             Assert.Equal(2, result.Count);
         }
@@ -232,39 +236,18 @@ namespace Jellyfin.Naming.Tests.Video
             {
                 @"No (2012) part1.mp4",
                 @"No (2012) part2.mp4",
-                @"No (2012) part1-trailer.mp4"
-            };
-
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
-
-            Assert.Single(result);
-        }
-
-        [Fact]
-        public void TestStackedWithTrailer2()
-        {
-            var files = new[]
-            {
-                @"No (2012) part1.mp4",
-                @"No (2012) part2.mp4",
+                @"No (2012) part1-trailer.mp4",
                 @"No (2012)-trailer.mp4"
             };
 
-            var resolver = GetResolver();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
-
-            Assert.Single(result);
+            Assert.Equal(3, result.Count);
+            Assert.False(result[0].ExtraType.HasValue);
+            Assert.Equal(ExtraType.Trailer, result[1].ExtraType);
+            Assert.Equal(ExtraType.Trailer, result[2].ExtraType);
         }
 
         [Fact]
@@ -275,18 +258,18 @@ namespace Jellyfin.Naming.Tests.Video
                 @"/Movies/Top Gun (1984)/movie.mp4",
                 @"/Movies/Top Gun (1984)/Top Gun (1984)-trailer.mp4",
                 @"/Movies/Top Gun (1984)/Top Gun (1984)-trailer2.mp4",
-                @"trailer.mp4"
+                @"/Movies/trailer.mp4"
             };
 
-            var resolver = GetResolver();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
-
-            Assert.Single(result);
+            Assert.Equal(4, result.Count);
+            Assert.False(result[0].ExtraType.HasValue);
+            Assert.Equal(ExtraType.Trailer, result[1].ExtraType);
+            Assert.Equal(ExtraType.Trailer, result[2].ExtraType);
+            Assert.Equal(ExtraType.Trailer, result[3].ExtraType);
         }
 
         [Fact]
@@ -300,13 +283,9 @@ namespace Jellyfin.Naming.Tests.Video
                 @"/MCFAMILY-PC/Private3$/Heterosexual/Breast In Class 2 Counterfeit Racks (2011)/Breast In Class 2 Disc 2 cd2.avi"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
             Assert.Equal(2, result.Count);
         }
@@ -319,13 +298,9 @@ namespace Jellyfin.Naming.Tests.Video
                 @"/nas-markrobbo78/Videos/INDEX HTPC/Movies/Watched/3 - ACTION/Argo (2012)/movie.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
             Assert.Single(result);
         }
@@ -338,13 +313,9 @@ namespace Jellyfin.Naming.Tests.Video
                 @"The Colony.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
             Assert.Single(result);
         }
@@ -358,13 +329,9 @@ namespace Jellyfin.Naming.Tests.Video
                 @"Four Sisters and a Wedding - B.avi"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
             Assert.Single(result);
         }
@@ -378,13 +345,9 @@ namespace Jellyfin.Naming.Tests.Video
                 @"Four Rooms - A.mp4"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
             Assert.Equal(2, result.Count);
         }
@@ -395,40 +358,34 @@ namespace Jellyfin.Naming.Tests.Video
             var files = new[]
             {
                 @"/Server/Despicable Me/Despicable Me (2010).mkv",
-                @"/Server/Despicable Me/movie-trailer.mkv"
+                @"/Server/Despicable Me/trailer.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
-            Assert.Single(result);
+            Assert.Equal(2, result.Count);
+            Assert.False(result[0].ExtraType.HasValue);
+            Assert.Equal(ExtraType.Trailer, result[1].ExtraType);
         }
 
         [Fact]
-        public void TestTrailerFalsePositives()
+        public void Resolve_TrailerInTrailersFolder_ReturnsCorrectExtraType()
         {
             var files = new[]
             {
-                @"/Server/Despicable Me/Skyscraper (2018) - Big Game Spot.mkv",
-                @"/Server/Despicable Me/Skyscraper (2018) - Trailer.mkv",
-                @"/Server/Despicable Me/Baywatch (2017) - Big Game Spot.mkv",
-                @"/Server/Despicable Me/Baywatch (2017) - Trailer.mkv"
+                @"/Server/Despicable Me/Despicable Me (2010).mkv",
+                @"/Server/Despicable Me/trailers/some title.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
-            Assert.Equal(4, result.Count);
+            Assert.Equal(2, result.Count);
+            Assert.False(result[0].ExtraType.HasValue);
+            Assert.Equal(ExtraType.Trailer, result[1].ExtraType);
         }
 
         [Fact]
@@ -440,27 +397,20 @@ namespace Jellyfin.Naming.Tests.Video
                 @"/Movies/Despicable Me/trailers/trailer.mkv"
             };
 
-            var resolver = GetResolver();
-
-            var result = resolver.Resolve(files.Select(i => new FileSystemMetadata
-            {
-                IsDirectory = false,
-                FullName = i
-            }).ToList()).ToList();
+            var result = VideoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                _namingOptions).ToList();
 
-            Assert.Single(result);
+            Assert.Equal(2, result.Count);
+            Assert.False(result[0].ExtraType.HasValue);
+            Assert.Equal(ExtraType.Trailer, result[1].ExtraType);
         }
 
         [Fact]
         public void TestDirectoryStack()
         {
-            var stack = new FileStack();
+            var stack = new FileStack(string.Empty, false, Array.Empty<string>());
             Assert.False(stack.ContainsFile("XX", true));
         }
-
-        private VideoListResolver GetResolver()
-        {
-            return new VideoListResolver(_namingOptions);
-        }
     }
 }
diff --git a/tests/Jellyfin.Naming.Tests/Video/VideoResolverTests.cs b/tests/Jellyfin.Naming.Tests/Video/VideoResolverTests.cs
index b6447a7a6..33a99e107 100644
--- a/tests/Jellyfin.Naming.Tests/Video/VideoResolverTests.cs
+++ b/tests/Jellyfin.Naming.Tests/Video/VideoResolverTests.cs
@@ -1,4 +1,3 @@
-using System.Collections.Generic;
 using System.Linq;
 using Emby.Naming.Common;
 using Emby.Naming.Video;
@@ -9,177 +8,163 @@ namespace Jellyfin.Naming.Tests.Video
 {
     public class VideoResolverTests
     {
-        private readonly NamingOptions _namingOptions = new NamingOptions();
+        private static NamingOptions _namingOptions = new NamingOptions();
 
-        public static IEnumerable<object[]> GetResolveFileTestData()
+        public static TheoryData<VideoFileInfo> ResolveFile_ValidFileNameTestData()
         {
-            yield return new object[]
-            {
+            var data = new TheoryData<VideoFileInfo>();
+            data.Add(
                 new VideoFileInfo(
                     path: @"/server/Movies/7 Psychos.mkv/7 Psychos.mkv",
                     container: "mkv",
-                    name: "7 Psychos")
-            };
-            yield return new object[]
-            {
+                    name: "7 Psychos"));
+
+            data.Add(
                 new VideoFileInfo(
                     path: @"/server/Movies/3 days to kill (2005)/3 days to kill (2005).mkv",
                     container: "mkv",
                     name: "3 days to kill",
-                    year: 2005)
-            };
-            yield return new object[]
-            {
+                    year: 2005));
+
+            data.Add(
                 new VideoFileInfo(
                     path: @"/server/Movies/American Psycho/American.Psycho.mkv",
                     container: "mkv",
-                    name: "American.Psycho")
-            };
-            yield return new object[]
-            {
+                    name: "American.Psycho"));
+
+            data.Add(
                 new VideoFileInfo(
                     path: @"/server/Movies/brave (2007)/brave (2006).3d.sbs.mkv",
                     container: "mkv",
                     name: "brave",
                     year: 2006,
                     is3D: true,
-                    format3D: "sbs")
-            };
-            yield return new object[]
-            {
+                    format3D: "sbs"));
+
+            data.Add(
                 new VideoFileInfo(
                     path: @"/server/Movies/300 (2007)/300 (2006).3d1.sbas.mkv",
                     container: "mkv",
                     name: "300",
-                    year: 2006)
-            };
-            yield return new object[]
-            {
+                    year: 2006));
+
+            data.Add(
                 new VideoFileInfo(
                     path: @"/server/Movies/300 (2007)/300 (2006).3d.sbs.mkv",
                     container: "mkv",
                     name: "300",
                     year: 2006,
                     is3D: true,
-                    format3D: "sbs")
-            };
-            yield return new object[]
-            {
+                    format3D: "sbs"));
+
+            data.Add(
                 new VideoFileInfo(
                     path: @"/server/Movies/brave (2007)/brave (2006)-trailer.bluray.disc",
                     container: "disc",
                     name: "brave",
                     year: 2006,
                     isStub: true,
-                    stubType: "bluray")
-            };
-            yield return new object[]
-            {
+                    stubType: "bluray"));
+
+            data.Add(
                 new VideoFileInfo(
                     path: @"/server/Movies/300 (2007)/300 (2006)-trailer.bluray.disc",
                     container: "disc",
                     name: "300",
                     year: 2006,
                     isStub: true,
-                    stubType: "bluray")
-            };
-            yield return new object[]
-            {
+                    stubType: "bluray"));
+
+            data.Add(
                 new VideoFileInfo(
                     path: @"/server/Movies/Brave (2007)/Brave (2006).bluray.disc",
                     container: "disc",
                     name: "Brave",
                     year: 2006,
                     isStub: true,
-                    stubType: "bluray")
-            };
-            yield return new object[]
-            {
+                    stubType: "bluray"));
+
+            data.Add(
                 new VideoFileInfo(
                     path: @"/server/Movies/300 (2007)/300 (2006).bluray.disc",
                     container: "disc",
                     name: "300",
                     year: 2006,
                     isStub: true,
-                    stubType: "bluray")
-            };
-            yield return new object[]
-            {
+                    stubType: "bluray"));
+
+            data.Add(
                 new VideoFileInfo(
                     path: @"/server/Movies/300 (2007)/300 (2006)-trailer.mkv",
                     container: "mkv",
                     name: "300",
                     year: 2006,
-                    extraType: ExtraType.Trailer)
-            };
-            yield return new object[]
-            {
+                    extraType: ExtraType.Trailer));
+
+            data.Add(
                 new VideoFileInfo(
                     path: @"/server/Movies/Brave (2007)/Brave (2006)-trailer.mkv",
                     container: "mkv",
                     name: "Brave",
                     year: 2006,
-                    extraType: ExtraType.Trailer)
-            };
-            yield return new object[]
-            {
+                    extraType: ExtraType.Trailer));
+
+            data.Add(
                 new VideoFileInfo(
                     path: @"/server/Movies/300 (2007)/300 (2006).mkv",
                     container: "mkv",
                     name: "300",
-                    year: 2006)
-            };
-            yield return new object[]
-            {
+                    year: 2006));
+
+            data.Add(
                 new VideoFileInfo(
                     path: @"/server/Movies/Bad Boys (1995)/Bad Boys (1995).mkv",
                     container: "mkv",
                     name: "Bad Boys",
-                    year: 1995)
-            };
-            yield return new object[]
-            {
+                    year: 1995));
+
+            data.Add(
                 new VideoFileInfo(
                     path: @"/server/Movies/Brave (2007)/Brave (2006).mkv",
                     container: "mkv",
                     name: "Brave",
-                    year: 2006)
-            };
-            yield return new object[]
-            {
+                    year: 2006));
+
+            data.Add(
                 new VideoFileInfo(
-                    path: @"/server/Movies/Rain Man 1988 REMASTERED 1080p BluRay x264 AAC - Ozlem/Rain Man 1988 REMASTERED 1080p BluRay x264 AAC - Ozlem.mp4",
+                    path: @"/server/Movies/Rain Man 1988 REMASTERED 1080p BluRay x264 AAC - JEFF/Rain Man 1988 REMASTERED 1080p BluRay x264 AAC - JEFF.mp4",
                     container: "mp4",
                     name: "Rain Man",
-                    year: 1988)
-            };
+                    year: 1988));
+
+            return data;
         }
 
         [Theory]
-        [MemberData(nameof(GetResolveFileTestData))]
+        [MemberData(nameof(ResolveFile_ValidFileNameTestData))]
         public void ResolveFile_ValidFileName_Success(VideoFileInfo expectedResult)
         {
-            var result = new VideoResolver(_namingOptions).ResolveFile(expectedResult.Path);
+            var result = VideoResolver.ResolveFile(expectedResult.Path, _namingOptions);
 
             Assert.NotNull(result);
-            Assert.Equal(result?.Path, expectedResult.Path);
-            Assert.Equal(result?.Container, expectedResult.Container);
-            Assert.Equal(result?.Name, expectedResult.Name);
-            Assert.Equal(result?.Year, expectedResult.Year);
-            Assert.Equal(result?.ExtraType, expectedResult.ExtraType);
-            Assert.Equal(result?.Format3D, expectedResult.Format3D);
-            Assert.Equal(result?.Is3D, expectedResult.Is3D);
-            Assert.Equal(result?.IsStub, expectedResult.IsStub);
-            Assert.Equal(result?.StubType, expectedResult.StubType);
-            Assert.Equal(result?.IsDirectory, expectedResult.IsDirectory);
-            Assert.Equal(result?.FileNameWithoutExtension, expectedResult.FileNameWithoutExtension);
-            Assert.Equal(result?.ToString(), expectedResult.ToString());
+            Assert.Equal(result!.Path, expectedResult.Path);
+            Assert.Equal(result.Container, expectedResult.Container);
+            Assert.Equal(result.Name, expectedResult.Name);
+            Assert.Equal(result.Year, expectedResult.Year);
+            Assert.Equal(result.ExtraType, expectedResult.ExtraType);
+            Assert.Equal(result.Format3D, expectedResult.Format3D);
+            Assert.Equal(result.Is3D, expectedResult.Is3D);
+            Assert.Equal(result.IsStub, expectedResult.IsStub);
+            Assert.Equal(result.StubType, expectedResult.StubType);
+            Assert.Equal(result.IsDirectory, expectedResult.IsDirectory);
+            Assert.Equal(result.FileNameWithoutExtension.ToString(), expectedResult.FileNameWithoutExtension.ToString());
+            Assert.Equal(result.ToString(), expectedResult.ToString());
         }
 
         [Fact]
         public void ResolveFile_EmptyPath()
         {
-            var result = new VideoResolver(_namingOptions).ResolveFile(string.Empty);
+            var result = VideoResolver.ResolveFile(string.Empty, _namingOptions);
 
             Assert.Null(result);
         }
@@ -194,13 +179,16 @@ namespace Jellyfin.Naming.Tests.Video
                 string.Empty
             };
 
-            var resolver = new VideoResolver(_namingOptions);
-            var results = paths.Select(path => resolver.ResolveDirectory(path)).ToList();
+            var results = paths.Select(path => VideoResolver.ResolveDirectory(path, _namingOptions)).ToList();
 
             Assert.Equal(3, results.Count);
             Assert.NotNull(results[0]);
             Assert.NotNull(results[1]);
             Assert.Null(results[2]);
+            foreach (var result in results)
+            {
+                Assert.Null(result?.Container);
+            }
         }
     }
 }
diff --git a/tests/Jellyfin.Networking.Tests/IPHostTests.cs b/tests/Jellyfin.Networking.Tests/IPHostTests.cs
new file mode 100644
index 000000000..ec3a1300c
--- /dev/null
+++ b/tests/Jellyfin.Networking.Tests/IPHostTests.cs
@@ -0,0 +1,53 @@
+using FsCheck;
+using FsCheck.Xunit;
+using MediaBrowser.Common.Net;
+using Xunit;
+
+namespace Jellyfin.Networking.Tests
+{
+    public static class IPHostTests
+    {
+        /// <summary>
+        /// Checks IP address formats.
+        /// </summary>
+        /// <param name="address">IP Address.</param>
+        [Theory]
+        [InlineData("127.0.0.1")]
+        [InlineData("127.0.0.1:123")]
+        [InlineData("localhost")]
+        [InlineData("localhost:1345")]
+        [InlineData("www.google.co.uk")]
+        [InlineData("fd23:184f:2029:0:3139:7386:67d7:d517")]
+        [InlineData("fd23:184f:2029:0:3139:7386:67d7:d517/56")]
+        [InlineData("[fd23:184f:2029:0:3139:7386:67d7:d517]:124")]
+        [InlineData("fe80::7add:12ff:febb:c67b%16")]
+        [InlineData("[fe80::7add:12ff:febb:c67b%16]:123")]
+        [InlineData("fe80::7add:12ff:febb:c67b%16:123")]
+        [InlineData("[fe80::7add:12ff:febb:c67b%16]")]
+        [InlineData("192.168.1.2/255.255.255.0")]
+        [InlineData("192.168.1.2/24")]
+        public static void TryParse_ValidHostStrings_True(string address)
+            => Assert.True(IPHost.TryParse(address, out _));
+
+        [Property]
+        public static Property TryParse_IPv4Address_True(IPv4Address address)
+            => IPHost.TryParse(address.Item.ToString(), out _).ToProperty();
+
+        [Property]
+        public static Property TryParse_IPv6Address_True(IPv6Address address)
+            => IPHost.TryParse(address.Item.ToString(), out _).ToProperty();
+
+        /// <summary>
+        /// All should be invalid address strings.
+        /// </summary>
+        /// <param name="address">Invalid address strings.</param>
+        [Theory]
+        [InlineData("256.128.0.0.0.1")]
+        [InlineData("127.0.0.1#")]
+        [InlineData("localhost!")]
+        [InlineData("fd23:184f:2029:0:3139:7386:67d7:d517:1231")]
+        [InlineData("[fd23:184f:2029:0:3139:7386:67d7:d517:1231]")]
+        public static void TryParse_InvalidAddressString_False(string address)
+            => Assert.False(IPHost.TryParse(address, out _));
+    }
+}
diff --git a/tests/Jellyfin.Networking.Tests/IPNetAddressTests.cs b/tests/Jellyfin.Networking.Tests/IPNetAddressTests.cs
new file mode 100644
index 000000000..aa2dbc57a
--- /dev/null
+++ b/tests/Jellyfin.Networking.Tests/IPNetAddressTests.cs
@@ -0,0 +1,49 @@
+using FsCheck;
+using FsCheck.Xunit;
+using MediaBrowser.Common.Net;
+using Xunit;
+
+namespace Jellyfin.Networking.Tests
+{
+    public static class IPNetAddressTests
+    {
+        /// <summary>
+        /// Checks IP address formats.
+        /// </summary>
+        /// <param name="address">IP Address.</param>
+        [Theory]
+        [InlineData("127.0.0.1")]
+        [InlineData("fd23:184f:2029:0:3139:7386:67d7:d517")]
+        [InlineData("fd23:184f:2029:0:3139:7386:67d7:d517/56")]
+        [InlineData("[fd23:184f:2029:0:3139:7386:67d7:d517]")]
+        [InlineData("fe80::7add:12ff:febb:c67b%16")]
+        [InlineData("[fe80::7add:12ff:febb:c67b%16]:123")]
+        [InlineData("fe80::7add:12ff:febb:c67b%16:123")]
+        [InlineData("[fe80::7add:12ff:febb:c67b%16]")]
+        [InlineData("192.168.1.2/255.255.255.0")]
+        [InlineData("192.168.1.2/24")]
+        public static void TryParse_ValidIPStrings_True(string address)
+            => Assert.True(IPNetAddress.TryParse(address, out _));
+
+        [Property]
+        public static Property TryParse_IPv4Address_True(IPv4Address address)
+            => IPNetAddress.TryParse(address.Item.ToString(), out _).ToProperty();
+
+        [Property]
+        public static Property TryParse_IPv6Address_True(IPv6Address address)
+            => IPNetAddress.TryParse(address.Item.ToString(), out _).ToProperty();
+
+        /// <summary>
+        /// All should be invalid address strings.
+        /// </summary>
+        /// <param name="address">Invalid address strings.</param>
+        [Theory]
+        [InlineData("256.128.0.0.0.1")]
+        [InlineData("127.0.0.1#")]
+        [InlineData("localhost!")]
+        [InlineData("fd23:184f:2029:0:3139:7386:67d7:d517:1231")]
+        [InlineData("[fd23:184f:2029:0:3139:7386:67d7:d517:1231]")]
+        public static void TryParse_InvalidAddressString_False(string address)
+            => Assert.False(IPNetAddress.TryParse(address, out _));
+    }
+}
diff --git a/tests/Jellyfin.Networking.Tests/NetworkTesting/Jellyfin.Networking.Tests.csproj b/tests/Jellyfin.Networking.Tests/Jellyfin.Networking.Tests.csproj
index 8d9c20de1..78556ee67 100644
--- a/tests/Jellyfin.Networking.Tests/NetworkTesting/Jellyfin.Networking.Tests.csproj
+++ b/tests/Jellyfin.Networking.Tests/Jellyfin.Networking.Tests.csproj
@@ -6,34 +6,34 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
     <IsPackable>false</IsPackable>
-    <Nullable>enable</Nullable>
-    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <CodeAnalysisRuleSet>../jellyfin-tests.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1" />
-    <PackageReference Include="coverlet.collector" Version="3.0.0" />
-    <PackageReference Include="Moq" Version="4.15.2" />
+    <PackageReference Include="coverlet.collector" Version="3.1.0" />
+    <PackageReference Include="FsCheck.Xunit" Version="2.16.3" />
+    <PackageReference Include="Moq" Version="4.16.1" />
   </ItemGroup>
 
   <!-- Code Analyzers-->
   <ItemGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="2.9.8" PrivateAssets="All" />
     <PackageReference Include="SerilogAnalyzer" Version="0.15.0" PrivateAssets="All" />
+    <PackageReference Include="StyleCop.Analyzers" Version="1.1.118" PrivateAssets="All" />
     <PackageReference Include="SmartAnalyzers.MultithreadingAnalyzer" Version="1.1.31" PrivateAssets="All" />
   </ItemGroup>
+
   <ItemGroup>
-    <ProjectReference Include="..\..\..\Emby.Server.Implementations\Emby.Server.Implementations.csproj" />
-    <ProjectReference Include="..\..\..\MediaBrowser.Common\MediaBrowser.Common.csproj" />
+    <ProjectReference Include="../../Emby.Server.Implementations/Emby.Server.Implementations.csproj" />
+    <ProjectReference Include="../../MediaBrowser.Common/MediaBrowser.Common.csproj" />
   </ItemGroup>
-  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <CodeAnalysisRuleSet>../../jellyfin-tests.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
+
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
     <DefineConstants>DEBUG</DefineConstants>
   </PropertyGroup>
+
 </Project>
diff --git a/tests/Jellyfin.Networking.Tests/NetworkManagerTests.cs b/tests/Jellyfin.Networking.Tests/NetworkManagerTests.cs
new file mode 100644
index 000000000..61f913252
--- /dev/null
+++ b/tests/Jellyfin.Networking.Tests/NetworkManagerTests.cs
@@ -0,0 +1,63 @@
+using System.Net;
+using Jellyfin.Networking.Configuration;
+using Jellyfin.Networking.Manager;
+using Microsoft.Extensions.Logging.Abstractions;
+using Xunit;
+
+namespace Jellyfin.Networking.Tests
+{
+    public class NetworkManagerTests
+    {
+        /// <summary>
+        /// Checks that the given IP address is in the specified network(s).
+        /// </summary>
+        /// <param name="network">Network address(es).</param>
+        /// <param name="value">The IP to check.</param>
+        [Theory]
+        [InlineData("192.168.2.1/24", "192.168.2.123")]
+        [InlineData("192.168.2.1/24, !192.168.2.122/32", "192.168.2.123")]
+        [InlineData("fd23:184f:2029:0::/56", "fd23:184f:2029:0:3139:7386:67d7:d517")]
+        [InlineData("fd23:184f:2029:0::/56, !fd23:184f:2029:0:3139:7386:67d7:d518/128", "fd23:184f:2029:0:3139:7386:67d7:d517")]
+        public void InNetwork_True_Success(string network, string value)
+        {
+            var ip = IPAddress.Parse(value);
+            var conf = new NetworkConfiguration()
+            {
+                EnableIPV6 = true,
+                EnableIPV4 = true,
+                LocalNetworkSubnets = network.Split(',')
+            };
+
+            using var networkManager = new NetworkManager(NetworkParseTests.GetMockConfig(conf), new NullLogger<NetworkManager>());
+
+            Assert.True(networkManager.IsInLocalNetwork(ip));
+        }
+
+        /// <summary>
+        /// Checks that the given IP address is not in the network provided.
+        /// </summary>
+        /// <param name="network">Network address(es).</param>
+        /// <param name="value">The IP to check.</param>
+        [Theory]
+        [InlineData("192.168.10.0/24", "192.168.11.1")]
+        [InlineData("192.168.10.0/24, !192.168.10.60/32", "192.168.10.60")]
+        [InlineData("192.168.10.0/24", "fd23:184f:2029:0:3139:7386:67d7:d517")]
+        [InlineData("fd23:184f:2029:0::/56", "fd24:184f:2029:0:3139:7386:67d7:d517")]
+        [InlineData("fd23:184f:2029:0::/56, !fd23:184f:2029:0:3139:7386:67d7:d500/120", "fd23:184f:2029:0:3139:7386:67d7:d517")]
+        [InlineData("fd23:184f:2029:0::/56", "192.168.10.60")]
+        public void InNetwork_False_Success(string network, string value)
+        {
+            var ip = IPAddress.Parse(value);
+            var conf = new NetworkConfiguration()
+            {
+                EnableIPV6 = true,
+                EnableIPV4 = true,
+                LocalNetworkSubnets = network.Split(',')
+            };
+
+            using var nm = new NetworkManager(NetworkParseTests.GetMockConfig(conf), new NullLogger<NetworkManager>());
+
+            Assert.False(nm.IsInLocalNetwork(ip));
+        }
+    }
+}
diff --git a/tests/Jellyfin.Networking.Tests/NetworkTesting/NetworkParseTests.cs b/tests/Jellyfin.Networking.Tests/NetworkParseTests.cs
index c350685af..6b9397437 100644
--- a/tests/Jellyfin.Networking.Tests/NetworkTesting/NetworkParseTests.cs
+++ b/tests/Jellyfin.Networking.Tests/NetworkParseTests.cs
@@ -1,66 +1,45 @@
 using System;
+using System.Collections.ObjectModel;
 using System.Net;
 using Jellyfin.Networking.Configuration;
 using Jellyfin.Networking.Manager;
 using MediaBrowser.Common.Configuration;
 using MediaBrowser.Common.Net;
-using Moq;
 using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
 using Xunit;
-using System.Collections.ObjectModel;
 
 namespace Jellyfin.Networking.Tests
 {
     public class NetworkParseTests
     {
-        /// <summary>
-        /// Tries to identify the string and return an object of that class.
-        /// </summary>
-        /// <param name="addr">String to parse.</param>
-        /// <param name="result">IPObject to return.</param>
-        /// <returns>True if the value parsed successfully.</returns>
-        private static bool TryParse(string addr, out IPObject result)
-        {
-            if (!string.IsNullOrEmpty(addr))
-            {
-                // Is it an IP address
-                if (IPNetAddress.TryParse(addr, out IPNetAddress nw))
-                {
-                    result = nw;
-                    return true;
-                }
-
-                if (IPHost.TryParse(addr, out IPHost h))
-                {
-                    result = h;
-                    return true;
-                }
-            }
-
-            result = IPNetAddress.None;
-            return false;
-        }
-
-        private static IConfigurationManager GetMockConfig(NetworkConfiguration conf)
+        internal static IConfigurationManager GetMockConfig(NetworkConfiguration conf)
         {
             var configManager = new Mock<IConfigurationManager>
             {
                 CallBase = true
             };
             configManager.Setup(x => x.GetConfiguration(It.IsAny<string>())).Returns(conf);
-            return (IConfigurationManager)configManager.Object;
+            return configManager.Object;
         }
 
         /// <summary>
-        /// Checks the ability to ignore interfaces
+        /// Checks the ability to ignore virtual interfaces.
         /// </summary>
-        /// <param name="interfaces">Mock network setup, in the format (IP address, interface index, interface name) : .... </param>
+        /// <param name="interfaces">Mock network setup, in the format (IP address, interface index, interface name) | .... </param>
         /// <param name="lan">LAN addresses.</param>
         /// <param name="value">Bind addresses that are excluded.</param>
         [Theory]
-        [InlineData("192.168.1.208/24,-16,eth16:200.200.200.200/24,11,eth11", "192.168.1.0/24;200.200.200.0/24", "[192.168.1.208/24,200.200.200.200/24]")]
-        [InlineData("192.168.1.208/24,-16,eth16:200.200.200.200/24,11,eth11", "192.168.1.0/24", "[192.168.1.208/24]")]
-        [InlineData("192.168.1.208/24,-16,vEthernet1:192.168.1.208/24,-16,vEthernet212;200.200.200.200/24,11,eth11", "192.168.1.0/24", "[192.168.1.208/24]")]
+        // All valid
+        [InlineData("192.168.1.208/24,-16,eth16|200.200.200.200/24,11,eth11", "192.168.1.0/24;200.200.200.0/24", "[192.168.1.208/24,200.200.200.200/24]")]
+        // eth16 only
+        [InlineData("192.168.1.208/24,-16,eth16|200.200.200.200/24,11,eth11", "192.168.1.0/24", "[192.168.1.208/24]")]
+        // All interfaces excluded. (including loopbacks)
+        [InlineData("192.168.1.208/24,-16,vEthernet1|192.168.2.208/24,-16,vEthernet212|200.200.200.200/24,11,eth11", "192.168.1.0/24", "[]")]
+        // vEthernet1 and vEthernet212 should be excluded.
+        [InlineData("192.168.1.200/24,-20,vEthernet1|192.168.2.208/24,-16,vEthernet212|200.200.200.200/24,11,eth11", "192.168.1.0/24;200.200.200.200/24", "[200.200.200.200/24]")]
+        // Overlapping interface,
+        [InlineData("192.168.1.110/24,-20,br0|192.168.1.10/24,-16,br0|200.200.200.200/24,11,eth11", "192.168.1.0/24", "[192.168.1.110/24,192.168.1.10/24]")]
         public void IgnoreVirtualInterfaces(string interfaces, string lan, string value)
         {
             var conf = new NetworkConfiguration()
@@ -78,71 +57,6 @@ namespace Jellyfin.Networking.Tests
         }
 
         /// <summary>
-        /// Check that the value given is in the network provided.
-        /// </summary>
-        /// <param name="network">Network address.</param>
-        /// <param name="value">Value to check.</param>
-        [Theory]
-        [InlineData("192.168.10.0/24, !192.168.10.60/32", "192.168.10.60")]
-        public void IsInNetwork(string network, string value)
-        {
-            if (network == null)
-            {
-                throw new ArgumentNullException(nameof(network));
-            }
-
-            var conf = new NetworkConfiguration()
-            {
-                EnableIPV6 = true,
-                EnableIPV4 = true,
-                LocalNetworkSubnets = network.Split(',')
-            };
-
-            using var nm = new NetworkManager(GetMockConfig(conf), new NullLogger<NetworkManager>());
-
-            Assert.False(nm.IsInLocalNetwork(value));
-        }
-
-        /// <summary>
-        /// Checks IP address formats.
-        /// </summary>
-        /// <param name="address"></param>
-        [Theory]
-        [InlineData("127.0.0.1")]
-        [InlineData("127.0.0.1:123")]
-        [InlineData("localhost")]
-        [InlineData("localhost:1345")]
-        [InlineData("www.google.co.uk")]
-        [InlineData("fd23:184f:2029:0:3139:7386:67d7:d517")]
-        [InlineData("fd23:184f:2029:0:3139:7386:67d7:d517/56")]
-        [InlineData("[fd23:184f:2029:0:3139:7386:67d7:d517]:124")]
-        [InlineData("fe80::7add:12ff:febb:c67b%16")]
-        [InlineData("[fe80::7add:12ff:febb:c67b%16]:123")]
-        [InlineData("192.168.1.2/255.255.255.0")]
-        [InlineData("192.168.1.2/24")]
-        public void ValidIPStrings(string address)
-        {
-            Assert.True(TryParse(address, out _));
-        }
-
-
-        /// <summary>
-        /// All should be invalid address strings.
-        /// </summary>
-        /// <param name="address">Invalid address strings.</param>
-        [Theory]
-        [InlineData("256.128.0.0.0.1")]
-        [InlineData("127.0.0.1#")]
-        [InlineData("localhost!")]
-        [InlineData("fd23:184f:2029:0:3139:7386:67d7:d517:1231")]
-        [InlineData("[fd23:184f:2029:0:3139:7386:67d7:d517:1231]")]
-        public void InvalidAddressString(string address)
-        {
-            Assert.False(TryParse(address, out _));
-        }
-
-
-        /// <summary>
         /// Test collection parsing.
         /// </summary>
         /// <param name="settings">Collection to parse.</param>
@@ -152,19 +66,22 @@ namespace Jellyfin.Networking.Tests
         /// <param name="result4">Excluded IP4 addresses from the collection.</param>
         /// <param name="result5">Network addresses of the collection.</param>
         [Theory]
-        [InlineData("127.0.0.1#",
+        [InlineData(
+            "127.0.0.1#",
             "[]",
             "[]",
             "[]",
             "[]",
             "[]")]
-        [InlineData("!127.0.0.1",
+        [InlineData(
+            "!127.0.0.1",
             "[]",
             "[]",
             "[127.0.0.1/32]",
             "[127.0.0.1/32]",
             "[]")]
-        [InlineData("",
+        [InlineData(
+            "",
             "[]",
             "[]",
             "[]",
@@ -172,12 +89,13 @@ namespace Jellyfin.Networking.Tests
             "[]")]
         [InlineData(
             "192.158.1.2/16, localhost, fd23:184f:2029:0:3139:7386:67d7:d517,    !10.10.10.10",
-            "[192.158.1.2/16,127.0.0.1/32,fd23:184f:2029:0:3139:7386:67d7:d517/128]",
+            "[192.158.1.2/16,[127.0.0.1/32,::1/128],fd23:184f:2029:0:3139:7386:67d7:d517/128]",
             "[192.158.1.2/16,127.0.0.1/32]",
             "[10.10.10.10/32]",
             "[10.10.10.10/32]",
-            "[192.158.0.0/16,127.0.0.1/32,fd23:184f:2029:0:3139:7386:67d7:d517/128]")]
-        [InlineData("192.158.1.2/255.255.0.0,192.169.1.2/8",
+            "[192.158.0.0/16,127.0.0.1/32,::1/128,fd23:184f:2029:0:3139:7386:67d7:d517/128]")]
+        [InlineData(
+            "192.158.1.2/255.255.0.0,192.169.1.2/8",
             "[192.158.1.2/16,192.169.1.2/8]",
             "[192.158.1.2/16,192.169.1.2/8]",
             "[]",
@@ -194,34 +112,34 @@ namespace Jellyfin.Networking.Tests
             {
                 EnableIPV6 = true,
                 EnableIPV4 = true,
-            };           
+            };
 
             using var nm = new NetworkManager(GetMockConfig(conf), new NullLogger<NetworkManager>());
 
             // Test included.
-            Collection<IPObject> nc = nm.CreateIPCollection(settings.Split(","), false); 
+            Collection<IPObject> nc = nm.CreateIPCollection(settings.Split(','), false);
             Assert.Equal(nc.AsString(), result1);
 
             // Test excluded.
-            nc = nm.CreateIPCollection(settings.Split(","), true);
+            nc = nm.CreateIPCollection(settings.Split(','), true);
             Assert.Equal(nc.AsString(), result3);
 
             conf.EnableIPV6 = false;
             nm.UpdateSettings(conf);
-            
+
             // Test IP4 included.
-            nc = nm.CreateIPCollection(settings.Split(","), false);
+            nc = nm.CreateIPCollection(settings.Split(','), false);
             Assert.Equal(nc.AsString(), result2);
 
             // Test IP4 excluded.
-            nc = nm.CreateIPCollection(settings.Split(","), true);
+            nc = nm.CreateIPCollection(settings.Split(','), true);
             Assert.Equal(nc.AsString(), result4);
 
             conf.EnableIPV6 = true;
             nm.UpdateSettings(conf);
 
             // Test network addresses of collection.
-            nc = nm.CreateIPCollection(settings.Split(","), false);
+            nc = nm.CreateIPCollection(settings.Split(','), false);
             nc = nc.AsNetworks();
             Assert.Equal(nc.AsString(), result5);
         }
@@ -252,7 +170,6 @@ namespace Jellyfin.Networking.Tests
                 throw new ArgumentNullException(nameof(result));
             }
 
-
             var conf = new NetworkConfiguration()
             {
                 EnableIPV6 = true,
@@ -261,10 +178,10 @@ namespace Jellyfin.Networking.Tests
 
             using var nm = new NetworkManager(GetMockConfig(conf), new NullLogger<NetworkManager>());
 
-            Collection<IPObject> nc1 = nm.CreateIPCollection(settings.Split(","), false);
-            Collection<IPObject> nc2 = nm.CreateIPCollection(compare.Split(","), false);
+            Collection<IPObject> nc1 = nm.CreateIPCollection(settings.Split(','), false);
+            Collection<IPObject> nc2 = nm.CreateIPCollection(compare.Split(','), false);
 
-            Assert.Equal(nc1.Union(nc2).AsString(), result);
+            Assert.Equal(nc1.ThatAreContainedInNetworks(nc2).AsString(), result);
         }
 
         [Theory]
@@ -333,8 +250,8 @@ namespace Jellyfin.Networking.Tests
 
         public void TestSubnetContains(string network, string ip)
         {
-            Assert.True(TryParse(network, out IPObject? networkObj));
-            Assert.True(TryParse(ip, out IPObject? ipObj));
+            Assert.True(IPNetAddress.TryParse(network, out var networkObj));
+            Assert.True(IPNetAddress.TryParse(ip, out var ipObj));
             Assert.True(networkObj.Contains(ipObj));
         }
 
@@ -371,14 +288,13 @@ namespace Jellyfin.Networking.Tests
             using var nm = new NetworkManager(GetMockConfig(conf), new NullLogger<NetworkManager>());
 
             // Test included, IP6.
-            Collection<IPObject> ncSource = nm.CreateIPCollection(source.Split(","));
-            Collection<IPObject> ncDest = nm.CreateIPCollection(dest.Split(","));
-            Collection<IPObject> ncResult = ncSource.Union(ncDest);
-            Collection<IPObject> resultCollection = nm.CreateIPCollection(result.Split(","));
+            Collection<IPObject> ncSource = nm.CreateIPCollection(source.Split(','));
+            Collection<IPObject> ncDest = nm.CreateIPCollection(dest.Split(','));
+            Collection<IPObject> ncResult = ncSource.ThatAreContainedInNetworks(ncDest);
+            Collection<IPObject> resultCollection = nm.CreateIPCollection(result.Split(','));
             Assert.True(ncResult.Compare(resultCollection));
         }
 
-
         [Theory]
         [InlineData("10.1.1.1/32", "10.1.1.1")]
         [InlineData("192.168.1.254/32", "192.168.1.254/255.255.255.255")]
@@ -408,6 +324,9 @@ namespace Jellyfin.Networking.Tests
         [InlineData("jellyfin.org", "eth16", false, "eth16")]
         // User on external network, no binding - so result is the 1st external.
         [InlineData("jellyfin.org", "", false, "eth11")]
+        // Dns failure - should skip the test.
+        // https://en.wikipedia.org/wiki/.test
+        [InlineData("invalid.domain.test", "", false, "eth11")]
         // User assumed to be internal, no binding - so result is the 1st internal.
         [InlineData("", "", false, "eth16")]
         public void TestBindInterfaces(string source, string bindAddresses, bool ipv6enabled, string result)
@@ -434,16 +353,19 @@ namespace Jellyfin.Networking.Tests
                 EnableIPV4 = true
             };
 
-            NetworkManager.MockNetworkSettings = "192.168.1.208/24,-16,eth16:200.200.200.200/24,11,eth11";
+            NetworkManager.MockNetworkSettings = "192.168.1.208/24,-16,eth16|200.200.200.200/24,11,eth11";
             using var nm = new NetworkManager(GetMockConfig(conf), new NullLogger<NetworkManager>());
             NetworkManager.MockNetworkSettings = string.Empty;
 
             _ = nm.TryParseInterface(result, out Collection<IPObject>? resultObj);
 
-            if (resultObj != null)
+            // Check to see if dns resolution is working. If not, skip test.
+            _ = IPHost.TryParse(source, out var host);
+
+            if (resultObj != null && host?.HasAddress == true)
             {
                 result = ((IPNetAddress)resultObj[0]).ToString(true);
-                var intf = nm.GetBindInterface(source, out int? _);
+                var intf = nm.GetBindInterface(source, out _);
 
                 Assert.Equal(intf, result);
             }
@@ -455,7 +377,7 @@ namespace Jellyfin.Networking.Tests
         // On my system eth16 is internal, eth11 external (Windows defines the indexes).
         //
         // This test is to replicate how subnet bound ServerPublisherUri work throughout the system.
-        
+
         // User on internal network, we're bound internal and external - so result is internal override.
         [InlineData("192.168.1.1", "192.168.1.0/24", "eth16,eth11", false, "192.168.1.0/24=internal.jellyfin", "internal.jellyfin")]
 
@@ -468,7 +390,7 @@ namespace Jellyfin.Networking.Tests
         // User on internal network, no binding specified - so result is the 1st internal.
         [InlineData("192.168.1.1", "192.168.1.0/24", "", false, "0.0.0.0=http://helloworld.com", "eth16")]
 
-        // User on external network, internal binding only - so asumption is a proxy forward, return external override.
+        // User on external network, internal binding only - so assumption is a proxy forward, return external override.
         [InlineData("jellyfin.org", "192.168.1.0/24", "eth16", false, "0.0.0.0=http://helloworld.com", "http://helloworld.com")]
 
         // User on external network, no binding - so result is the 1st external which is overriden.
@@ -479,7 +401,6 @@ namespace Jellyfin.Networking.Tests
 
         // User is internal, no binding - so result is the 1st internal, which is then overridden.
         [InlineData("192.168.1.1", "192.168.1.0/24", "", false, "eth16=http://helloworld.com", "http://helloworld.com")]
-
         public void TestBindInterfaceOverrides(string source, string lan, string bindAddresses, bool ipv6enabled, string publishedServers, string result)
         {
             if (lan == null)
@@ -501,7 +422,7 @@ namespace Jellyfin.Networking.Tests
                 PublishedServerUriBySubnet = new string[] { publishedServers }
             };
 
-            NetworkManager.MockNetworkSettings = "192.168.1.208/24,-16,eth16:200.200.200.200/24,11,eth11";
+            NetworkManager.MockNetworkSettings = "192.168.1.208/24,-16,eth16|200.200.200.200/24,11,eth11";
             using var nm = new NetworkManager(GetMockConfig(conf), new NullLogger<NetworkManager>());
             NetworkManager.MockNetworkSettings = string.Empty;
 
@@ -515,5 +436,91 @@ namespace Jellyfin.Networking.Tests
 
             Assert.Equal(intf, result);
         }
+
+        [Theory]
+        [InlineData("185.10.10.10,200.200.200.200", "79.2.3.4", true)]
+        [InlineData("185.10.10.10", "185.10.10.10", false)]
+        [InlineData("", "100.100.100.100", false)]
+
+        public void HasRemoteAccess_GivenWhitelist_AllowsOnlyIpsInWhitelist(string addresses, string remoteIp, bool denied)
+        {
+            // Comma separated list of IP addresses or IP/netmask entries for networks that will be allowed to connect remotely.
+            // If left blank, all remote addresses will be allowed.
+            var conf = new NetworkConfiguration()
+            {
+                EnableIPV4 = true,
+                RemoteIPFilter = addresses.Split(','),
+                IsRemoteIPFilterBlacklist = false
+            };
+            using var nm = new NetworkManager(GetMockConfig(conf), new NullLogger<NetworkManager>());
+
+            Assert.NotEqual(nm.HasRemoteAccess(IPAddress.Parse(remoteIp)), denied);
+        }
+
+        [Theory]
+        [InlineData("185.10.10.10", "79.2.3.4", false)]
+        [InlineData("185.10.10.10", "185.10.10.10", true)]
+        [InlineData("", "100.100.100.100", false)]
+        public void HasRemoteAccess_GivenBlacklist_BlacklistTheIps(string addresses, string remoteIp, bool denied)
+        {
+            // Comma separated list of IP addresses or IP/netmask entries for networks that will be allowed to connect remotely.
+            // If left blank, all remote addresses will be allowed.
+            var conf = new NetworkConfiguration()
+            {
+                EnableIPV4 = true,
+                RemoteIPFilter = addresses.Split(','),
+                IsRemoteIPFilterBlacklist = true
+            };
+
+            using var nm = new NetworkManager(GetMockConfig(conf), new NullLogger<NetworkManager>());
+
+            Assert.NotEqual(nm.HasRemoteAccess(IPAddress.Parse(remoteIp)), denied);
+        }
+
+        [Theory]
+        [InlineData("192.168.1.209/24,-16,eth16", "192.168.1.0/24", "", "192.168.1.209")] // Only 1 address so use it.
+        [InlineData("192.168.1.208/24,-16,eth16|10.0.0.1/24,10,eth7", "192.168.1.0/24", "", "192.168.1.208")] // LAN address is specified by default.
+        [InlineData("192.168.1.208/24,-16,eth16|10.0.0.1/24,10,eth7", "192.168.1.0/24", "10.0.0.1", "10.0.0.1")] // return bind address
+
+        public void GetBindInterface_NoSourceGiven_Success(string interfaces, string lan, string bind, string result)
+        {
+            var conf = new NetworkConfiguration
+            {
+                EnableIPV4 = true,
+                LocalNetworkSubnets = lan.Split(','),
+                LocalNetworkAddresses = bind.Split(',')
+            };
+
+            NetworkManager.MockNetworkSettings = interfaces;
+            using var nm = new NetworkManager(GetMockConfig(conf), new NullLogger<NetworkManager>());
+
+            var interfaceToUse = nm.GetBindInterface(string.Empty, out _);
+
+            Assert.Equal(result, interfaceToUse);
+        }
+
+        [Theory]
+        [InlineData("192.168.1.209/24,-16,eth16", "192.168.1.0/24", "", "192.168.1.210", "192.168.1.209")] // Source on LAN
+        [InlineData("192.168.1.208/24,-16,eth16|10.0.0.1/24,10,eth7", "192.168.1.0/24", "", "192.168.1.209", "192.168.1.208")] // Source on LAN
+        [InlineData("192.168.1.208/24,-16,eth16|10.0.0.1/24,10,eth7", "192.168.1.0/24", "", "8.8.8.8", "10.0.0.1")] // Source external.
+        [InlineData("192.168.1.208/24,-16,eth16|10.0.0.1/24,10,eth7", "192.168.1.0/24", "10.0.0.1", "192.168.1.209", "10.0.0.1")] // LAN not bound, so return external.
+        [InlineData("192.168.1.208/24,-16,eth16|10.0.0.1/24,10,eth7", "192.168.1.0/24", "192.168.1.208,10.0.0.1", "8.8.8.8", "10.0.0.1")] // return external bind address
+        [InlineData("192.168.1.208/24,-16,eth16|10.0.0.1/24,10,eth7", "192.168.1.0/24", "192.168.1.208,10.0.0.1", "192.168.1.210", "192.168.1.208")] // return LAN bind address
+        public void GetBindInterface_ValidSourceGiven_Success(string interfaces, string lan, string bind, string source, string result)
+        {
+            var conf = new NetworkConfiguration
+            {
+                EnableIPV4 = true,
+                LocalNetworkSubnets = lan.Split(','),
+                LocalNetworkAddresses = bind.Split(',')
+            };
+
+            NetworkManager.MockNetworkSettings = interfaces;
+            using var nm = new NetworkManager(GetMockConfig(conf), new NullLogger<NetworkManager>());
+
+            var interfaceToUse = nm.GetBindInterface(source, out _);
+
+            Assert.Equal(result, interfaceToUse);
+        }
     }
 }
diff --git a/tests/Jellyfin.Providers.Tests/Jellyfin.Providers.Tests.csproj b/tests/Jellyfin.Providers.Tests/Jellyfin.Providers.Tests.csproj
new file mode 100644
index 000000000..10767ae23
--- /dev/null
+++ b/tests/Jellyfin.Providers.Tests/Jellyfin.Providers.Tests.csproj
@@ -0,0 +1,40 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <IsPackable>false</IsPackable>
+    <CodeAnalysisRuleSet>../jellyfin-tests.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Include="Test Data\**\*.*">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
+    <PackageReference Include="Moq" Version="4.16.1" />
+    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="coverlet.collector" Version="3.1.0">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <!-- Code Analyzers -->
+  <ItemGroup Condition=" '$(Configuration)' == 'Debug' ">
+    <PackageReference Include="SerilogAnalyzer" Version="0.15.0" PrivateAssets="All" />
+    <PackageReference Include="StyleCop.Analyzers" Version="1.1.118" PrivateAssets="All" />
+    <PackageReference Include="SmartAnalyzers.MultithreadingAnalyzer" Version="1.1.31" PrivateAssets="All" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../../MediaBrowser.Providers/MediaBrowser.Providers.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/tests/Jellyfin.Providers.Tests/Manager/ItemImageProviderTests.cs b/tests/Jellyfin.Providers.Tests/Manager/ItemImageProviderTests.cs
new file mode 100644
index 000000000..2ba5c47d7
--- /dev/null
+++ b/tests/Jellyfin.Providers.Tests/Manager/ItemImageProviderTests.cs
@@ -0,0 +1,597 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Configuration;
+using MediaBrowser.Model.Drawing;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Model.MediaInfo;
+using MediaBrowser.Model.Providers;
+using MediaBrowser.Providers.Manager;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.Providers.Tests.Manager
+{
+    public class ItemImageProviderTests
+    {
+        private const string TestDataImagePath = "Test Data/Images/blank{0}.jpg";
+
+        [Fact]
+        public void ValidateImages_PhotoEmptyProviders_NoChange()
+        {
+            var itemImageProvider = GetItemImageProvider(null, null);
+            var changed = itemImageProvider.ValidateImages(new Photo(), Enumerable.Empty<ILocalImageProvider>(), null);
+
+            Assert.False(changed);
+        }
+
+        [Fact]
+        public void ValidateImages_EmptyItemEmptyProviders_NoChange()
+        {
+            var itemImageProvider = GetItemImageProvider(null, null);
+            var changed = itemImageProvider.ValidateImages(new Video(), Enumerable.Empty<ILocalImageProvider>(), null);
+
+            Assert.False(changed);
+        }
+
+        private static TheoryData<ImageType, int> GetImageTypesWithCount()
+        {
+            var theoryTypes = new TheoryData<ImageType, int>
+            {
+                // minimal test cases that hit different handling
+                { ImageType.Primary, 1 },
+                { ImageType.Backdrop, 1 },
+                { ImageType.Backdrop, 2 }
+            };
+
+            return theoryTypes;
+        }
+
+        [Theory]
+        [MemberData(nameof(GetImageTypesWithCount))]
+        public void ValidateImages_EmptyItemAndPopulatedProviders_AddsImages(ImageType imageType, int imageCount)
+        {
+            // Has to exist for querying DateModified time on file, results stored but not checked so not populating
+            BaseItem.FileSystem = Mock.Of<IFileSystem>();
+
+            var item = new Video();
+            var imageProvider = GetImageProvider(imageType, imageCount, true);
+
+            var itemImageProvider = GetItemImageProvider(null, null);
+            var changed = itemImageProvider.ValidateImages(item, new[] { imageProvider }, null);
+
+            Assert.True(changed);
+            Assert.Equal(imageCount, item.GetImages(imageType).Count());
+        }
+
+        [Theory]
+        [MemberData(nameof(GetImageTypesWithCount))]
+        public void ValidateImages_PopulatedItemWithGoodPathsAndEmptyProviders_NoChange(ImageType imageType, int imageCount)
+        {
+            var item = GetItemWithImages(imageType, imageCount, true);
+
+            var itemImageProvider = GetItemImageProvider(null, null);
+            var changed = itemImageProvider.ValidateImages(item, Enumerable.Empty<ILocalImageProvider>(), null);
+
+            Assert.False(changed);
+            Assert.Equal(imageCount, item.GetImages(imageType).Count());
+        }
+
+        [Theory]
+        [MemberData(nameof(GetImageTypesWithCount))]
+        public void ValidateImages_PopulatedItemWithBadPathsAndEmptyProviders_RemovesImage(ImageType imageType, int imageCount)
+        {
+            var item = GetItemWithImages(imageType, imageCount, false);
+
+            var itemImageProvider = GetItemImageProvider(null, null);
+            var changed = itemImageProvider.ValidateImages(item, Enumerable.Empty<ILocalImageProvider>(), null);
+
+            Assert.True(changed);
+            Assert.Empty(item.GetImages(imageType));
+        }
+
+        [Fact]
+        public void MergeImages_EmptyItemNewImagesEmpty_NoChange()
+        {
+            var itemImageProvider = GetItemImageProvider(null, null);
+            var changed = itemImageProvider.MergeImages(new Video(), Array.Empty<LocalImageInfo>());
+
+            Assert.False(changed);
+        }
+
+        [Theory]
+        [MemberData(nameof(GetImageTypesWithCount))]
+        public void MergeImages_PopulatedItemWithGoodPathsAndPopulatedNewImages_AddsUpdatesImages(ImageType imageType, int imageCount)
+        {
+            // valid and not valid paths - should replace the valid paths with the invalid ones
+            var item = GetItemWithImages(imageType, imageCount, true);
+            var images = GetImages(imageType, imageCount, false);
+
+            var itemImageProvider = GetItemImageProvider(null, null);
+            var changed = itemImageProvider.MergeImages(item, images);
+
+            Assert.True(changed);
+            // adds for types that allow multiple, replaces singular type images
+            if (item.AllowsMultipleImages(imageType))
+            {
+                Assert.Equal(imageCount * 2, item.GetImages(imageType).Count());
+            }
+            else
+            {
+                Assert.Single(item.GetImages(imageType));
+                Assert.Same(images[0].FileInfo.FullName, item.GetImages(imageType).First().Path);
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(GetImageTypesWithCount))]
+        public void MergeImages_PopulatedItemWithGoodPathsAndSameNewImages_NoChange(ImageType imageType, int imageCount)
+        {
+            var oldTime = new DateTime(1970, 1, 1);
+
+            // match update time with time added to item images (unix epoch)
+            var fileSystem = new Mock<IFileSystem>();
+            fileSystem.Setup(fs => fs.GetLastWriteTimeUtc(It.IsAny<FileSystemMetadata>()))
+                .Returns(oldTime);
+            BaseItem.FileSystem = fileSystem.Object;
+
+            // all valid paths - matching for strictly updating
+            var item = GetItemWithImages(imageType, imageCount, true);
+            // set size to non-zero to allow for updates to occur
+            foreach (var image in item.GetImages(imageType))
+            {
+                image.DateModified = oldTime;
+                image.Height = 1;
+                image.Width = 1;
+            }
+
+            var images = GetImages(imageType, imageCount, true);
+
+            var itemImageProvider = GetItemImageProvider(null, fileSystem);
+            var changed = itemImageProvider.MergeImages(item, images);
+
+            Assert.False(changed);
+        }
+
+        [Theory]
+        [MemberData(nameof(GetImageTypesWithCount))]
+        public void MergeImages_PopulatedItemWithGoodPathsAndSameNewImagesWithNewTimestamps_ResetsImageSizes(ImageType imageType, int imageCount)
+        {
+            var oldTime = new DateTime(1970, 1, 1);
+            var updatedTime = new DateTime(2021, 1, 1);
+
+            var fileSystem = new Mock<IFileSystem>();
+            fileSystem.Setup(fs => fs.GetLastWriteTimeUtc(It.IsAny<FileSystemMetadata>()))
+                .Returns(updatedTime);
+            BaseItem.FileSystem = fileSystem.Object;
+
+            // all valid paths - matching for strictly updating
+            var item = GetItemWithImages(imageType, imageCount, true);
+            // set size to non-zero to allow for image size reset to occur
+            foreach (var image in item.GetImages(imageType))
+            {
+                image.DateModified = oldTime;
+                image.Height = 1;
+                image.Width = 1;
+            }
+
+            var images = GetImages(imageType, imageCount, true);
+
+            var itemImageProvider = GetItemImageProvider(null, fileSystem);
+            var changed = itemImageProvider.MergeImages(item, images);
+
+            Assert.True(changed);
+            // before and after paths are the same, verify updated by size reset to 0
+            Assert.Equal(imageCount, item.GetImages(imageType).Count());
+            foreach (var image in item.GetImages(imageType))
+            {
+                Assert.Equal(updatedTime, image.DateModified);
+                Assert.Equal(0, image.Height);
+                Assert.Equal(0, image.Width);
+            }
+        }
+
+        [Theory]
+        [InlineData(ImageType.Primary, 1, false)]
+        [InlineData(ImageType.Backdrop, 2, false)]
+        [InlineData(ImageType.Primary, 1, true)]
+        [InlineData(ImageType.Backdrop, 2, true)]
+        public async void RefreshImages_PopulatedItemPopulatedProviderDynamic_UpdatesImagesIfForced(ImageType imageType, int imageCount, bool forceRefresh)
+        {
+            var item = GetItemWithImages(imageType, imageCount, false);
+
+            var libraryOptions = GetLibraryOptions(item, imageType, imageCount);
+
+            var imageResponse = new DynamicImageResponse
+            {
+                HasImage = true,
+                Format = ImageFormat.Jpg,
+                Path = "url path",
+                Protocol = MediaProtocol.Http
+            };
+
+            var dynamicProvider = new Mock<IDynamicImageProvider>(MockBehavior.Strict);
+            dynamicProvider.Setup(rp => rp.Name).Returns("MockDynamicProvider");
+            dynamicProvider.Setup(rp => rp.GetSupportedImages(item))
+                .Returns(new[] { imageType });
+            dynamicProvider.Setup(rp => rp.GetImage(item, imageType, It.IsAny<CancellationToken>()))
+                .ReturnsAsync(imageResponse);
+
+            var refreshOptions = forceRefresh
+                ? new ImageRefreshOptions(Mock.Of<IDirectoryService>())
+                {
+                    ImageRefreshMode = MetadataRefreshMode.FullRefresh,
+                    ReplaceAllImages = true
+                }
+                : new ImageRefreshOptions(Mock.Of<IDirectoryService>());
+
+            var itemImageProvider = GetItemImageProvider(null, new Mock<IFileSystem>());
+            var result = await itemImageProvider.RefreshImages(item, libraryOptions, new List<IImageProvider> { dynamicProvider.Object }, refreshOptions, CancellationToken.None);
+
+            Assert.Equal(forceRefresh, result.UpdateType.HasFlag(ItemUpdateType.ImageUpdate));
+            if (forceRefresh)
+            {
+                // replaces multi-types
+                Assert.Single(item.GetImages(imageType));
+            }
+            else
+            {
+                // adds to multi-types if room
+                Assert.Equal(imageCount, item.GetImages(imageType).Count());
+            }
+        }
+
+        [Theory]
+        [InlineData(ImageType.Primary, 1, true, MediaProtocol.Http)]
+        [InlineData(ImageType.Backdrop, 2, true, MediaProtocol.Http)]
+        [InlineData(ImageType.Primary, 1, true, MediaProtocol.File)]
+        [InlineData(ImageType.Backdrop, 2, true, MediaProtocol.File)]
+        [InlineData(ImageType.Primary, 1, false, MediaProtocol.File)]
+        [InlineData(ImageType.Backdrop, 2, false, MediaProtocol.File)]
+        public async void RefreshImages_EmptyItemPopulatedProviderDynamic_AddsImages(ImageType imageType, int imageCount, bool responseHasPath, MediaProtocol protocol)
+        {
+            // Has to exist for querying DateModified time on file, results stored but not checked so not populating
+            BaseItem.FileSystem = Mock.Of<IFileSystem>();
+
+            var item = new Video();
+
+            var libraryOptions = GetLibraryOptions(item, imageType, imageCount);
+
+            // Path must exist if set: is read in as a stream by AsyncFile.OpenRead
+            var imageResponse = new DynamicImageResponse
+            {
+                HasImage = true,
+                Format = ImageFormat.Jpg,
+                Path = responseHasPath ? string.Format(CultureInfo.InvariantCulture, TestDataImagePath, 0) : null,
+                Protocol = protocol
+            };
+
+            var dynamicProvider = new Mock<IDynamicImageProvider>(MockBehavior.Strict);
+            dynamicProvider.Setup(rp => rp.Name).Returns("MockDynamicProvider");
+            dynamicProvider.Setup(rp => rp.GetSupportedImages(item))
+                .Returns(new[] { imageType });
+            dynamicProvider.Setup(rp => rp.GetImage(item, imageType, It.IsAny<CancellationToken>()))
+                .ReturnsAsync(imageResponse);
+
+            var refreshOptions = new ImageRefreshOptions(Mock.Of<IDirectoryService>());
+
+            var providerManager = new Mock<IProviderManager>(MockBehavior.Strict);
+            providerManager.Setup(pm => pm.SaveImage(item, It.IsAny<Stream>(), It.IsAny<string>(), imageType, null, It.IsAny<CancellationToken>()))
+                .Callback<BaseItem, Stream, string, ImageType, int?, CancellationToken>((callbackItem, _, _, callbackType, _, _) => callbackItem.SetImagePath(callbackType, 0, new FileSystemMetadata()))
+                .Returns(Task.CompletedTask);
+            var itemImageProvider = GetItemImageProvider(providerManager.Object, null);
+            var result = await itemImageProvider.RefreshImages(item, libraryOptions, new List<IImageProvider> { dynamicProvider.Object }, refreshOptions, CancellationToken.None);
+
+            Assert.True(result.UpdateType.HasFlag(ItemUpdateType.ImageUpdate));
+            // dynamic provider unable to return multiple images
+            Assert.Single(item.GetImages(imageType));
+            if (protocol == MediaProtocol.Http)
+            {
+                Assert.Equal(imageResponse.Path, item.GetImagePath(imageType, 0));
+            }
+        }
+
+        [Theory]
+        [InlineData(ImageType.Primary, 1, false)]
+        [InlineData(ImageType.Backdrop, 1, false)]
+        [InlineData(ImageType.Backdrop, 2, false)]
+        [InlineData(ImageType.Primary, 1, true)]
+        [InlineData(ImageType.Backdrop, 1, true)]
+        [InlineData(ImageType.Backdrop, 2, true)]
+        public async void RefreshImages_PopulatedItemPopulatedProviderRemote_UpdatesImagesIfForced(ImageType imageType, int imageCount, bool forceRefresh)
+        {
+            var item = GetItemWithImages(imageType, imageCount, false);
+
+            var libraryOptions = GetLibraryOptions(item, imageType, imageCount);
+
+            var remoteProvider = new Mock<IRemoteImageProvider>(MockBehavior.Strict);
+            remoteProvider.Setup(rp => rp.Name).Returns("MockRemoteProvider");
+            remoteProvider.Setup(rp => rp.GetSupportedImages(item))
+                .Returns(new[] { imageType });
+
+            var refreshOptions = forceRefresh
+                ? new ImageRefreshOptions(Mock.Of<IDirectoryService>())
+                {
+                    ImageRefreshMode = MetadataRefreshMode.FullRefresh,
+                    ReplaceAllImages = true
+                }
+                : new ImageRefreshOptions(Mock.Of<IDirectoryService>());
+
+            var remoteInfo = new RemoteImageInfo[imageCount];
+            for (int i = 0; i < imageCount; i++)
+            {
+                remoteInfo[i] = new RemoteImageInfo
+                {
+                    Type = imageType,
+                    Url = "image url " + i,
+                    Width = 1 // min width is set to 0, this will always pass
+                };
+            }
+
+            var providerManager = new Mock<IProviderManager>(MockBehavior.Strict);
+            providerManager.Setup(pm => pm.GetAvailableRemoteImages(It.IsAny<BaseItem>(), It.IsAny<RemoteImageQuery>(), It.IsAny<CancellationToken>()))
+                .ReturnsAsync(remoteInfo);
+            var itemImageProvider = GetItemImageProvider(providerManager.Object, new Mock<IFileSystem>());
+            var result = await itemImageProvider.RefreshImages(item, libraryOptions, new List<IImageProvider> { remoteProvider.Object }, refreshOptions, CancellationToken.None);
+
+            Assert.Equal(forceRefresh, result.UpdateType.HasFlag(ItemUpdateType.ImageUpdate));
+            Assert.Equal(imageCount, item.GetImages(imageType).Count());
+            foreach (var image in item.GetImages(imageType))
+            {
+                if (forceRefresh)
+                {
+                    Assert.Matches(@"image url [0-9]", image.Path);
+                }
+                else
+                {
+                    Assert.DoesNotMatch(@"image url [0-9]", image.Path);
+                }
+            }
+        }
+
+        [Theory]
+        [InlineData(ImageType.Primary, 0, false)] // singular type only fetches if type is missing from item, no caching
+        [InlineData(ImageType.Backdrop, 0, false)] // empty item, no cache to check
+        [InlineData(ImageType.Backdrop, 1, false)] // populated item, cached so no download
+        [InlineData(ImageType.Backdrop, 1, true)] // populated item, forced to download
+        public async void RefreshImages_NonStubItemPopulatedProviderRemote_DownloadsIfNecessary(ImageType imageType, int initialImageCount, bool fullRefresh)
+        {
+            var targetImageCount = 1;
+
+            // Set path and media source manager so images will be downloaded (EnableImageStub will return false)
+            var item = GetItemWithImages(imageType, initialImageCount, false);
+            item.Path = "non-empty path";
+            BaseItem.MediaSourceManager = Mock.Of<IMediaSourceManager>();
+
+            // seek 2 so it won't short-circuit out of downloading when populated
+            var libraryOptions = GetLibraryOptions(item, imageType, 2);
+
+            const string Content = "Content";
+            var remoteProvider = new Mock<IRemoteImageProvider>(MockBehavior.Strict);
+            remoteProvider.Setup(rp => rp.Name).Returns("MockRemoteProvider");
+            remoteProvider.Setup(rp => rp.GetSupportedImages(item))
+                .Returns(new[] { imageType });
+            remoteProvider.Setup(rp => rp.GetImageResponse(It.IsAny<string>(), It.IsAny<CancellationToken>()))
+                .ReturnsAsync((string url, CancellationToken _) => new HttpResponseMessage
+                {
+                    ReasonPhrase = url,
+                    StatusCode = HttpStatusCode.OK,
+                    Content = new StringContent(Content, Encoding.UTF8, "image/jpeg")
+                });
+
+            var refreshOptions = fullRefresh
+                ? new ImageRefreshOptions(Mock.Of<IDirectoryService>())
+                {
+                    ImageRefreshMode = MetadataRefreshMode.FullRefresh,
+                    ReplaceAllImages = true
+                }
+                : new ImageRefreshOptions(Mock.Of<IDirectoryService>());
+
+            var remoteInfo = new RemoteImageInfo[targetImageCount];
+            for (int i = 0; i < targetImageCount; i++)
+            {
+                remoteInfo[i] = new RemoteImageInfo()
+                {
+                    Type = imageType,
+                    Url = "image url " + i,
+                    Width = 1 // min width is set to 0, this will always pass
+                };
+            }
+
+            var providerManager = new Mock<IProviderManager>(MockBehavior.Strict);
+            providerManager.Setup(pm => pm.GetAvailableRemoteImages(It.IsAny<BaseItem>(), It.IsAny<RemoteImageQuery>(), It.IsAny<CancellationToken>()))
+                .ReturnsAsync(remoteInfo);
+            providerManager.Setup(pm => pm.SaveImage(item, It.IsAny<Stream>(), It.IsAny<string>(), imageType, null, It.IsAny<CancellationToken>()))
+                .Callback<BaseItem, Stream, string, ImageType, int?, CancellationToken>((callbackItem, _, _, callbackType, _, _) =>
+                    callbackItem.SetImagePath(callbackType, callbackItem.AllowsMultipleImages(callbackType) ? callbackItem.GetImages(callbackType).Count() : 0, new FileSystemMetadata()))
+                .Returns(Task.CompletedTask);
+            var fileSystem = new Mock<IFileSystem>();
+            // match reported file size to image content length - condition for skipping already downloaded multi-images
+            fileSystem.Setup(fs => fs.GetFileInfo(It.IsAny<string>()))
+                .Returns(new FileSystemMetadata { Length = Content.Length });
+            var itemImageProvider = GetItemImageProvider(providerManager.Object, fileSystem);
+            var result = await itemImageProvider.RefreshImages(item, libraryOptions, new List<IImageProvider> { remoteProvider.Object }, refreshOptions, CancellationToken.None);
+
+            Assert.Equal(initialImageCount == 0 || fullRefresh, result.UpdateType.HasFlag(ItemUpdateType.ImageUpdate));
+            Assert.Equal(targetImageCount, item.GetImages(imageType).Count());
+        }
+
+        [Theory]
+        [MemberData(nameof(GetImageTypesWithCount))]
+        public async void RefreshImages_EmptyItemPopulatedProviderRemoteExtras_LimitsImages(ImageType imageType, int imageCount)
+        {
+            var item = new Video();
+
+            var libraryOptions = GetLibraryOptions(item, imageType, imageCount);
+
+            var remoteProvider = new Mock<IRemoteImageProvider>(MockBehavior.Strict);
+            remoteProvider.Setup(rp => rp.Name).Returns("MockRemoteProvider");
+            remoteProvider.Setup(rp => rp.GetSupportedImages(item))
+                .Returns(new[] { imageType });
+
+            var refreshOptions = new ImageRefreshOptions(Mock.Of<IDirectoryService>());
+
+            // populate remote with double the required images to verify count is trimmed to the library option count
+            var remoteInfoCount = imageCount * 2;
+            var remoteInfo = new RemoteImageInfo[remoteInfoCount];
+            for (int i = 0; i < remoteInfoCount; i++)
+            {
+                remoteInfo[i] = new RemoteImageInfo()
+                {
+                    Type = imageType,
+                    Url = "image url " + i,
+                    Width = 1 // min width is set to 0, this will always pass
+                };
+            }
+
+            var providerManager = new Mock<IProviderManager>(MockBehavior.Strict);
+            providerManager.Setup(pm => pm.GetAvailableRemoteImages(It.IsAny<BaseItem>(), It.IsAny<RemoteImageQuery>(), It.IsAny<CancellationToken>()))
+                .ReturnsAsync(remoteInfo);
+            var itemImageProvider = GetItemImageProvider(providerManager.Object, null);
+            var result = await itemImageProvider.RefreshImages(item, libraryOptions, new List<IImageProvider> { remoteProvider.Object }, refreshOptions, CancellationToken.None);
+
+            Assert.True(result.UpdateType.HasFlag(ItemUpdateType.ImageUpdate));
+            var actualImages = item.GetImages(imageType).ToList();
+            Assert.Equal(imageCount, actualImages.Count);
+            // images from the provider manager are sorted by preference (earlier images are higher priority) so we can verify that low url numbers are chosen
+            foreach (var image in actualImages)
+            {
+                var index = int.Parse(Regex.Match(image.Path, @"[0-9]+").Value, NumberStyles.Integer, CultureInfo.InvariantCulture);
+                Assert.True(index < imageCount);
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(GetImageTypesWithCount))]
+        public async void RefreshImages_PopulatedItemEmptyProviderRemoteFullRefresh_DoesntClearImages(ImageType imageType, int imageCount)
+        {
+            var item = GetItemWithImages(imageType, imageCount, false);
+
+            var libraryOptions = GetLibraryOptions(item, imageType, imageCount);
+
+            var remoteProvider = new Mock<IRemoteImageProvider>(MockBehavior.Strict);
+            remoteProvider.Setup(rp => rp.Name).Returns("MockRemoteProvider");
+            remoteProvider.Setup(rp => rp.GetSupportedImages(item))
+                .Returns(new[] { imageType });
+
+            var refreshOptions = new ImageRefreshOptions(Mock.Of<IDirectoryService>())
+            {
+                ImageRefreshMode = MetadataRefreshMode.FullRefresh,
+                ReplaceAllImages = true
+            };
+
+            var itemImageProvider = GetItemImageProvider(Mock.Of<IProviderManager>(), null);
+            var result = await itemImageProvider.RefreshImages(item, libraryOptions, new List<IImageProvider> { remoteProvider.Object }, refreshOptions, CancellationToken.None);
+
+            Assert.False(result.UpdateType.HasFlag(ItemUpdateType.ImageUpdate));
+            Assert.Equal(imageCount, item.GetImages(imageType).Count());
+        }
+
+        private static ItemImageProvider GetItemImageProvider(IProviderManager? providerManager, Mock<IFileSystem>? mockFileSystem)
+        {
+            // strict to ensure this isn't accidentally used where a prepared mock is intended
+            providerManager ??= Mock.Of<IProviderManager>(MockBehavior.Strict);
+
+            // BaseItem.ValidateImages depends on the directory service being able to list directory contents, give it the expected valid file paths
+            mockFileSystem ??= new Mock<IFileSystem>(MockBehavior.Strict);
+            mockFileSystem.Setup(fs => fs.GetFilePaths(It.IsAny<string>(), It.IsAny<bool>()))
+                .Returns(new[]
+                {
+                    string.Format(CultureInfo.InvariantCulture, TestDataImagePath, 0),
+                    string.Format(CultureInfo.InvariantCulture, TestDataImagePath, 1)
+                });
+
+            return new ItemImageProvider(new NullLogger<ItemImageProvider>(), providerManager, mockFileSystem.Object);
+        }
+
+        private static BaseItem GetItemWithImages(ImageType type, int count, bool validPaths)
+        {
+            // Has to exist for querying DateModified time on file, results stored but not checked so not populating
+            BaseItem.FileSystem ??= Mock.Of<IFileSystem>();
+
+            var item = new Video();
+
+            var path = validPaths ? TestDataImagePath : "invalid path {0}";
+            for (int i = 0; i < count; i++)
+            {
+                item.SetImagePath(type, i, new FileSystemMetadata
+                {
+                    FullName = string.Format(CultureInfo.InvariantCulture, path, i),
+                });
+            }
+
+            return item;
+        }
+
+        private static ILocalImageProvider GetImageProvider(ImageType type, int count, bool validPaths)
+        {
+            var images = GetImages(type, count, validPaths);
+
+            var imageProvider = new Mock<ILocalImageProvider>();
+            imageProvider.Setup(ip => ip.GetImages(It.IsAny<BaseItem>(), It.IsAny<IDirectoryService>()))
+                .Returns(images);
+            return imageProvider.Object;
+        }
+
+        /// <summary>
+        /// Creates a list of <see cref="LocalImageInfo"/> references of the specified type and size, optionally pointing to files that exist.
+        /// </summary>
+        private static LocalImageInfo[] GetImages(ImageType type, int count, bool validPaths)
+        {
+            var path = validPaths ? TestDataImagePath : "invalid path {0}";
+            var images = new LocalImageInfo[count];
+            for (int i = 0; i < count; i++)
+            {
+                images[i] = new LocalImageInfo
+                {
+                    Type = type,
+                    FileInfo = new FileSystemMetadata
+                    {
+                        FullName = string.Format(CultureInfo.InvariantCulture, path, i)
+                    }
+                };
+            }
+
+            return images;
+        }
+
+        /// <summary>
+        /// Generates a <see cref="LibraryOptions"/> object that will allow for the requested number of images for the target type.
+        /// </summary>
+        private static LibraryOptions GetLibraryOptions(BaseItem item, ImageType type, int count)
+        {
+            return new LibraryOptions
+            {
+                TypeOptions = new[]
+                {
+                    new TypeOptions
+                    {
+                        Type = item.GetType().Name,
+                        ImageOptions = new[]
+                        {
+                            new ImageOption
+                            {
+                                Type = type,
+                                Limit = count,
+                                MinWidth = 0
+                            }
+                        }
+                    }
+                }
+            };
+        }
+    }
+}
diff --git a/tests/Jellyfin.Providers.Tests/MediaInfo/EmbeddedImageProviderTests.cs b/tests/Jellyfin.Providers.Tests/MediaInfo/EmbeddedImageProviderTests.cs
new file mode 100644
index 000000000..558321810
--- /dev/null
+++ b/tests/Jellyfin.Providers.Tests/MediaInfo/EmbeddedImageProviderTests.cs
@@ -0,0 +1,156 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.MediaEncoding;
+using MediaBrowser.Controller.Persistence;
+using MediaBrowser.Model.Drawing;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Providers.MediaInfo;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.Providers.Tests.MediaInfo
+{
+    public class EmbeddedImageProviderTests
+    {
+        [Theory]
+        [InlineData(typeof(AudioBook))]
+        [InlineData(typeof(BoxSet))]
+        [InlineData(typeof(Series))]
+        [InlineData(typeof(Season))]
+        [InlineData(typeof(Episode), ImageType.Primary)]
+        [InlineData(typeof(Movie), ImageType.Logo, ImageType.Backdrop, ImageType.Primary)]
+        public void GetSupportedImages_AnyBaseItem_ReturnsExpected(Type type, params ImageType[] expected)
+        {
+            BaseItem item = (BaseItem)Activator.CreateInstance(type)!;
+            var embeddedImageProvider = new EmbeddedImageProvider(Mock.Of<IMediaSourceManager>(), Mock.Of<IMediaEncoder>(), new NullLogger<EmbeddedImageProvider>());
+            var actual = embeddedImageProvider.GetSupportedImages(item);
+            Assert.Equal(expected.OrderBy(i => i.ToString()), actual.OrderBy(i => i.ToString()));
+        }
+
+        [Fact]
+        public async void GetImage_NoStreams_ReturnsNoImage()
+        {
+            var input = new Movie();
+
+            var mediaSourceManager = GetMediaSourceManager(input, new List<MediaAttachment>(), new List<MediaStream>());
+            var embeddedImageProvider = new EmbeddedImageProvider(mediaSourceManager, null, new NullLogger<EmbeddedImageProvider>());
+
+            var actual = await embeddedImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
+            Assert.NotNull(actual);
+            Assert.False(actual.HasImage);
+        }
+
+        [Theory]
+        [InlineData("chapter", null, 1, ImageType.Chapter, null)] // unexpected type, nothing found
+        [InlineData("unmatched", null, 1, ImageType.Primary, null)] // doesn't default on no match
+        [InlineData("clearlogo.png", null, 1, ImageType.Logo, ImageFormat.Png)] // extract extension from name
+        [InlineData("backdrop", "image/bmp", 2, ImageType.Backdrop, ImageFormat.Bmp)] // extract extension from mimetype
+        [InlineData("poster", null, 3, ImageType.Primary, ImageFormat.Jpg)] // default extension to jpg
+        public async void GetImage_Attachment_ReturnsCorrectSelection(string filename, string mimetype, int targetIndex, ImageType type, ImageFormat? expectedFormat)
+        {
+            var attachments = new List<MediaAttachment>();
+            string pathPrefix = "path";
+            for (int i = 1; i <= targetIndex; i++)
+            {
+                var name = i == targetIndex ? filename : "unmatched";
+                attachments.Add(new ()
+                {
+                    FileName = name,
+                    MimeType = mimetype,
+                    Index = i
+                });
+            }
+
+            var input = new Movie();
+
+            var mediaEncoder = new Mock<IMediaEncoder>(MockBehavior.Strict);
+            mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<MediaSourceInfo>(), It.IsAny<MediaStream>(), It.IsAny<int>(), It.IsAny<ImageFormat>(), It.IsAny<CancellationToken>()))
+                .Returns<string, string, MediaSourceInfo, MediaStream, int, ImageFormat, CancellationToken>((_, _, _, _, index, ext, _) => Task.FromResult(pathPrefix + index + "." + ext));
+            var mediaSourceManager = GetMediaSourceManager(input, attachments, new List<MediaStream>());
+            var embeddedImageProvider = new EmbeddedImageProvider(mediaSourceManager, mediaEncoder.Object, new NullLogger<EmbeddedImageProvider>());
+
+            var actual = await embeddedImageProvider.GetImage(input, type, CancellationToken.None);
+            Assert.NotNull(actual);
+            if (expectedFormat == null)
+            {
+                Assert.False(actual.HasImage);
+            }
+            else
+            {
+                Assert.True(actual.HasImage);
+                Assert.Equal(pathPrefix + targetIndex + "." + expectedFormat, actual.Path, StringComparer.OrdinalIgnoreCase);
+                Assert.Equal(expectedFormat, actual.Format);
+            }
+        }
+
+        [Theory]
+        [InlineData("chapter", null, 1, ImageType.Chapter, null)] // unexpected type, nothing found
+        [InlineData(null, null, 1, ImageType.Backdrop, null)] // no label, can only find primary
+        [InlineData(null, null, 1, ImageType.Primary, ImageFormat.Jpg)] // no label, finds primary
+        [InlineData("backdrop", null, 2, ImageType.Backdrop, ImageFormat.Jpg)] // uses label to find index 2, not just pulling first stream
+        [InlineData("cover", null, 2, ImageType.Primary, ImageFormat.Jpg)] // uses label to find index 2, not just pulling first stream
+        [InlineData(null, "mjpeg", 1, ImageType.Primary, ImageFormat.Jpg)]
+        [InlineData(null, "png", 1, ImageType.Primary, ImageFormat.Png)]
+        [InlineData(null, "gif", 1, ImageType.Primary, ImageFormat.Gif)]
+        public async void GetImage_Embedded_ReturnsCorrectSelection(string label, string? codec, int targetIndex, ImageType type, ImageFormat? expectedFormat)
+        {
+            var streams = new List<MediaStream>();
+            for (int i = 1; i <= targetIndex; i++)
+            {
+                var comment = i == targetIndex ? label : "unmatched";
+                streams.Add(new ()
+                {
+                    Type = MediaStreamType.EmbeddedImage,
+                    Index = i,
+                    Comment = comment,
+                    Codec = codec
+                });
+            }
+
+            var input = new Movie();
+
+            var pathPrefix = "path";
+            var mediaEncoder = new Mock<IMediaEncoder>(MockBehavior.Strict);
+            mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<MediaSourceInfo>(), It.IsAny<MediaStream>(), It.IsAny<int>(), It.IsAny<ImageFormat>(), It.IsAny<CancellationToken>()))
+                .Returns<string, string, MediaSourceInfo, MediaStream, int, ImageFormat, CancellationToken>((_, _, _, stream, index, ext, _) =>
+                {
+                    Assert.Equal(streams[index - 1], stream);
+                    return Task.FromResult(pathPrefix + index + "." + ext);
+                });
+            var mediaSourceManager = GetMediaSourceManager(input, new List<MediaAttachment>(), streams);
+            var embeddedImageProvider = new EmbeddedImageProvider(mediaSourceManager, mediaEncoder.Object, new NullLogger<EmbeddedImageProvider>());
+
+            var actual = await embeddedImageProvider.GetImage(input, type, CancellationToken.None);
+            Assert.NotNull(actual);
+            if (expectedFormat == null)
+            {
+                Assert.False(actual.HasImage);
+            }
+            else
+            {
+                Assert.True(actual.HasImage);
+                Assert.Equal(pathPrefix + targetIndex + "." + expectedFormat, actual.Path, StringComparer.OrdinalIgnoreCase);
+                Assert.Equal(expectedFormat, actual.Format);
+            }
+        }
+
+        private static IMediaSourceManager GetMediaSourceManager(BaseItem item, List<MediaAttachment> mediaAttachments, List<MediaStream> mediaStreams)
+        {
+            var mediaSourceManager = new Mock<IMediaSourceManager>(MockBehavior.Strict);
+            mediaSourceManager.Setup(i => i.GetMediaAttachments(item.Id))
+                .Returns(mediaAttachments);
+            mediaSourceManager.Setup(i => i.GetMediaStreams(It.Is<MediaStreamQuery>(q => q.ItemId == item.Id && q.Type == MediaStreamType.EmbeddedImage)))
+                .Returns(mediaStreams);
+            return mediaSourceManager.Object;
+        }
+    }
+}
diff --git a/tests/Jellyfin.Providers.Tests/MediaInfo/SubtitleResolverTests.cs b/tests/Jellyfin.Providers.Tests/MediaInfo/SubtitleResolverTests.cs
new file mode 100644
index 000000000..33da277e3
--- /dev/null
+++ b/tests/Jellyfin.Providers.Tests/MediaInfo/SubtitleResolverTests.cs
@@ -0,0 +1,129 @@
+#pragma warning disable CA1002 // Do not expose generic lists
+
+using System.Collections.Generic;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Globalization;
+using MediaBrowser.Providers.MediaInfo;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.Providers.Tests.MediaInfo
+{
+    public class SubtitleResolverTests
+    {
+        public static TheoryData<List<MediaStream>, string, int, string[], MediaStream[]> AddExternalSubtitleStreams_GivenMixedFilenames_ReturnsValidSubtitles_TestData()
+        {
+            var data = new TheoryData<List<MediaStream>, string, int, string[], MediaStream[]>();
+
+            var index = 0;
+            data.Add(
+                new List<MediaStream>(),
+                "/video/My.Video.mkv",
+                index,
+                new[]
+                {
+                    "/video/My.Video.mp3",
+                    "/video/My.Video.png",
+                    "/video/My.Video.srt",
+                    "/video/My.Video.txt",
+                    "/video/My.Video.vtt",
+                    "/video/My.Video.ass",
+                    "/video/My.Video.sub",
+                    "/video/My.Video.ssa",
+                    "/video/My.Video.smi",
+                    "/video/My.Video.sami",
+                    "/video/My.Video.en.srt",
+                    "/video/My.Video.default.en.srt",
+                    "/video/My.Video.default.forced.en.srt",
+                    "/video/My.Video.en.default.forced.srt",
+                    "/video/My.Video.With.Additional.Garbage.en.srt",
+                    "/video/My.Video With Additional Garbage.srt"
+                },
+                new[]
+                {
+                    CreateMediaStream("/video/My.Video.srt", "srt", null, index++),
+                    CreateMediaStream("/video/My.Video.vtt", "vtt", null, index++),
+                    CreateMediaStream("/video/My.Video.ass", "ass", null, index++),
+                    CreateMediaStream("/video/My.Video.sub", "sub", null, index++),
+                    CreateMediaStream("/video/My.Video.ssa", "ssa", null, index++),
+                    CreateMediaStream("/video/My.Video.smi", "smi", null, index++),
+                    CreateMediaStream("/video/My.Video.sami", "sami", null, index++),
+                    CreateMediaStream("/video/My.Video.en.srt", "srt", "en", index++),
+                    CreateMediaStream("/video/My.Video.default.en.srt", "srt", "en", index++, isDefault: true),
+                    CreateMediaStream("/video/My.Video.default.forced.en.srt", "srt", "en", index++, isForced: true, isDefault: true),
+                    CreateMediaStream("/video/My.Video.en.default.forced.srt", "srt", "en", index++, isForced: true, isDefault: true),
+                    CreateMediaStream("/video/My.Video.With.Additional.Garbage.en.srt", "srt", "en", index),
+                });
+
+            return data;
+        }
+
+        [Theory]
+        [MemberData(nameof(AddExternalSubtitleStreams_GivenMixedFilenames_ReturnsValidSubtitles_TestData))]
+        public void AddExternalSubtitleStreams_GivenMixedFilenames_ReturnsValidSubtitles(List<MediaStream> streams, string videoPath, int startIndex, string[] files, MediaStream[] expectedResult)
+        {
+            new SubtitleResolver(Mock.Of<ILocalizationManager>()).AddExternalSubtitleStreams(streams, videoPath, startIndex, files);
+
+            Assert.Equal(expectedResult.Length, streams.Count);
+            for (var i = 0; i < expectedResult.Length; i++)
+            {
+                var expected = expectedResult[i];
+                var actual = streams[i];
+
+                Assert.Equal(expected.Index, actual.Index);
+                Assert.Equal(expected.Type, actual.Type);
+                Assert.Equal(expected.IsExternal, actual.IsExternal);
+                Assert.Equal(expected.Path, actual.Path);
+                Assert.Equal(expected.IsDefault, actual.IsDefault);
+                Assert.Equal(expected.IsForced, actual.IsForced);
+                Assert.Equal(expected.Language, actual.Language);
+            }
+        }
+
+        [Theory]
+        [InlineData("/video/My Video.mkv", "/video/My Video.srt", "srt", null, false, false)]
+        [InlineData("/video/My.Video.mkv", "/video/My.Video.srt", "srt", null, false, false)]
+        [InlineData("/video/My.Video.mkv", "/video/My.Video.foreign.srt", "srt", null, true, false)]
+        [InlineData("/video/My Video.mkv", "/video/My Video.forced.srt", "srt", null, true, false)]
+        [InlineData("/video/My.Video.mkv", "/video/My.Video.default.srt", "srt", null, false, true)]
+        [InlineData("/video/My.Video.mkv", "/video/My.Video.forced.default.srt", "srt", null, true, true)]
+        [InlineData("/video/My.Video.mkv", "/video/My.Video.en.srt", "srt", "en", false, false)]
+        [InlineData("/video/My.Video.mkv", "/video/My.Video.default.en.srt", "srt", "en", false, true)]
+        [InlineData("/video/My.Video.mkv", "/video/My.Video.default.forced.en.srt", "srt", "en", true, true)]
+        [InlineData("/video/My.Video.mkv", "/video/My.Video.en.default.forced.srt", "srt", "en", true, true)]
+        public void AddExternalSubtitleStreams_GivenSingleFile_ReturnsExpectedSubtitle(string videoPath, string file, string codec, string? language, bool isForced, bool isDefault)
+        {
+            var streams = new List<MediaStream>();
+            var expected = CreateMediaStream(file, codec, language, 0, isForced, isDefault);
+
+            new SubtitleResolver(Mock.Of<ILocalizationManager>()).AddExternalSubtitleStreams(streams, videoPath, 0, new[] { file });
+
+            Assert.Single(streams);
+
+            var actual = streams[0];
+
+            Assert.Equal(expected.Index, actual.Index);
+            Assert.Equal(expected.Type, actual.Type);
+            Assert.Equal(expected.IsExternal, actual.IsExternal);
+            Assert.Equal(expected.Path, actual.Path);
+            Assert.Equal(expected.IsDefault, actual.IsDefault);
+            Assert.Equal(expected.IsForced, actual.IsForced);
+            Assert.Equal(expected.Language, actual.Language);
+        }
+
+        private static MediaStream CreateMediaStream(string path, string codec, string? language, int index, bool isForced = false, bool isDefault = false)
+        {
+            return new ()
+            {
+                Index = index,
+                Codec = codec,
+                Type = MediaStreamType.Subtitle,
+                IsExternal = true,
+                Path = path,
+                IsDefault = isDefault,
+                IsForced = isForced,
+                Language = language
+            };
+        }
+    }
+}
diff --git a/tests/Jellyfin.Providers.Tests/MediaInfo/VideoImageProviderTests.cs b/tests/Jellyfin.Providers.Tests/MediaInfo/VideoImageProviderTests.cs
new file mode 100644
index 000000000..839925dd1
--- /dev/null
+++ b/tests/Jellyfin.Providers.Tests/MediaInfo/VideoImageProviderTests.cs
@@ -0,0 +1,126 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.MediaEncoding;
+using MediaBrowser.Controller.Persistence;
+using MediaBrowser.Model.Drawing;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Providers.MediaInfo;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.Providers.Tests.MediaInfo
+{
+    public class VideoImageProviderTests
+    {
+        private static TheoryData<Video> GetImage_UnsupportedInput_ReturnsNoImage_TestData()
+        {
+            return new ()
+            {
+                new Movie { IsPlaceHolder = true },
+
+                new Movie { DefaultVideoStreamIndex = null },
+
+                // set a default index but don't put anything there (invalid input, but provider shouldn't break)
+                new Movie { DefaultVideoStreamIndex = 0 }
+            };
+        }
+
+        [Theory]
+        [MemberData(nameof(GetImage_UnsupportedInput_ReturnsNoImage_TestData))]
+        public async void GetImage_UnsupportedInput_ReturnsNoImage(Video input)
+        {
+            var mediaSourceManager = GetMediaSourceManager(input, null, new List<MediaStream>());
+            var videoImageProvider = new VideoImageProvider(mediaSourceManager, Mock.Of<IMediaEncoder>(), new NullLogger<VideoImageProvider>());
+
+            var actual = await videoImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
+            Assert.NotNull(actual);
+            Assert.False(actual.HasImage);
+        }
+
+        [Theory]
+        [InlineData(1, 1)] // default not first stream
+        [InlineData(5, 0)] // default out of valid range
+        public async void GetImage_DefaultVideoStreams_ReturnsCorrectStreamImage(int defaultIndex, int targetIndex)
+        {
+            var input = new Movie { DefaultVideoStreamIndex = defaultIndex };
+
+            string targetPath = "path.jpg";
+            var mediaStreams = new List<MediaStream>();
+            var mediaEncoder = new Mock<IMediaEncoder>(MockBehavior.Strict);
+
+            for (int i = 0; i <= targetIndex; i++)
+            {
+                var mediaStream = new MediaStream { Type = MediaStreamType.Video, Index = i };
+                mediaStreams.Add(mediaStream);
+
+                var path = i == targetIndex ? targetPath : "wrong stream called!";
+                mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<MediaSourceInfo>(), mediaStream, It.IsAny<Video3DFormat?>(), It.IsAny<TimeSpan?>(), It.IsAny<CancellationToken>()))
+                    .Returns(Task.FromResult(path));
+            }
+
+            var defaultStream = defaultIndex < mediaStreams.Count ? mediaStreams[targetIndex] : null;
+            var mediaSourceManager = GetMediaSourceManager(input, defaultStream, mediaStreams);
+
+            var videoImageProvider = new VideoImageProvider(mediaSourceManager, mediaEncoder.Object, new NullLogger<VideoImageProvider>());
+
+            var actual = await videoImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
+            Assert.NotNull(actual);
+            Assert.True(actual.HasImage);
+            Assert.Equal(targetPath, actual.Path);
+            Assert.Equal(ImageFormat.Jpg, actual.Format);
+        }
+
+        [Theory]
+        [InlineData(null, 10)] // default time
+        [InlineData(500, 50)] // calculated time
+        public async void GetImage_TimeSpan_SelectsCorrectTime(int? runTimeSeconds, long expectedSeconds)
+        {
+            MediaStream targetStream = new () { Type = MediaStreamType.Video, Index = 0 };
+            var input = new Movie
+            {
+                DefaultVideoStreamIndex = 0,
+                RunTimeTicks = runTimeSeconds * TimeSpan.TicksPerSecond
+            };
+
+            var mediaSourceManager = GetMediaSourceManager(input, targetStream, new List<MediaStream> { targetStream });
+
+            // use a callback to catch the actual value
+            // provides more information on failure than verifying a specific input was called on the mock
+            TimeSpan? actualTimeSpan = null;
+            var mediaEncoder = new Mock<IMediaEncoder>(MockBehavior.Strict);
+            mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<MediaSourceInfo>(), It.IsAny<MediaStream>(), It.IsAny<Video3DFormat?>(), It.IsAny<TimeSpan?>(), CancellationToken.None))
+                .Callback<string, string, MediaSourceInfo, MediaStream, Video3DFormat?, TimeSpan?, CancellationToken>((_, _, _, _, _, timeSpan, _) => actualTimeSpan = timeSpan)
+                .Returns(Task.FromResult("path"));
+
+            var videoImageProvider = new VideoImageProvider(mediaSourceManager, mediaEncoder.Object, new NullLogger<VideoImageProvider>());
+
+            // not testing return, just verifying what gets requested for time span
+            await videoImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
+
+            Assert.Equal(TimeSpan.FromSeconds(expectedSeconds), actualTimeSpan);
+        }
+
+        private static IMediaSourceManager GetMediaSourceManager(Video item, MediaStream? defaultStream, List<MediaStream> mediaStreams)
+        {
+            var defaultStreamList = new List<MediaStream>();
+            if (defaultStream != null)
+            {
+                defaultStreamList.Add(defaultStream);
+            }
+
+            var mediaSourceManager = new Mock<IMediaSourceManager>(MockBehavior.Strict);
+            mediaSourceManager.Setup(i => i.GetMediaStreams(It.Is<MediaStreamQuery>(q => q.ItemId == item.Id && q.Index == item.DefaultVideoStreamIndex)))
+                .Returns(defaultStreamList);
+            mediaSourceManager.Setup(i => i.GetMediaStreams(It.Is<MediaStreamQuery>(q => q.ItemId == item.Id && q.Type == MediaStreamType.Video)))
+                .Returns(mediaStreams);
+            return mediaSourceManager.Object;
+        }
+    }
+}
diff --git a/tests/Jellyfin.Common.Tests/Json/JsonOmdbConverterTests.cs b/tests/Jellyfin.Providers.Tests/Omdb/JsonOmdbConverterTests.cs
index faed086a1..25900bc09 100644
--- a/tests/Jellyfin.Common.Tests/Json/JsonOmdbConverterTests.cs
+++ b/tests/Jellyfin.Providers.Tests/Omdb/JsonOmdbConverterTests.cs
@@ -1,10 +1,9 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
-using MediaBrowser.Common.Json.Converters;
 using MediaBrowser.Providers.Plugins.Omdb;
 using Xunit;
 
-namespace Jellyfin.Common.Tests.Json
+namespace Jellyfin.Providers.Tests.Omdb
 {
     public class JsonOmdbConverterTests
     {
@@ -39,6 +38,15 @@ namespace Jellyfin.Common.Tests.Json
         }
 
         [Theory]
+        [InlineData("\"8\"", 8)]
+        [InlineData("8", 8)]
+        public void Deserialize_NullableInt_Success(string input, int? expected)
+        {
+            var result = JsonSerializer.Deserialize<int?>(input, _options);
+            Assert.Equal(result, expected);
+        }
+
+        [Theory]
         [InlineData("\"N/A\"")]
         [InlineData("null")]
         public void Deserialization_To_Nullable_String_Shoud_Be_Null(string input)
@@ -48,21 +56,11 @@ namespace Jellyfin.Common.Tests.Json
         }
 
         [Theory]
-        [InlineData("\"8\"", 8)]
-        [InlineData("8", 8)]
-        public void Deserialize_Int_Success(string input, int expected)
-        {
-            var result = JsonSerializer.Deserialize<int>(input, _options);
-            Assert.Equal(result, expected);
-        }
-
-        [Fact]
-        public void Deserialize_Normal_String_Success()
+        [InlineData("\"Jellyfin\"", "Jellyfin")]
+        public void Deserialize_Normal_String_Success(string input, string expected)
         {
-            const string Input = "\"Jellyfin\"";
-            const string Expected = "Jellyfin";
-            var result = JsonSerializer.Deserialize<string>(Input, _options);
-            Assert.Equal(Expected, result);
+            var result = JsonSerializer.Deserialize<string?>(input, _options);
+            Assert.Equal(expected, result);
         }
 
         [Fact]
diff --git a/tests/Jellyfin.Providers.Tests/Test Data/Images/blank0.jpg b/tests/Jellyfin.Providers.Tests/Test Data/Images/blank0.jpg
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/Jellyfin.Providers.Tests/Test Data/Images/blank0.jpg
diff --git a/tests/Jellyfin.Providers.Tests/Test Data/Images/blank1.jpg b/tests/Jellyfin.Providers.Tests/Test Data/Images/blank1.jpg
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/Jellyfin.Providers.Tests/Test Data/Images/blank1.jpg
diff --git a/tests/Jellyfin.Providers.Tests/Tmdb/TmdbUtilsTests.cs b/tests/Jellyfin.Providers.Tests/Tmdb/TmdbUtilsTests.cs
new file mode 100644
index 000000000..efd2d9553
--- /dev/null
+++ b/tests/Jellyfin.Providers.Tests/Tmdb/TmdbUtilsTests.cs
@@ -0,0 +1,40 @@
+using MediaBrowser.Providers.Plugins.Tmdb;
+using Xunit;
+
+namespace Jellyfin.Providers.Tests.Tmdb
+{
+    public static class TmdbUtilsTests
+    {
+        [Theory]
+        [InlineData("de", "de")]
+        [InlineData("En", "En")]
+        [InlineData("de-de", "de-DE")]
+        [InlineData("en-US", "en-US")]
+        [InlineData("de-CH", "de")]
+        public static void NormalizeLanguage_Valid_Success(string input, string expected)
+        {
+            Assert.Equal(expected, TmdbUtils.NormalizeLanguage(input));
+        }
+
+        [Theory]
+        [InlineData(null, null)]
+        [InlineData("", "")]
+        public static void NormalizeLanguage_Invalid_Equal(string? input, string? expected)
+        {
+            Assert.Equal(expected, TmdbUtils.NormalizeLanguage(input!));
+        }
+
+        [Theory]
+        [InlineData(null, null, null)]
+        [InlineData(null, "en-US", null)]
+        [InlineData("en", null, "en")]
+        [InlineData("en", "en-US", "en-US")]
+        [InlineData("fr-CA", "fr-BE", "fr-CA")]
+        [InlineData("fr-CA", "fr", "fr-CA")]
+        [InlineData("de", "en-US", "de")]
+        public static void AdjustImageLanguage_Valid_Success(string imageLanguage, string requestLanguage, string expected)
+        {
+            Assert.Equal(expected, TmdbUtils.AdjustImageLanguage(imageLanguage, requestLanguage));
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Data/SqliteItemRepositoryTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Data/SqliteItemRepositoryTests.cs
new file mode 100644
index 000000000..6337dea41
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Data/SqliteItemRepositoryTests.cs
@@ -0,0 +1,290 @@
+using System;
+using System.Collections.Generic;
+using AutoFixture;
+using AutoFixture.AutoMoq;
+using Emby.Server.Implementations.Data;
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Model.Entities;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.Data
+{
+    public class SqliteItemRepositoryTests
+    {
+        public const string VirtualMetaDataPath = "%MetadataPath%";
+        public const string MetaDataPath = "/meta/data/path";
+
+        private readonly IFixture _fixture;
+        private readonly SqliteItemRepository _sqliteItemRepository;
+
+        public SqliteItemRepositoryTests()
+        {
+            var appHost = new Mock<IServerApplicationHost>();
+            appHost.Setup(x => x.ExpandVirtualPath(It.IsAny<string>()))
+                .Returns((string x) => x.Replace(VirtualMetaDataPath, MetaDataPath, StringComparison.Ordinal));
+            appHost.Setup(x => x.ReverseVirtualPath(It.IsAny<string>()))
+                .Returns((string x) => x.Replace(MetaDataPath, VirtualMetaDataPath, StringComparison.Ordinal));
+
+            _fixture = new Fixture().Customize(new AutoMoqCustomization { ConfigureMembers = true });
+            _fixture.Inject(appHost);
+            _sqliteItemRepository = _fixture.Create<SqliteItemRepository>();
+        }
+
+        public static TheoryData<string, ItemImageInfo> ItemImageInfoFromValueString_Valid_TestData()
+        {
+            var data = new TheoryData<string, ItemImageInfo>();
+
+            data.Add(
+                "/mnt/series/Family Guy/Season 1/Family Guy - S01E01-thumb.jpg*637452096478512963*Primary*1920*1080*WjQbtJtSO8nhNZ%L_Io#R/oaS6o}-;adXAoIn7j[%hW9s:WGw[nN",
+                new ItemImageInfo
+                {
+                    Path = "/mnt/series/Family Guy/Season 1/Family Guy - S01E01-thumb.jpg",
+                    Type = ImageType.Primary,
+                    DateModified = new DateTime(637452096478512963, DateTimeKind.Utc),
+                    Width = 1920,
+                    Height = 1080,
+                    BlurHash = "WjQbtJtSO8nhNZ%L_Io#R*oaS6o}-;adXAoIn7j[%hW9s:WGw[nN"
+                });
+
+            data.Add(
+                "https://image.tmdb.org/t/p/original/zhB5CHEgqqh4wnEqDNJLfWXJlcL.jpg*0*Primary*0*0",
+                new ItemImageInfo
+                {
+                    Path = "https://image.tmdb.org/t/p/original/zhB5CHEgqqh4wnEqDNJLfWXJlcL.jpg",
+                    Type = ImageType.Primary,
+                });
+
+            data.Add(
+                "https://image.tmdb.org/t/p/original/zhB5CHEgqqh4wnEqDNJLfWXJlcL.jpg*0*Primary",
+                new ItemImageInfo
+                {
+                    Path = "https://image.tmdb.org/t/p/original/zhB5CHEgqqh4wnEqDNJLfWXJlcL.jpg",
+                    Type = ImageType.Primary,
+                });
+
+            data.Add(
+                "https://image.tmdb.org/t/p/original/zhB5CHEgqqh4wnEqDNJLfWXJlcL.jpg*0*Primary*600",
+                new ItemImageInfo
+                {
+                    Path = "https://image.tmdb.org/t/p/original/zhB5CHEgqqh4wnEqDNJLfWXJlcL.jpg",
+                    Type = ImageType.Primary,
+                });
+
+            data.Add(
+                "%MetadataPath%/library/68/68578562b96c80a7ebd530848801f645/poster.jpg*637264380567586027*Primary*600*336",
+                new ItemImageInfo
+                {
+                    Path = "/meta/data/path/library/68/68578562b96c80a7ebd530848801f645/poster.jpg",
+                    Type = ImageType.Primary,
+                    DateModified = new DateTime(637264380567586027, DateTimeKind.Utc),
+                    Width = 600,
+                    Height = 336
+                });
+
+            return data;
+        }
+
+        [Theory]
+        [MemberData(nameof(ItemImageInfoFromValueString_Valid_TestData))]
+        public void ItemImageInfoFromValueString_Valid_Success(string value, ItemImageInfo expected)
+        {
+            var result = _sqliteItemRepository.ItemImageInfoFromValueString(value);
+            Assert.Equal(expected.Path, result.Path);
+            Assert.Equal(expected.Type, result.Type);
+            Assert.Equal(expected.DateModified, result.DateModified);
+            Assert.Equal(expected.Width, result.Width);
+            Assert.Equal(expected.Height, result.Height);
+            Assert.Equal(expected.BlurHash, result.BlurHash);
+        }
+
+        [Theory]
+        [InlineData("")]
+        [InlineData("*")]
+        [InlineData("https://image.tmdb.org/t/p/original/zhB5CHEgqqh4wnEqDNJLfWXJlcL.jpg*0")]
+        [InlineData("/mnt/series/Family Guy/Season 1/Family Guy - S01E01-thumb.jpg*6374520964785129080*WjQbtJtSO8nhNZ%L_Io#R/oaS<o}-;adXAoIn7j[%hW9s:WGw[nN")] // Invalid modified date
+        [InlineData("/mnt/series/Family Guy/Season 1/Family Guy - S01E01-thumb.jpg*-637452096478512963*WjQbtJtSO8nhNZ%L_Io#R/oaS<o}-;adXAoIn7j[%hW9s:WGw[nN")] // Negative modified date
+        [InlineData("/mnt/series/Family Guy/Season 1/Family Guy - S01E01-thumb.jpg*637452096478512963*Invalid*1920*1080*WjQbtJtSO8nhNZ%L_Io#R/oaS6o}-;adXAoIn7j[%hW9s:WGw[nN")] // Invalid type
+        public void ItemImageInfoFromValueString_Invalid_Null(string value)
+        {
+            Assert.Null(_sqliteItemRepository.ItemImageInfoFromValueString(value));
+        }
+
+        public static TheoryData<string, ItemImageInfo[]> DeserializeImages_Valid_TestData()
+        {
+            var data = new TheoryData<string, ItemImageInfo[]>();
+            data.Add(
+                "/mnt/series/Family Guy/Season 1/Family Guy - S01E01-thumb.jpg*637452096478512963*Primary*1920*1080*WjQbtJtSO8nhNZ%L_Io#R/oaS6o}-;adXAoIn7j[%hW9s:WGw[nN",
+                new ItemImageInfo[]
+                {
+                    new ItemImageInfo()
+                    {
+                        Path = "/mnt/series/Family Guy/Season 1/Family Guy - S01E01-thumb.jpg",
+                        Type = ImageType.Primary,
+                        DateModified = new DateTime(637452096478512963, DateTimeKind.Utc),
+                        Width = 1920,
+                        Height = 1080,
+                        BlurHash = "WjQbtJtSO8nhNZ%L_Io#R*oaS6o}-;adXAoIn7j[%hW9s:WGw[nN"
+                    }
+                });
+
+            data.Add(
+                "%MetadataPath%/library/2a/2a27372f1e9bc757b1db99721bbeae1e/poster.jpg*637261226720645297*Primary*0*0|%MetadataPath%/library/2a/2a27372f1e9bc757b1db99721bbeae1e/logo.png*637261226720805297*Logo*0*0|%MetadataPath%/library/2a/2a27372f1e9bc757b1db99721bbeae1e/landscape.jpg*637261226721285297*Thumb*0*0|%MetadataPath%/library/2a/2a27372f1e9bc757b1db99721bbeae1e/backdrop.jpg*637261226721685297*Backdrop*0*0",
+                new ItemImageInfo[]
+                {
+                    new ItemImageInfo()
+                    {
+                        Path = "/meta/data/path/library/2a/2a27372f1e9bc757b1db99721bbeae1e/poster.jpg",
+                        Type = ImageType.Primary,
+                        DateModified = new DateTime(637261226720645297, DateTimeKind.Utc),
+                    },
+                    new ItemImageInfo()
+                    {
+                        Path = "/meta/data/path/library/2a/2a27372f1e9bc757b1db99721bbeae1e/logo.png",
+                        Type = ImageType.Logo,
+                        DateModified = new DateTime(637261226720805297, DateTimeKind.Utc),
+                    },
+                    new ItemImageInfo()
+                    {
+                        Path = "/meta/data/path/library/2a/2a27372f1e9bc757b1db99721bbeae1e/landscape.jpg",
+                        Type = ImageType.Thumb,
+                        DateModified = new DateTime(637261226721285297, DateTimeKind.Utc),
+                    },
+                    new ItemImageInfo()
+                    {
+                        Path = "/meta/data/path/library/2a/2a27372f1e9bc757b1db99721bbeae1e/backdrop.jpg",
+                        Type = ImageType.Backdrop,
+                        DateModified = new DateTime(637261226721685297, DateTimeKind.Utc),
+                    }
+                });
+
+            return data;
+        }
+
+        public static TheoryData<string, ItemImageInfo[]> DeserializeImages_ValidAndInvalid_TestData()
+        {
+            var data = new TheoryData<string, ItemImageInfo[]>();
+            data.Add(
+                string.Empty,
+                Array.Empty<ItemImageInfo>());
+
+            data.Add(
+                "/mnt/series/Family Guy/Season 1/Family Guy - S01E01-thumb.jpg*637452096478512963*Primary*1920*1080*WjQbtJtSO8nhNZ%L_Io#R/oaS6o}-;adXAoIn7j[%hW9s:WGw[nN|test|1234||ss",
+                new ItemImageInfo[]
+                {
+                    new ()
+                    {
+                        Path = "/mnt/series/Family Guy/Season 1/Family Guy - S01E01-thumb.jpg",
+                        Type = ImageType.Primary,
+                        DateModified = new DateTime(637452096478512963, DateTimeKind.Utc),
+                        Width = 1920,
+                        Height = 1080,
+                        BlurHash = "WjQbtJtSO8nhNZ%L_Io#R*oaS6o}-;adXAoIn7j[%hW9s:WGw[nN"
+                    }
+                });
+
+            data.Add(
+                "|",
+                Array.Empty<ItemImageInfo>());
+
+            return data;
+        }
+
+        [Theory]
+        [MemberData(nameof(DeserializeImages_Valid_TestData))]
+        public void DeserializeImages_Valid_Success(string value, ItemImageInfo[] expected)
+        {
+            var result = _sqliteItemRepository.DeserializeImages(value);
+            Assert.Equal(expected.Length, result.Length);
+            for (int i = 0; i < expected.Length; i++)
+            {
+                Assert.Equal(expected[i].Path, result[i].Path);
+                Assert.Equal(expected[i].Type, result[i].Type);
+                Assert.Equal(expected[i].DateModified, result[i].DateModified);
+                Assert.Equal(expected[i].Width, result[i].Width);
+                Assert.Equal(expected[i].Height, result[i].Height);
+                Assert.Equal(expected[i].BlurHash, result[i].BlurHash);
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(DeserializeImages_ValidAndInvalid_TestData))]
+        public void DeserializeImages_ValidAndInvalid_Success(string value, ItemImageInfo[] expected)
+        {
+            var result = _sqliteItemRepository.DeserializeImages(value);
+            Assert.Equal(expected.Length, result.Length);
+            for (int i = 0; i < expected.Length; i++)
+            {
+                Assert.Equal(expected[i].Path, result[i].Path);
+                Assert.Equal(expected[i].Type, result[i].Type);
+                Assert.Equal(expected[i].DateModified, result[i].DateModified);
+                Assert.Equal(expected[i].Width, result[i].Width);
+                Assert.Equal(expected[i].Height, result[i].Height);
+                Assert.Equal(expected[i].BlurHash, result[i].BlurHash);
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(DeserializeImages_Valid_TestData))]
+        public void SerializeImages_Valid_Success(string expected, ItemImageInfo[] value)
+        {
+            Assert.Equal(expected, _sqliteItemRepository.SerializeImages(value));
+        }
+
+        public static TheoryData<string, Dictionary<string, string>> DeserializeProviderIds_Valid_TestData()
+        {
+            var data = new TheoryData<string, Dictionary<string, string>>();
+
+            data.Add(
+                "Imdb=tt0119567",
+                new Dictionary<string, string>()
+                {
+                    { "Imdb", "tt0119567" },
+                });
+
+            data.Add(
+                "Imdb=tt0119567|Tmdb=330|TmdbCollection=328",
+                new Dictionary<string, string>()
+                {
+                    { "Imdb", "tt0119567" },
+                    { "Tmdb", "330" },
+                    { "TmdbCollection", "328" },
+                });
+
+            data.Add(
+                "MusicBrainzAlbum=9d363e43-f24f-4b39-bc5a-7ef305c677c7|MusicBrainzReleaseGroup=63eba062-847c-3b73-8b0f-6baf27bba6fa|AudioDbArtist=111352|AudioDbAlbum=2116560|MusicBrainzAlbumArtist=20244d07-534f-4eff-b4d4-930878889970",
+                new Dictionary<string, string>()
+                {
+                    { "MusicBrainzAlbum", "9d363e43-f24f-4b39-bc5a-7ef305c677c7" },
+                    { "MusicBrainzReleaseGroup", "63eba062-847c-3b73-8b0f-6baf27bba6fa" },
+                    { "AudioDbArtist", "111352" },
+                    { "AudioDbAlbum", "2116560" },
+                    { "MusicBrainzAlbumArtist", "20244d07-534f-4eff-b4d4-930878889970" },
+                });
+
+            return data;
+        }
+
+        [Theory]
+        [MemberData(nameof(DeserializeProviderIds_Valid_TestData))]
+        public void DeserializeProviderIds_Valid_Success(string value, Dictionary<string, string> expected)
+        {
+            var result = new ProviderIdsExtensionsTestsObject();
+            SqliteItemRepository.DeserializeProviderIds(value, result);
+            Assert.Equal(expected, result.ProviderIds);
+        }
+
+        [Theory]
+        [MemberData(nameof(DeserializeProviderIds_Valid_TestData))]
+        public void SerializeProviderIds_Valid_Success(string expected, Dictionary<string, string> values)
+        {
+            Assert.Equal(expected, SqliteItemRepository.SerializeProviderIds(values));
+        }
+
+        private class ProviderIdsExtensionsTestsObject : IHasProviderIds
+        {
+            public Dictionary<string, string> ProviderIds { get; set; } = new Dictionary<string, string>();
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/HttpServer/WebSocketConnectionTests.cs b/tests/Jellyfin.Server.Implementations.Tests/HttpServer/WebSocketConnectionTests.cs
new file mode 100644
index 000000000..1ce2096ea
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/HttpServer/WebSocketConnectionTests.cs
@@ -0,0 +1,69 @@
+using System;
+using System.Buffers;
+using System.IO;
+using System.Text.Json;
+using Emby.Server.Implementations.HttpServer;
+using Microsoft.Extensions.Logging.Abstractions;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.HttpServer
+{
+    public class WebSocketConnectionTests
+    {
+        [Fact]
+        public void DeserializeWebSocketMessage_SingleSegment_Success()
+        {
+            var con = new WebSocketConnection(new NullLogger<WebSocketConnection>(), null!, null!, null!);
+            var bytes = File.ReadAllBytes("Test Data/HttpServer/ForceKeepAlive.json");
+            con.DeserializeWebSocketMessage(new ReadOnlySequence<byte>(bytes), out var bytesConsumed);
+            Assert.Equal(109, bytesConsumed);
+        }
+
+        [Fact]
+        public void DeserializeWebSocketMessage_MultipleSegments_Success()
+        {
+            const int SplitPos = 64;
+            var con = new WebSocketConnection(new NullLogger<WebSocketConnection>(), null!, null!, null!);
+            var bytes = File.ReadAllBytes("Test Data/HttpServer/ForceKeepAlive.json");
+            var seg1 = new BufferSegment(new Memory<byte>(bytes, 0, SplitPos));
+            var seg2 = seg1.Append(new Memory<byte>(bytes, SplitPos, bytes.Length - SplitPos));
+            con.DeserializeWebSocketMessage(new ReadOnlySequence<byte>(seg1, 0, seg2, seg2.Memory.Length - 1), out var bytesConsumed);
+            Assert.Equal(109, bytesConsumed);
+        }
+
+        [Fact]
+        public void DeserializeWebSocketMessage_ValidPartial_Success()
+        {
+            var con = new WebSocketConnection(new NullLogger<WebSocketConnection>(), null!, null!, null!);
+            var bytes = File.ReadAllBytes("Test Data/HttpServer/ValidPartial.json");
+            con.DeserializeWebSocketMessage(new ReadOnlySequence<byte>(bytes), out var bytesConsumed);
+            Assert.Equal(109, bytesConsumed);
+        }
+
+        [Fact]
+        public void DeserializeWebSocketMessage_Partial_ThrowJsonException()
+        {
+            var con = new WebSocketConnection(new NullLogger<WebSocketConnection>(), null!, null!, null!);
+            var bytes = File.ReadAllBytes("Test Data/HttpServer/Partial.json");
+            Assert.Throws<JsonException>(() => con.DeserializeWebSocketMessage(new ReadOnlySequence<byte>(bytes), out var bytesConsumed));
+        }
+
+        internal class BufferSegment : ReadOnlySequenceSegment<byte>
+        {
+            public BufferSegment(Memory<byte> memory)
+            {
+                Memory = memory;
+            }
+
+            public BufferSegment Append(Memory<byte> memory)
+            {
+                var segment = new BufferSegment(memory)
+                {
+                    RunningIndex = RunningIndex + Memory.Length
+                };
+                Next = segment;
+                return segment;
+            }
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/IO/ManagedFileSystemTests.cs b/tests/Jellyfin.Server.Implementations.Tests/IO/ManagedFileSystemTests.cs
index 671c59b2e..d991f5574 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/IO/ManagedFileSystemTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/IO/ManagedFileSystemTests.cs
@@ -1,7 +1,10 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Runtime.InteropServices;
 using AutoFixture;
 using AutoFixture.AutoMoq;
 using Emby.Server.Implementations.IO;
-using MediaBrowser.Model.System;
 using Xunit;
 
 namespace Jellyfin.Server.Implementations.Tests.IO
@@ -28,7 +31,7 @@ namespace Jellyfin.Server.Implementations.Tests.IO
         {
             var generatedPath = _sut.MakeAbsolutePath(folderPath, filePath);
 
-            if (MediaBrowser.Common.System.OperatingSystem.Id == OperatingSystemId.Windows)
+            if (OperatingSystem.IsWindows())
             {
                 var expectedWindowsPath = expectedAbsolutePath.Replace('/', '\\');
                 Assert.Equal(expectedWindowsPath, generatedPath.Split(':')[1]);
@@ -38,5 +41,36 @@ namespace Jellyfin.Server.Implementations.Tests.IO
                 Assert.Equal(expectedAbsolutePath, generatedPath);
             }
         }
+
+        [Theory]
+        [InlineData("ValidFileName", "ValidFileName")]
+        [InlineData("AC/DC", "AC DC")]
+        [InlineData("Invalid\0", "Invalid ")]
+        [InlineData("AC/DC\0KD/A", "AC DC KD A")]
+        public void GetValidFilename_ReturnsValidFilename(string filename, string expectedFileName)
+        {
+            Assert.Equal(expectedFileName, _sut.GetValidFilename(filename));
+        }
+
+        [SkippableFact]
+        public void GetFileInfo_DanglingSymlink_ExistsFalse()
+        {
+            Skip.If(OperatingSystem.IsWindows());
+
+            string testFileDir = Path.Combine(Path.GetTempPath(), "jellyfin-test-data");
+            string testFileName = Path.Combine(testFileDir, Path.GetRandomFileName() + "-danglingsym.link");
+
+            Directory.CreateDirectory(testFileDir);
+            Assert.Equal(0, symlink("thispathdoesntexist", testFileName));
+            Assert.True(File.Exists(testFileName));
+
+            var metadata = _sut.GetFileInfo(testFileName);
+            Assert.False(metadata.Exists);
+        }
+
+        [SuppressMessage("Naming Rules", "SA1300:ElementMustBeginWithUpperCaseLetter", Justification = "Have to")]
+        [DllImport("libc", SetLastError = true, CharSet = CharSet.Ansi)]
+        [DefaultDllImportSearchPaths(DllImportSearchPath.UserDirectories)]
+        private static extern int symlink(string target, string linkpath);
     }
 }
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Jellyfin.Server.Implementations.Tests.csproj b/tests/Jellyfin.Server.Implementations.Tests/Jellyfin.Server.Implementations.Tests.csproj
index 5c4170514..028ebdf55 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Jellyfin.Server.Implementations.Tests.csproj
+++ b/tests/Jellyfin.Server.Implementations.Tests/Jellyfin.Server.Implementations.Tests.csproj
@@ -6,26 +6,31 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
     <IsPackable>false</IsPackable>
-    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-    <Nullable>enable</Nullable>
+    <CodeAnalysisRuleSet>../jellyfin-tests.ruleset</CodeAnalysisRuleSet>
     <RootNamespace>Jellyfin.Server.Implementations.Tests</RootNamespace>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="AutoFixture" Version="4.15.0" />
-    <PackageReference Include="AutoFixture.AutoMoq" Version="4.15.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3" />
-    <PackageReference Include="Moq" Version="4.15.2" />
+    <None Include="Test Data\**\*.*">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="AutoFixture" Version="4.17.0" />
+    <PackageReference Include="AutoFixture.AutoMoq" Version="4.17.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
+    <PackageReference Include="Moq" Version="4.16.1" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" />
-    <PackageReference Include="coverlet.collector" Version="3.0.0" />
+    <PackageReference Include="Xunit.SkippableFact" Version="1.4.13" />
+    <PackageReference Include="coverlet.collector" Version="3.1.0" />
   </ItemGroup>
 
   <!-- Code Analyzers -->
   <ItemGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="2.9.8" PrivateAssets="All" />
     <PackageReference Include="SerilogAnalyzer" Version="0.15.0" PrivateAssets="All" />
     <PackageReference Include="StyleCop.Analyzers" Version="1.1.118" PrivateAssets="All" />
     <PackageReference Include="SmartAnalyzers.MultithreadingAnalyzer" Version="1.1.31" PrivateAssets="All" />
@@ -33,15 +38,8 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\Emby.Server.Implementations\Emby.Server.Implementations.csproj" />
+    <ProjectReference Include="..\..\Jellyfin.Server.Implementations\Jellyfin.Server.Implementations.csproj" />
+    <ProjectReference Include="..\Jellyfin.Server.Integration.Tests\Jellyfin.Server.Integration.Tests.csproj" />
   </ItemGroup>
 
-  <ItemGroup>
-    <EmbeddedResource Include="LiveTv\discover.json" />
-    <EmbeddedResource Include="LiveTv\lineup.json" />
-  </ItemGroup>
-
-  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <CodeAnalysisRuleSet>../jellyfin-tests.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-
 </Project>
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/EpisodeResolverTest.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/EpisodeResolverTest.cs
new file mode 100644
index 000000000..362c3216f
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/EpisodeResolverTest.cs
@@ -0,0 +1,71 @@
+using Emby.Naming.Common;
+using Emby.Server.Implementations.Library.Resolvers.TV;
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.IO;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.Library
+{
+    public class EpisodeResolverTest
+    {
+        private static readonly NamingOptions _namingOptions = new ();
+
+        [Fact]
+        public void Resolve_GivenVideoInExtrasFolder_DoesNotResolveToEpisode()
+        {
+            var parent = new Folder { Name = "extras" };
+
+            var episodeResolver = new EpisodeResolver(_namingOptions);
+            var itemResolveArgs = new ItemResolveArgs(
+                Mock.Of<IServerApplicationPaths>(),
+                Mock.Of<IDirectoryService>())
+            {
+                Parent = parent,
+                CollectionType = CollectionType.TvShows,
+                FileInfo = new FileSystemMetadata
+                {
+                    FullName = "All My Children/Season 01/Extras/All My Children S01E01 - Behind The Scenes.mkv"
+                }
+            };
+
+            Assert.Null(episodeResolver.Resolve(itemResolveArgs));
+        }
+
+        [Fact]
+        public void Resolve_GivenVideoInExtrasSeriesFolder_ResolvesToEpisode()
+        {
+            var series = new Series { Name = "Extras" };
+
+            // Have to create a mock because of moq proxies not being castable to a concrete implementation
+            // https://github.com/jellyfin/jellyfin/blob/ab0cff8556403e123642dc9717ba778329554634/Emby.Server.Implementations/Library/Resolvers/BaseVideoResolver.cs#L48
+            var episodeResolver = new EpisodeResolverMock(_namingOptions);
+            var itemResolveArgs = new ItemResolveArgs(
+                Mock.Of<IServerApplicationPaths>(),
+                Mock.Of<IDirectoryService>())
+            {
+                Parent = series,
+                CollectionType = CollectionType.TvShows,
+                FileInfo = new FileSystemMetadata
+                {
+                    FullName = "Extras/Extras S01E01.mkv"
+                }
+            };
+            Assert.NotNull(episodeResolver.Resolve(itemResolveArgs));
+        }
+
+        private class EpisodeResolverMock : EpisodeResolver
+        {
+            public EpisodeResolverMock(NamingOptions namingOptions) : base(namingOptions)
+            {
+            }
+
+            protected override TVideoType ResolveVideo<TVideoType>(ItemResolveArgs args, bool parseName) => new ();
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/LibraryManager/FindExtrasTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/LibraryManager/FindExtrasTests.cs
new file mode 100644
index 000000000..b29426d85
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/LibraryManager/FindExtrasTests.cs
@@ -0,0 +1,232 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using AutoFixture;
+using AutoFixture.AutoMoq;
+using Emby.Naming.Common;
+using Emby.Server.Implementations.Library.Resolvers;
+using Emby.Server.Implementations.Library.Resolvers.Audio;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Controller.Resolvers;
+using MediaBrowser.Controller.Sorting;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.IO;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.Library.LibraryManager;
+
+public class FindExtrasTests
+{
+    private readonly Emby.Server.Implementations.Library.LibraryManager _libraryManager;
+    private readonly Mock<IFileSystem> _fileSystemMock;
+
+    public FindExtrasTests()
+    {
+        var fixture = new Fixture().Customize(new AutoMoqCustomization());
+        fixture.Register(() => new NamingOptions());
+        var configMock = fixture.Freeze<Mock<IServerConfigurationManager>>();
+        configMock.Setup(c => c.ApplicationPaths.ProgramDataPath).Returns("/data");
+        _fileSystemMock = fixture.Freeze<Mock<IFileSystem>>();
+        _fileSystemMock.Setup(f => f.GetFileInfo(It.IsAny<string>())).Returns<string>(path => new FileSystemMetadata { FullName = path });
+        _libraryManager = fixture.Build<Emby.Server.Implementations.Library.LibraryManager>().Do(s => s.AddParts(
+                fixture.Create<IEnumerable<IResolverIgnoreRule>>(),
+                new List<IItemResolver> { new GenericVideoResolver<Video>(fixture.Create<NamingOptions>()), new AudioResolver(fixture.Create<NamingOptions>()) },
+                fixture.Create<IEnumerable<IIntroProvider>>(),
+                fixture.Create<IEnumerable<IBaseItemComparer>>(),
+                fixture.Create<IEnumerable<ILibraryPostScanTask>>()))
+            .Create();
+
+        // This is pretty terrible but unavoidable
+        BaseItem.FileSystem ??= fixture.Create<IFileSystem>();
+        BaseItem.MediaSourceManager ??= fixture.Create<IMediaSourceManager>();
+    }
+
+    [Fact]
+    public void FindExtras_SeparateMovieFolder_FindsCorrectExtras()
+    {
+        var owner = new Movie { Name = "Up", Path = "/movies/Up/Up.mkv" };
+        var paths = new List<string>
+        {
+            "/movies/Up/Up.mkv",
+            "/movies/Up/Up - trailer.mkv",
+            "/movies/Up/Up - sample.mkv",
+            "/movies/Up/Up something else.mkv"
+        };
+
+        var files = paths.Select(p => new FileSystemMetadata
+        {
+            FullName = p,
+            IsDirectory = false
+        }).ToList();
+
+        var extras = _libraryManager.FindExtras(owner, files, new DirectoryService(_fileSystemMock.Object)).OrderBy(e => e.ExtraType).ToList();
+
+        Assert.Equal(2, extras.Count);
+        Assert.Equal(ExtraType.Trailer, extras[0].ExtraType);
+        Assert.Equal(ExtraType.Sample, extras[1].ExtraType);
+    }
+
+    [Fact]
+    public void FindExtras_SeparateMovieFolderWithMixedExtras_FindsCorrectExtras()
+    {
+        var owner = new Movie { Name = "Up", Path = "/movies/Up/Up.mkv" };
+        var paths = new List<string>
+        {
+            "/movies/Up/Up.mkv",
+            "/movies/Up/Up - trailer.mkv",
+            "/movies/Up/trailers",
+            "/movies/Up/theme-music",
+            "/movies/Up/theme.mp3",
+            "/movies/Up/not a theme.mp3",
+            "/movies/Up/behind the scenes",
+            "/movies/Up/behind the scenes.mkv",
+            "/movies/Up/Up - sample.mkv",
+            "/movies/Up/Up something else.mkv"
+        };
+
+        _fileSystemMock.Setup(f => f.GetFiles(
+                "/movies/Up/trailers",
+                It.IsAny<string[]>(),
+                false,
+                false))
+            .Returns(new List<FileSystemMetadata>
+            {
+                new ()
+                {
+                    FullName = "/movies/Up/trailers/some trailer.mkv",
+                    Name = "some trailer.mkv",
+                    IsDirectory = false
+                }
+            });
+
+        _fileSystemMock.Setup(f => f.GetFiles(
+                "/movies/Up/behind the scenes",
+                It.IsAny<string[]>(),
+                false,
+                false))
+            .Returns(new List<FileSystemMetadata>
+            {
+                new ()
+                {
+                    FullName = "/movies/Up/behind the scenes/the making of Up.mkv",
+                    Name = "the making of Up.mkv",
+                    IsDirectory = false
+                }
+            });
+
+        _fileSystemMock.Setup(f => f.GetFiles(
+                "/movies/Up/theme-music",
+                It.IsAny<string[]>(),
+                false,
+                false))
+            .Returns(new List<FileSystemMetadata>
+            {
+                new ()
+                {
+                    FullName = "/movies/Up/theme-music/theme2.mp3",
+                    Name = "theme2.mp3",
+                    IsDirectory = false
+                }
+            });
+
+        var files = paths.Select(p => new FileSystemMetadata
+        {
+            FullName = p,
+            Name = Path.GetFileName(p),
+            IsDirectory = string.IsNullOrEmpty(Path.GetExtension(p))
+        }).ToList();
+
+        var extras = _libraryManager.FindExtras(owner, files, new DirectoryService(_fileSystemMock.Object)).OrderBy(e => e.ExtraType).ToList();
+
+        Assert.Equal(6, extras.Count);
+        Assert.Equal(ExtraType.Trailer, extras[0].ExtraType);
+        Assert.Equal(ExtraType.Trailer, extras[1].ExtraType);
+        Assert.Equal(ExtraType.BehindTheScenes, extras[2].ExtraType);
+        Assert.Equal(ExtraType.Sample, extras[3].ExtraType);
+        Assert.Equal(ExtraType.ThemeSong, extras[4].ExtraType);
+        Assert.Equal(ExtraType.ThemeSong, extras[5].ExtraType);
+    }
+
+    [Fact]
+    public void FindExtras_SeparateMovieFolderWithMixedExtras_FindsOnlyExtrasInMovieFolder()
+    {
+        var owner = new Movie { Name = "Up", Path = "/movies/Up/Up.mkv" };
+        var paths = new List<string>
+        {
+            "/movies/Up/Up.mkv",
+            "/movies/Up/trailer.mkv",
+            "/movies/Another Movie/trailer.mkv"
+        };
+
+        var files = paths.Select(p => new FileSystemMetadata
+        {
+            FullName = p,
+            IsDirectory = false
+        }).ToList();
+
+        var extras = _libraryManager.FindExtras(owner, files, new DirectoryService(_fileSystemMock.Object)).OrderBy(e => e.ExtraType).ToList();
+
+        Assert.Single(extras);
+        Assert.Equal(ExtraType.Trailer, extras[0].ExtraType);
+        Assert.Equal("trailer", extras[0].FileNameWithoutExtension);
+        Assert.Equal("/movies/Up/trailer.mkv", extras[0].Path);
+    }
+
+    [Fact]
+    public void FindExtras_SeparateMovieFolderWithParts_FindsCorrectExtras()
+    {
+        var owner = new Movie { Name = "Up", Path = "/movies/Up/Up - part1.mkv" };
+        var paths = new List<string>
+        {
+            "/movies/Up/Up - part1.mkv",
+            "/movies/Up/Up - part2.mkv",
+            "/movies/Up/trailer.mkv",
+            "/movies/Another Movie/trailer.mkv"
+        };
+
+        var files = paths.Select(p => new FileSystemMetadata
+        {
+            FullName = p,
+            IsDirectory = false
+        }).ToList();
+
+        var extras = _libraryManager.FindExtras(owner, files, new DirectoryService(_fileSystemMock.Object)).OrderBy(e => e.ExtraType).ToList();
+
+        Assert.Single(extras);
+        Assert.Equal(ExtraType.Trailer, extras[0].ExtraType);
+        Assert.Equal("trailer", extras[0].FileNameWithoutExtension);
+        Assert.Equal("/movies/Up/trailer.mkv", extras[0].Path);
+    }
+
+    [Fact]
+    public void FindExtras_SeriesWithTrailers_FindsCorrectExtras()
+    {
+        var owner = new Series { Name = "Dexter", Path = "/series/Dexter" };
+        var paths = new List<string>
+        {
+            "/series/Dexter/Season 1/S01E01.mkv",
+            "/series/Dexter/trailer.mkv",
+            "/series/Dexter/trailers/trailer2.mkv",
+        };
+
+        var files = paths.Select(p => new FileSystemMetadata
+        {
+            FullName = p,
+            IsDirectory = string.IsNullOrEmpty(Path.GetExtension(p))
+        }).ToList();
+
+        var extras = _libraryManager.FindExtras(owner, files, new DirectoryService(_fileSystemMock.Object)).OrderBy(e => e.ExtraType).ToList();
+
+        Assert.Equal(2, extras.Count);
+        Assert.Equal(ExtraType.Trailer, extras[0].ExtraType);
+        Assert.Equal("trailer", extras[0].FileNameWithoutExtension);
+        Assert.Equal("/series/Dexter/trailer.mkv", extras[0].Path);
+        Assert.Equal("/series/Dexter/trailers/trailer2.mkv", extras[1].Path);
+    }
+}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/MediaSourceManagerTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/MediaSourceManagerTests.cs
new file mode 100644
index 000000000..8ed3d8b94
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/MediaSourceManagerTests.cs
@@ -0,0 +1,32 @@
+using AutoFixture;
+using AutoFixture.AutoMoq;
+using Emby.Server.Implementations.IO;
+using Emby.Server.Implementations.Library;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Model.MediaInfo;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.Library
+{
+    public class MediaSourceManagerTests
+    {
+        private readonly MediaSourceManager _mediaSourceManager;
+
+        public MediaSourceManagerTests()
+        {
+            IFixture fixture = new Fixture().Customize(new AutoMoqCustomization { ConfigureMembers = true });
+            fixture.Inject<IFileSystem>(fixture.Create<ManagedFileSystem>());
+            _mediaSourceManager = fixture.Create<MediaSourceManager>();
+        }
+
+        [Theory]
+        [InlineData(@"C:\mydir\myfile.ext", MediaProtocol.File)]
+        [InlineData("/mydir/myfile.ext", MediaProtocol.File)]
+        [InlineData("file:///mydir/myfile.ext", MediaProtocol.File)]
+        [InlineData("http://example.com/stream.m3u8", MediaProtocol.Http)]
+        [InlineData("https://example.com/stream.m3u8", MediaProtocol.Http)]
+        [InlineData("rtsp://media.example.com:554/twister/audiotrack", MediaProtocol.Rtsp)]
+        public void GetPathProtocol_ValidArg_Correct(string path, MediaProtocol expected)
+            => Assert.Equal(expected, _mediaSourceManager.GetPathProtocol(path));
+    }
+}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/PathExtensionsTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/PathExtensionsTests.cs
index 6d768af89..54a63a5f2 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Library/PathExtensionsTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/PathExtensionsTests.cs
@@ -11,6 +11,18 @@ namespace Jellyfin.Server.Implementations.Tests.Library
         [InlineData("Superman: Red Son - tt10985510", "imdbid", "tt10985510")]
         [InlineData("Superman: Red Son", "imdbid", null)]
         [InlineData("Superman: Red Son", "something", null)]
+        [InlineData("Superman: Red Son [imdbid1=tt11111111][imdbid=tt10985510]", "imdbid", "tt10985510")]
+        [InlineData("Superman: Red Son [tmdbid=618355][imdbid=tt10985510]", "imdbid", "tt10985510")]
+        [InlineData("Superman: Red Son [tmdbid=618355][imdbid=tt10985510]", "tmdbid", "618355")]
+        [InlineData("[tmdbid=618355]", "tmdbid", "618355")]
+        [InlineData("tmdbid=111111][tmdbid=618355]", "tmdbid", "618355")]
+        [InlineData("[tmdbid=618355]tmdbid=111111]", "tmdbid", "618355")]
+        [InlineData("tmdbid=618355]", "tmdbid", null)]
+        [InlineData("[tmdbid=618355", "tmdbid", null)]
+        [InlineData("tmdbid=618355", "tmdbid", null)]
+        [InlineData("tmdbid=", "tmdbid", null)]
+        [InlineData("tmdbid", "tmdbid", null)]
+        [InlineData("[tmdbid=][imdbid=tt10985510]", "tmdbid", null)]
         public void GetAttributeValue_ValidArgs_Correct(string input, string attribute, string? expectedResult)
         {
             Assert.Equal(expectedResult, PathExtensions.GetAttributeValue(input, attribute));
@@ -24,5 +36,36 @@ namespace Jellyfin.Server.Implementations.Tests.Library
         {
             Assert.Throws<ArgumentException>(() => PathExtensions.GetAttributeValue(input, attribute));
         }
+
+        [Theory]
+        [InlineData("C:/Users/jeff/myfile.mkv", "C:/Users/jeff", "/home/jeff", "/home/jeff/myfile.mkv")]
+        [InlineData("C:/Users/jeff/myfile.mkv", "C:/Users/jeff/", "/home/jeff", "/home/jeff/myfile.mkv")]
+        [InlineData("/home/jeff/music/jeff's band/consistently inconsistent.mp3", "/home/jeff/music/jeff's band", "/home/not jeff", "/home/not jeff/consistently inconsistent.mp3")]
+        [InlineData("C:\\Users\\jeff\\myfile.mkv", "C:\\Users/jeff", "/home/jeff", "/home/jeff/myfile.mkv")]
+        [InlineData("C:\\Users\\jeff\\myfile.mkv", "C:\\Users/jeff", "/home/jeff/", "/home/jeff/myfile.mkv")]
+        [InlineData("C:\\Users\\jeff\\myfile.mkv", "C:\\Users/jeff/", "/home/jeff/", "/home/jeff/myfile.mkv")]
+        [InlineData("C:\\Users\\jeff\\myfile.mkv", "C:\\Users/jeff/", "/", "/myfile.mkv")]
+        [InlineData("/o", "/o", "/s", "/s")] // regression test for #5977
+        public void TryReplaceSubPath_ValidArgs_Correct(string path, string subPath, string newSubPath, string? expectedResult)
+        {
+            Assert.True(PathExtensions.TryReplaceSubPath(path, subPath, newSubPath, out var result));
+            Assert.Equal(expectedResult, result);
+        }
+
+        [Theory]
+        [InlineData(null, null, null)]
+        [InlineData(null, "/my/path", "/another/path")]
+        [InlineData("/my/path", null, "/another/path")]
+        [InlineData("/my/path", "/another/path", null)]
+        [InlineData("", "", "")]
+        [InlineData("/my/path", "", "")]
+        [InlineData("", "/another/path", "")]
+        [InlineData("", "", "/new/subpath")]
+        [InlineData("/home/jeff/music/jeff's band/consistently inconsistent.mp3", "/home/jeff/music/not jeff's band", "/home/not jeff")]
+        public void TryReplaceSubPath_InvalidInput_ReturnsFalseAndNull(string? path, string? subPath, string? newSubPath)
+        {
+            Assert.False(PathExtensions.TryReplaceSubPath(path, subPath, newSubPath, out var result));
+            Assert.Null(result);
+        }
     }
 }
diff --git a/tests/Jellyfin.Server.Implementations.Tests/LiveTv/HdHomerunHostTests.cs b/tests/Jellyfin.Server.Implementations.Tests/LiveTv/HdHomerunHostTests.cs
index 75939526d..c859d11c6 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/LiveTv/HdHomerunHostTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/LiveTv/HdHomerunHostTests.cs
@@ -1,5 +1,7 @@
 using System;
+using System.IO;
 using System.Net.Http;
+using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
 using AutoFixture;
@@ -14,31 +16,20 @@ namespace Jellyfin.Server.Implementations.Tests.LiveTv
 {
     public class HdHomerunHostTests
     {
-        private const string TestIp = "http://192.168.1.182";
-
         private readonly Fixture _fixture;
         private readonly HdHomerunHost _hdHomerunHost;
 
         public HdHomerunHostTests()
         {
-            const string BaseResourcePath = "Jellyfin.Server.Implementations.Tests.LiveTv.";
-
             var messageHandler = new Mock<HttpMessageHandler>();
             messageHandler.Protected()
                 .Setup<Task<HttpResponseMessage>>("SendAsync", ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>())
                 .Returns<HttpRequestMessage, CancellationToken>(
                     (m, _) =>
                     {
-                        var resource = BaseResourcePath + m.RequestUri?.Segments[^1];
-                        var stream = typeof(HdHomerunHostTests).Assembly.GetManifestResourceStream(resource);
-                        if (stream == null)
-                        {
-                            throw new NullReferenceException("Resource doesn't exist: " + resource);
-                        }
-
                         return Task.FromResult(new HttpResponseMessage()
                         {
-                            Content = new StreamContent(stream)
+                            Content = new StreamContent(File.OpenRead(Path.Combine("Test Data/LiveTv", m.RequestUri!.Host, m.RequestUri.Segments[^1])))
                         });
                     });
 
@@ -58,7 +49,7 @@ namespace Jellyfin.Server.Implementations.Tests.LiveTv
         {
             var host = new TunerHostInfo()
             {
-                Url = TestIp
+                Url = "192.168.1.182"
             };
 
             var modelInfo = await _hdHomerunHost.GetModelInfo(host, true, CancellationToken.None).ConfigureAwait(false);
@@ -74,6 +65,26 @@ namespace Jellyfin.Server.Implementations.Tests.LiveTv
         }
 
         [Fact]
+        public async Task GetModelInfo_Legacy_Success()
+        {
+            var host = new TunerHostInfo()
+            {
+                Url = "10.10.10.100"
+            };
+
+            var modelInfo = await _hdHomerunHost.GetModelInfo(host, true, CancellationToken.None).ConfigureAwait(false);
+            Assert.Equal("HDHomeRun DUAL", modelInfo.FriendlyName);
+            Assert.Equal("HDHR3-US", modelInfo.ModelNumber);
+            Assert.Equal("hdhomerun3_atsc", modelInfo.FirmwareName);
+            Assert.Equal("20200225", modelInfo.FirmwareVersion);
+            Assert.Equal("10xxxxx5", modelInfo.DeviceID);
+            Assert.Null(modelInfo.DeviceAuth);
+            Assert.Equal(2, modelInfo.TunerCount);
+            Assert.Equal("http://10.10.10.100:80", modelInfo.BaseURL);
+            Assert.Null(modelInfo.LineupURL);
+        }
+
+        [Fact]
         public async Task GetModelInfo_EmptyUrl_ArgumentException()
         {
             var host = new TunerHostInfo()
@@ -89,7 +100,7 @@ namespace Jellyfin.Server.Implementations.Tests.LiveTv
         {
             var host = new TunerHostInfo()
             {
-                Url = TestIp
+                Url = "192.168.1.182"
             };
 
             var channels = await _hdHomerunHost.GetLineup(host, CancellationToken.None).ConfigureAwait(false);
@@ -102,11 +113,23 @@ namespace Jellyfin.Server.Implementations.Tests.LiveTv
         }
 
         [Fact]
+        public async Task GetLineup_Legacy_Success()
+        {
+            var host = new TunerHostInfo()
+            {
+                Url = "10.10.10.100"
+            };
+
+            // Placeholder json is invalid, just need to make sure we can reach it
+            await Assert.ThrowsAsync<JsonException>(() => _hdHomerunHost.GetLineup(host, CancellationToken.None));
+        }
+
+        [Fact]
         public async Task GetLineup_ImportFavoritesOnly_Success()
         {
             var host = new TunerHostInfo()
             {
-                Url = TestIp,
+                Url = "192.168.1.182",
                 ImportFavoritesOnly = true
             };
 
@@ -122,9 +145,9 @@ namespace Jellyfin.Server.Implementations.Tests.LiveTv
         [Fact]
         public async Task TryGetTunerHostInfo_Valid_Success()
         {
-            var host = await _hdHomerunHost.TryGetTunerHostInfo(TestIp, CancellationToken.None).ConfigureAwait(false);
+            var host = await _hdHomerunHost.TryGetTunerHostInfo("192.168.1.182", CancellationToken.None).ConfigureAwait(false);
             Assert.Equal(_hdHomerunHost.Type, host.Type);
-            Assert.Equal(TestIp, host.Url);
+            Assert.Equal("192.168.1.182", host.Url);
             Assert.Equal("HDHomeRun PRIME", host.FriendlyName);
             Assert.Equal("FFFFFFFF", host.DeviceId);
             Assert.Equal(3, host.TunerCount);
diff --git a/tests/Jellyfin.Server.Implementations.Tests/LiveTv/HdHomerunManagerTests.cs b/tests/Jellyfin.Server.Implementations.Tests/LiveTv/HdHomerunManagerTests.cs
new file mode 100644
index 000000000..fd499d9cf
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/LiveTv/HdHomerunManagerTests.cs
@@ -0,0 +1,326 @@
+using System;
+using System.Text;
+using Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.LiveTv
+{
+    public class HdHomerunManagerTests
+    {
+        [Fact]
+        public void WriteNullTerminatedString_Empty_Success()
+        {
+            ReadOnlySpan<byte> expected = stackalloc byte[]
+            {
+                1, 0
+            };
+
+            Span<byte> buffer = stackalloc byte[128];
+            int len = HdHomerunManager.WriteNullTerminatedString(buffer, string.Empty);
+
+            Assert.Equal(
+                Convert.ToHexString(expected),
+                Convert.ToHexString(buffer.Slice(0, len)));
+        }
+
+        [Fact]
+        public void WriteNullTerminatedString_Valid_Success()
+        {
+            ReadOnlySpan<byte> expected = stackalloc byte[]
+            {
+                10, (byte)'T', (byte)'h', (byte)'e', (byte)' ', (byte)'q', (byte)'u', (byte)'i', (byte)'c', (byte)'k', 0
+            };
+
+            Span<byte> buffer = stackalloc byte[128];
+            int len = HdHomerunManager.WriteNullTerminatedString(buffer, "The quick");
+
+            Assert.Equal(
+                Convert.ToHexString(expected),
+                Convert.ToHexString(buffer.Slice(0, len)));
+        }
+
+        [Fact]
+        public void WriteGetMessage_Valid_Success()
+        {
+            ReadOnlySpan<byte> expected = stackalloc byte[]
+            {
+                0, 4,
+                0, 12,
+                3,
+                10, (byte)'/', (byte)'t', (byte)'u', (byte)'n', (byte)'e', (byte)'r', (byte)'0', (byte)'/', (byte)'N', 0,
+                0xc0, 0xc9, 0x87, 0x33
+            };
+
+            Span<byte> buffer = stackalloc byte[128];
+            int len = HdHomerunManager.WriteGetMessage(buffer, 0, "N");
+
+            Assert.Equal(
+                Convert.ToHexString(expected),
+                Convert.ToHexString(buffer.Slice(0, len)));
+        }
+
+        [Fact]
+        public void WriteSetMessage_NoLockKey_Success()
+        {
+            ReadOnlySpan<byte> expected = stackalloc byte[]
+            {
+                0, 4,
+                0, 20,
+                3,
+                10, (byte)'/', (byte)'t', (byte)'u', (byte)'n', (byte)'e', (byte)'r', (byte)'0', (byte)'/', (byte)'N', 0,
+                4,
+                6, (byte)'v', (byte)'a', (byte)'l', (byte)'u', (byte)'e', 0,
+                0xa9, 0x49, 0xd0, 0x68
+            };
+
+            Span<byte> buffer = stackalloc byte[128];
+            int len = HdHomerunManager.WriteSetMessage(buffer, 0, "N", "value", null);
+
+            Assert.Equal(
+                Convert.ToHexString(expected),
+                Convert.ToHexString(buffer.Slice(0, len)));
+        }
+
+        [Fact]
+        public void WriteSetMessage_LockKey_Success()
+        {
+            ReadOnlySpan<byte> expected = stackalloc byte[]
+            {
+                0, 4,
+                0, 26,
+                3,
+                10, (byte)'/', (byte)'t', (byte)'u', (byte)'n', (byte)'e', (byte)'r', (byte)'0', (byte)'/', (byte)'N', 0,
+                4,
+                6, (byte)'v', (byte)'a', (byte)'l', (byte)'u', (byte)'e', 0,
+                21,
+                4, 0x00, 0x01, 0x38, 0xd5,
+                0x8e, 0xb6, 0x06, 0x82
+            };
+
+            Span<byte> buffer = stackalloc byte[128];
+            int len = HdHomerunManager.WriteSetMessage(buffer, 0, "N", "value", 80085);
+
+            Assert.Equal(
+                Convert.ToHexString(expected),
+                Convert.ToHexString(buffer.Slice(0, len)));
+        }
+
+        [Fact]
+        public void TryGetReturnValueOfGetSet_Valid_Success()
+        {
+            ReadOnlySpan<byte> packet = new byte[]
+            {
+                0, 5,
+                0, 20,
+                3,
+                10, (byte)'/', (byte)'t', (byte)'u', (byte)'n', (byte)'e', (byte)'r', (byte)'0', (byte)'/', (byte)'N', 0,
+                4,
+                6, (byte)'v', (byte)'a', (byte)'l', (byte)'u', (byte)'e', 0,
+                0x7d, 0xa3, 0xa3, 0xf3
+            };
+
+            Assert.True(HdHomerunManager.TryGetReturnValueOfGetSet(packet, out var value));
+            Assert.Equal("value", Encoding.UTF8.GetString(value));
+        }
+
+        [Fact]
+        public void TryGetReturnValueOfGetSet_InvalidCrc_False()
+        {
+            ReadOnlySpan<byte> packet = new byte[]
+            {
+                0, 5,
+                0, 20,
+                3,
+                10, (byte)'/', (byte)'t', (byte)'u', (byte)'n', (byte)'e', (byte)'r', (byte)'0', (byte)'/', (byte)'N', 0,
+                4,
+                6, (byte)'v', (byte)'a', (byte)'l', (byte)'u', (byte)'e', 0,
+                0x7d, 0xa3, 0xa3, 0xf4
+            };
+
+            Assert.False(HdHomerunManager.TryGetReturnValueOfGetSet(packet, out _));
+        }
+
+        [Fact]
+        public void TryGetReturnValueOfGetSet_InvalidPacketType_False()
+        {
+            ReadOnlySpan<byte> packet = new byte[]
+            {
+                0, 4,
+                0, 20,
+                3,
+                10, (byte)'/', (byte)'t', (byte)'u', (byte)'n', (byte)'e', (byte)'r', (byte)'0', (byte)'/', (byte)'N', 0,
+                4,
+                6, (byte)'v', (byte)'a', (byte)'l', (byte)'u', (byte)'e', 0,
+                0xa9, 0x49, 0xd0, 0x68
+            };
+
+            Assert.False(HdHomerunManager.TryGetReturnValueOfGetSet(packet, out _));
+        }
+
+        [Fact]
+        public void TryGetReturnValueOfGetSet_InvalidPacket_False()
+        {
+            ReadOnlySpan<byte> packet = new byte[]
+            {
+                0, 5,
+                0, 20,
+                0x7d, 0xa3, 0xa3
+            };
+
+            Assert.False(HdHomerunManager.TryGetReturnValueOfGetSet(packet, out _));
+        }
+
+        [Fact]
+        public void TryGetReturnValueOfGetSet_TooSmallMessageLength_False()
+        {
+            ReadOnlySpan<byte> packet = new byte[]
+            {
+                0, 5,
+                0, 19,
+                3,
+                10, (byte)'/', (byte)'t', (byte)'u', (byte)'n', (byte)'e', (byte)'r', (byte)'0', (byte)'/', (byte)'N', 0,
+                4,
+                6, (byte)'v', (byte)'a', (byte)'l', (byte)'u', (byte)'e', 0,
+                0x25, 0x25, 0x44, 0x9a
+            };
+
+            Assert.False(HdHomerunManager.TryGetReturnValueOfGetSet(packet, out _));
+        }
+
+        [Fact]
+        public void TryGetReturnValueOfGetSet_TooLargeMessageLength_False()
+        {
+            ReadOnlySpan<byte> packet = new byte[]
+            {
+                0, 5,
+                0, 21,
+                3,
+                10, (byte)'/', (byte)'t', (byte)'u', (byte)'n', (byte)'e', (byte)'r', (byte)'0', (byte)'/', (byte)'N', 0,
+                4,
+                6, (byte)'v', (byte)'a', (byte)'l', (byte)'u', (byte)'e', 0,
+                0xe3, 0x20, 0x79, 0x6c
+            };
+
+            Assert.False(HdHomerunManager.TryGetReturnValueOfGetSet(packet, out _));
+        }
+
+        [Fact]
+        public void TryGetReturnValueOfGetSet_TooLargeNameLength_False()
+        {
+            ReadOnlySpan<byte> packet = new byte[]
+            {
+                0, 5,
+                0, 20,
+                3,
+                20, (byte)'/', (byte)'t', (byte)'u', (byte)'n', (byte)'e', (byte)'r', (byte)'0', (byte)'/', (byte)'N', 0,
+                4,
+                6, (byte)'v', (byte)'a', (byte)'l', (byte)'u', (byte)'e', 0,
+                0xe1, 0x8e, 0x9c, 0x74
+            };
+
+            Assert.False(HdHomerunManager.TryGetReturnValueOfGetSet(packet, out _));
+        }
+
+        [Fact]
+        public void TryGetReturnValueOfGetSet_InvalidGetSetNameTag_False()
+        {
+            ReadOnlySpan<byte> packet = new byte[]
+            {
+                0, 5,
+                0, 20,
+                4,
+                10, (byte)'/', (byte)'t', (byte)'u', (byte)'n', (byte)'e', (byte)'r', (byte)'0', (byte)'/', (byte)'N', 0,
+                4,
+                6, (byte)'v', (byte)'a', (byte)'l', (byte)'u', (byte)'e', 0,
+                0xee, 0x05, 0xe7, 0x12
+            };
+
+            Assert.False(HdHomerunManager.TryGetReturnValueOfGetSet(packet, out _));
+        }
+
+        [Fact]
+        public void TryGetReturnValueOfGetSet_InvalidGetSetValueTag_False()
+        {
+            ReadOnlySpan<byte> packet = new byte[]
+            {
+                0, 5,
+                0, 20,
+                3,
+                10, (byte)'/', (byte)'t', (byte)'u', (byte)'n', (byte)'e', (byte)'r', (byte)'0', (byte)'/', (byte)'N', 0,
+                3,
+                6, (byte)'v', (byte)'a', (byte)'l', (byte)'u', (byte)'e', 0,
+                0x64, 0xaa, 0x66, 0xf9
+            };
+
+            Assert.False(HdHomerunManager.TryGetReturnValueOfGetSet(packet, out _));
+        }
+
+        [Fact]
+        public void TryGetReturnValueOfGetSet_TooLargeValueLength_False()
+        {
+            ReadOnlySpan<byte> packet = new byte[]
+            {
+                0, 5,
+                0, 20,
+                3,
+                10, (byte)'/', (byte)'t', (byte)'u', (byte)'n', (byte)'e', (byte)'r', (byte)'0', (byte)'/', (byte)'N', 0,
+                4,
+                7, (byte)'v', (byte)'a', (byte)'l', (byte)'u', (byte)'e', 0,
+                0xc9, 0xa8, 0xd4, 0x55
+            };
+
+            Assert.False(HdHomerunManager.TryGetReturnValueOfGetSet(packet, out _));
+        }
+
+        [Fact]
+        public void VerifyReturnValueOfGetSet_Valid_True()
+        {
+            ReadOnlySpan<byte> packet = new byte[]
+            {
+                0, 5,
+                0, 20,
+                3,
+                10, (byte)'/', (byte)'t', (byte)'u', (byte)'n', (byte)'e', (byte)'r', (byte)'0', (byte)'/', (byte)'N', 0,
+                4,
+                6, (byte)'v', (byte)'a', (byte)'l', (byte)'u', (byte)'e', 0,
+                0x7d, 0xa3, 0xa3, 0xf3
+            };
+
+            Assert.True(HdHomerunManager.VerifyReturnValueOfGetSet(packet, "value"));
+        }
+
+        [Fact]
+        public void VerifyReturnValueOfGetSet_WrongValue_False()
+        {
+            ReadOnlySpan<byte> packet = new byte[]
+            {
+                0, 5,
+                0, 20,
+                3,
+                10, (byte)'/', (byte)'t', (byte)'u', (byte)'n', (byte)'e', (byte)'r', (byte)'0', (byte)'/', (byte)'N', 0,
+                4,
+                6, (byte)'v', (byte)'a', (byte)'l', (byte)'u', (byte)'e', 0,
+                0x7d, 0xa3, 0xa3, 0xf3
+            };
+
+            Assert.False(HdHomerunManager.VerifyReturnValueOfGetSet(packet, "none"));
+        }
+
+        [Fact]
+        public void VerifyReturnValueOfGetSet_InvalidPacket_False()
+        {
+            ReadOnlySpan<byte> packet = new byte[]
+            {
+                0, 4,
+                0, 20,
+                3,
+                10, (byte)'/', (byte)'t', (byte)'u', (byte)'n', (byte)'e', (byte)'r', (byte)'0', (byte)'/', (byte)'N', 0,
+                4,
+                6, (byte)'v', (byte)'a', (byte)'l', (byte)'u', (byte)'e', 0,
+                0x7d, 0xa3, 0xa3, 0xf3
+            };
+
+            Assert.False(HdHomerunManager.VerifyReturnValueOfGetSet(packet, "value"));
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/LiveTv/RecordingHelperTests.cs b/tests/Jellyfin.Server.Implementations.Tests/LiveTv/RecordingHelperTests.cs
new file mode 100644
index 000000000..09aec82b0
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/LiveTv/RecordingHelperTests.cs
@@ -0,0 +1,98 @@
+using System;
+using Emby.Server.Implementations.LiveTv.EmbyTV;
+using MediaBrowser.Controller.LiveTv;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.LiveTv
+{
+    public static class RecordingHelperTests
+    {
+        public static TheoryData<string, TimerInfo> GetRecordingName_Success_TestData()
+        {
+            var data = new TheoryData<string, TimerInfo>();
+
+            data.Add(
+                "The Incredibles 2020_04_20_21_06_00",
+                new TimerInfo
+                {
+                    Name = "The Incredibles",
+                    StartDate = new DateTime(2020, 4, 20, 21, 6, 0, DateTimeKind.Local),
+                    IsMovie = true
+                });
+
+            data.Add(
+                "The Incredibles (2004)",
+                new TimerInfo
+                {
+                    Name = "The Incredibles",
+                    IsMovie = true,
+                    ProductionYear = 2004
+                });
+            data.Add(
+                "The Big Bang Theory 2020_04_20_21_06_00",
+                new TimerInfo
+                {
+                    Name = "The Big Bang Theory",
+                    StartDate = new DateTime(2020, 4, 20, 21, 6, 0, DateTimeKind.Local),
+                    IsProgramSeries = true,
+                });
+            data.Add(
+                "The Big Bang Theory S12E10",
+                new TimerInfo
+                {
+                    Name = "The Big Bang Theory",
+                    IsProgramSeries = true,
+                    SeasonNumber = 12,
+                    EpisodeNumber = 10
+                });
+            data.Add(
+                "The Big Bang Theory S12E10 The VCR Illumination",
+                new TimerInfo
+                {
+                    Name = "The Big Bang Theory",
+                    IsProgramSeries = true,
+                    SeasonNumber = 12,
+                    EpisodeNumber = 10,
+                    EpisodeTitle = "The VCR Illumination"
+                });
+            data.Add(
+                "The Big Bang Theory 2018-12-06",
+                new TimerInfo
+                {
+                    Name = "The Big Bang Theory",
+                    IsProgramSeries = true,
+                    OriginalAirDate = new DateTime(2018, 12, 6, 0, 0, 0, DateTimeKind.Local)
+                });
+
+            data.Add(
+                "The Big Bang Theory 2018-12-06 - The VCR Illumination",
+                new TimerInfo
+                {
+                    Name = "The Big Bang Theory",
+                    IsProgramSeries = true,
+                    OriginalAirDate = new DateTime(2018, 12, 6, 0, 0, 0, DateTimeKind.Local),
+                    EpisodeTitle = "The VCR Illumination"
+                });
+
+            data.Add(
+                "The Big Bang Theory 2018_12_06_21_06_00 - The VCR Illumination",
+                new TimerInfo
+                {
+                    Name = "The Big Bang Theory",
+                    StartDate = new DateTime(2018, 12, 6, 21, 6, 0, DateTimeKind.Local),
+                    IsProgramSeries = true,
+                    OriginalAirDate = new DateTime(2018, 12, 6),
+                    EpisodeTitle = "The VCR Illumination"
+                });
+
+            return data;
+        }
+
+        [Theory]
+        [MemberData(nameof(GetRecordingName_Success_TestData))]
+        public static void GetRecordingName_Success(string expected, TimerInfo timerInfo)
+        {
+            Assert.Equal(expected, RecordingHelper.GetRecordingName(timerInfo));
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/LiveTv/SchedulesDirect/SchedulesDirectDeserializeTests.cs b/tests/Jellyfin.Server.Implementations.Tests/LiveTv/SchedulesDirect/SchedulesDirectDeserializeTests.cs
new file mode 100644
index 000000000..3b3e38bd1
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/LiveTv/SchedulesDirect/SchedulesDirectDeserializeTests.cs
@@ -0,0 +1,240 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text.Json;
+using Emby.Server.Implementations.LiveTv.Listings.SchedulesDirectDtos;
+using Jellyfin.Extensions.Json;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.LiveTv.SchedulesDirect
+{
+    public class SchedulesDirectDeserializeTests
+    {
+        private readonly JsonSerializerOptions _jsonOptions;
+
+        public SchedulesDirectDeserializeTests()
+        {
+            _jsonOptions = JsonDefaults.Options;
+        }
+
+        /// <summary>
+        /// /token reponse.
+        /// </summary>
+        [Fact]
+        public void Deserialize_Token_Response_Live_Success()
+        {
+            var bytes = File.ReadAllBytes("Test Data/SchedulesDirect/token_live_response.json");
+            var tokenDto = JsonSerializer.Deserialize<TokenDto>(bytes, _jsonOptions);
+
+            Assert.NotNull(tokenDto);
+            Assert.Equal(0, tokenDto!.Code);
+            Assert.Equal("OK", tokenDto.Message);
+            Assert.Equal("AWS-SD-web.1", tokenDto.ServerId);
+            Assert.Equal(new DateTime(2016, 08, 23, 13, 55, 25, DateTimeKind.Utc), tokenDto.TokenTimestamp);
+            Assert.Equal("f3fca79989cafe7dead71beefedc812b", tokenDto.Token);
+        }
+
+        /// <summary>
+        /// /token response.
+        /// </summary>
+        [Fact]
+        public void Deserialize_Token_Response_Offline_Success()
+        {
+            var bytes = File.ReadAllBytes("Test Data/SchedulesDirect/token_offline_response.json");
+            var tokenDto = JsonSerializer.Deserialize<TokenDto>(bytes, _jsonOptions);
+
+            Assert.NotNull(tokenDto);
+            Assert.Equal(3_000, tokenDto!.Code);
+            Assert.Equal("Server offline for maintenance.", tokenDto.Message);
+            Assert.Equal("20141201.web.1", tokenDto.ServerId);
+            Assert.Equal(new DateTime(2015, 04, 23, 00, 03, 32, DateTimeKind.Utc), tokenDto.TokenTimestamp);
+            Assert.Equal("CAFEDEADBEEFCAFEDEADBEEFCAFEDEADBEEFCAFE", tokenDto.Token);
+            Assert.Equal("SERVICE_OFFLINE", tokenDto.Response);
+        }
+
+        /// <summary>
+        /// /schedules request.
+        /// </summary>
+        [Fact]
+        public void Serialize_Schedule_Request_Success()
+        {
+            var expectedString = File.ReadAllText("Test Data/SchedulesDirect/schedules_request.json").Trim();
+
+            var requestObject = new RequestScheduleForChannelDto[]
+            {
+                new RequestScheduleForChannelDto
+                {
+                    StationId = "20454",
+                    Date = new[]
+                    {
+                        "2015-03-13",
+                        "2015-03-17"
+                    }
+                },
+                new RequestScheduleForChannelDto
+                {
+                    StationId = "10021",
+                    Date = new[]
+                    {
+                        "2015-03-12",
+                        "2015-03-13"
+                    }
+                }
+            };
+
+            var requestString = JsonSerializer.Serialize(requestObject, _jsonOptions);
+            Assert.Equal(expectedString, requestString);
+        }
+
+        /// <summary>
+        /// /schedules response.
+        /// </summary>
+        [Fact]
+        public void Deserialize_Schedule_Response_Success()
+        {
+            var bytes = File.ReadAllBytes("Test Data/SchedulesDirect/schedules_response.json");
+            var days = JsonSerializer.Deserialize<IReadOnlyList<DayDto>>(bytes, _jsonOptions);
+
+            Assert.NotNull(days);
+            Assert.Equal(1, days!.Count);
+
+            var dayDto = days[0];
+            Assert.Equal("20454", dayDto.StationId);
+            Assert.Equal(2, dayDto.Programs.Count);
+
+            Assert.Equal("SH005371070000", dayDto.Programs[0].ProgramId);
+            Assert.Equal(new DateTime(2015, 03, 03, 00, 00, 00, DateTimeKind.Utc), dayDto.Programs[0].AirDateTime);
+            Assert.Equal(1_800, dayDto.Programs[0].Duration);
+            Assert.Equal("Sy8HEMBPcuiAx3FBukUhKQ", dayDto.Programs[0].Md5);
+            Assert.True(dayDto.Programs[0].New);
+            Assert.Equal(2, dayDto.Programs[0].AudioProperties.Count);
+            Assert.Equal("stereo", dayDto.Programs[0].AudioProperties[0]);
+            Assert.Equal("cc", dayDto.Programs[0].AudioProperties[1]);
+            Assert.Equal(1, dayDto.Programs[0].VideoProperties.Count);
+            Assert.Equal("hdtv", dayDto.Programs[0].VideoProperties[0]);
+        }
+
+        /// <summary>
+        /// /programs response.
+        /// </summary>
+        [Fact]
+        public void Deserialize_Program_Response_Success()
+        {
+            var bytes = File.ReadAllBytes("Test Data/SchedulesDirect/programs_response.json");
+            var programDtos = JsonSerializer.Deserialize<IReadOnlyList<ProgramDetailsDto>>(bytes, _jsonOptions);
+
+            Assert.NotNull(programDtos);
+            Assert.Equal(2, programDtos!.Count);
+            Assert.Equal("EP000000060003", programDtos[0].ProgramId);
+            Assert.Equal(1, programDtos[0].Titles.Count);
+            Assert.Equal("'Allo 'Allo!", programDtos[0].Titles[0].Title120);
+            Assert.Equal("Series", programDtos[0].EventDetails?.SubType);
+            Assert.Equal("en", programDtos[0].Descriptions?.Description1000[0].DescriptionLanguage);
+            Assert.Equal("A disguised British Intelligence officer is sent to help the airmen.", programDtos[0].Descriptions?.Description1000[0].Description);
+            Assert.Equal(new DateTime(1985, 11, 04), programDtos[0].OriginalAirDate);
+            Assert.Equal(1, programDtos[0].Genres.Count);
+            Assert.Equal("Sitcom", programDtos[0].Genres[0]);
+            Assert.Equal("The Poloceman Cometh", programDtos[0].EpisodeTitle150);
+            Assert.Equal(2, programDtos[0].Metadata[0].Gracenote?.Season);
+            Assert.Equal(3, programDtos[0].Metadata[0].Gracenote?.Episode);
+            Assert.Equal(13, programDtos[0].Cast.Count);
+            Assert.Equal("383774", programDtos[0].Cast[0].PersonId);
+            Assert.Equal("392649", programDtos[0].Cast[0].NameId);
+            Assert.Equal("Gorden Kaye", programDtos[0].Cast[0].Name);
+            Assert.Equal("Actor", programDtos[0].Cast[0].Role);
+            Assert.Equal("01", programDtos[0].Cast[0].BillingOrder);
+            Assert.Equal(3, programDtos[0].Crew.Count);
+            Assert.Equal("354407", programDtos[0].Crew[0].PersonId);
+            Assert.Equal("363281", programDtos[0].Crew[0].NameId);
+            Assert.Equal("David Croft", programDtos[0].Crew[0].Name);
+            Assert.Equal("Director", programDtos[0].Crew[0].Role);
+            Assert.Equal("01", programDtos[0].Crew[0].BillingOrder);
+        }
+
+        /// <summary>
+        /// /metadata/programs response.
+        /// </summary>
+        [Fact]
+        public void Deserialize_Metadata_Programs_Response_Success()
+        {
+            var bytes = File.ReadAllBytes("Test Data/SchedulesDirect/metadata_programs_response.json");
+            var showImagesDtos = JsonSerializer.Deserialize<IReadOnlyList<ShowImagesDto>>(bytes, _jsonOptions);
+
+            Assert.NotNull(showImagesDtos);
+            Assert.Equal(1, showImagesDtos!.Count);
+            Assert.Equal("SH00712240", showImagesDtos[0].ProgramId);
+            Assert.Equal(4, showImagesDtos[0].Data.Count);
+            Assert.Equal("135", showImagesDtos[0].Data[0].Width);
+            Assert.Equal("180", showImagesDtos[0].Data[0].Height);
+            Assert.Equal("assets/p282288_b_v2_aa.jpg", showImagesDtos[0].Data[0].Uri);
+            Assert.Equal("Sm", showImagesDtos[0].Data[0].Size);
+            Assert.Equal("3x4", showImagesDtos[0].Data[0].Aspect);
+            Assert.Equal("Banner-L3", showImagesDtos[0].Data[0].Category);
+            Assert.Equal("yes", showImagesDtos[0].Data[0].Text);
+            Assert.Equal("true", showImagesDtos[0].Data[0].Primary);
+            Assert.Equal("Series", showImagesDtos[0].Data[0].Tier);
+        }
+
+        /// <summary>
+        /// /headends response.
+        /// </summary>
+        [Fact]
+        public void Deserialize_Headends_Response_Success()
+        {
+            var bytes = File.ReadAllBytes("Test Data/SchedulesDirect/headends_response.json");
+            var headendsDtos = JsonSerializer.Deserialize<IReadOnlyList<HeadendsDto>>(bytes, _jsonOptions);
+
+            Assert.NotNull(headendsDtos);
+            Assert.Equal(8, headendsDtos!.Count);
+            Assert.Equal("CA00053", headendsDtos[0].Headend);
+            Assert.Equal("Cable", headendsDtos[0].Transport);
+            Assert.Equal("Beverly Hills", headendsDtos[0].Location);
+            Assert.Equal(2, headendsDtos[0].Lineups.Count);
+            Assert.Equal("Time Warner Cable - Cable", headendsDtos[0].Lineups[0].Name);
+            Assert.Equal("USA-CA00053-DEFAULT", headendsDtos[0].Lineups[0].Lineup);
+            Assert.Equal("/20141201/lineups/USA-CA00053-DEFAULT", headendsDtos[0].Lineups[0].Uri);
+        }
+
+        /// <summary>
+        /// /lineups response.
+        /// </summary>
+        [Fact]
+        public void Deserialize_Lineups_Response_Success()
+        {
+            var bytes = File.ReadAllBytes("Test Data/SchedulesDirect/lineups_response.json");
+            var lineupsDto = JsonSerializer.Deserialize<LineupsDto>(bytes, _jsonOptions);
+
+            Assert.NotNull(lineupsDto);
+            Assert.Equal(0, lineupsDto!.Code);
+            Assert.Equal("20141201.web.1", lineupsDto.ServerId);
+            Assert.Equal(new DateTime(2015, 04, 17, 14, 22, 17, DateTimeKind.Utc), lineupsDto.LineupTimestamp);
+            Assert.Equal(5, lineupsDto.Lineups.Count);
+            Assert.Equal("GBR-0001317-DEFAULT", lineupsDto.Lineups[0].Lineup);
+            Assert.Equal("Freeview - Carlton - LWT (Southeast)", lineupsDto.Lineups[0].Name);
+            Assert.Equal("DVB-T", lineupsDto.Lineups[0].Transport);
+            Assert.Equal("London", lineupsDto.Lineups[0].Location);
+            Assert.Equal("/20141201/lineups/GBR-0001317-DEFAULT", lineupsDto.Lineups[0].Uri);
+
+            Assert.Equal("DELETED LINEUP", lineupsDto.Lineups[4].Name);
+            Assert.True(lineupsDto.Lineups[4].IsDeleted);
+        }
+
+        /// <summary>
+        /// /lineup/:id response.
+        /// </summary>
+        [Fact]
+        public void Deserialize_Lineup_Response_Success()
+        {
+            var bytes = File.ReadAllBytes("Test Data/SchedulesDirect/lineup_response.json");
+            var channelDto = JsonSerializer.Deserialize<ChannelDto>(bytes, _jsonOptions);
+
+            Assert.NotNull(channelDto);
+            Assert.Equal(2, channelDto!.Map.Count);
+            Assert.Equal("24326", channelDto.Map[0].StationId);
+            Assert.Equal("001", channelDto.Map[0].Channel);
+            Assert.Equal("BBC ONE South", channelDto.Map[0].ProvderCallsign);
+            Assert.Equal("1", channelDto.Map[0].LogicalChannelNumber);
+            Assert.Equal("providerCallsign", channelDto.Map[0].MatchType);
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Localization/LocalizationManagerTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Localization/LocalizationManagerTests.cs
new file mode 100644
index 000000000..3e7d6ed1d
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Localization/LocalizationManagerTests.cs
@@ -0,0 +1,179 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Emby.Server.Implementations.Localization;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Model.Configuration;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.Localization
+{
+    public class LocalizationManagerTests
+    {
+        [Fact]
+        public void GetCountries_All_Success()
+        {
+            var localizationManager = Setup(new ServerConfiguration
+            {
+                UICulture = "de-DE"
+            });
+            var countries = localizationManager.GetCountries().ToList();
+
+            Assert.Equal(139, countries.Count);
+
+            var germany = countries.FirstOrDefault(x => x.Name.Equals("DE", StringComparison.Ordinal));
+            Assert.NotNull(germany);
+            Assert.Equal("Germany", germany!.DisplayName);
+            Assert.Equal("DEU", germany.ThreeLetterISORegionName);
+            Assert.Equal("DE", germany.TwoLetterISORegionName);
+        }
+
+        [Fact]
+        public async Task GetCultures_All_Success()
+        {
+            var localizationManager = Setup(new ServerConfiguration
+            {
+                UICulture = "de-DE"
+            });
+            await localizationManager.LoadAll();
+            var cultures = localizationManager.GetCultures().ToList();
+
+            Assert.Equal(190, cultures.Count);
+
+            var germany = cultures.FirstOrDefault(x => x.TwoLetterISOLanguageName.Equals("de", StringComparison.Ordinal));
+            Assert.NotNull(germany);
+            Assert.Equal("ger", germany!.ThreeLetterISOLanguageName);
+            Assert.Equal("German", germany.DisplayName);
+            Assert.Equal("German", germany.Name);
+            Assert.Contains("deu", germany.ThreeLetterISOLanguageNames);
+            Assert.Contains("ger", germany.ThreeLetterISOLanguageNames);
+        }
+
+        [Theory]
+        [InlineData("de")]
+        [InlineData("ger")]
+        [InlineData("german")]
+        public async Task FindLanguageInfo_Valid_Success(string identifier)
+        {
+            var localizationManager = Setup(new ServerConfiguration
+            {
+                UICulture = "de-DE"
+            });
+            await localizationManager.LoadAll();
+
+            var germany = localizationManager.FindLanguageInfo(identifier);
+            Assert.NotNull(germany);
+
+            Assert.Equal("ger", germany!.ThreeLetterISOLanguageName);
+            Assert.Equal("German", germany.DisplayName);
+            Assert.Equal("German", germany.Name);
+            Assert.Contains("deu", germany.ThreeLetterISOLanguageNames);
+            Assert.Contains("ger", germany.ThreeLetterISOLanguageNames);
+        }
+
+        [Fact]
+        public async Task GetParentalRatings_Default_Success()
+        {
+            var localizationManager = Setup(new ServerConfiguration
+            {
+                UICulture = "de-DE"
+            });
+            await localizationManager.LoadAll();
+            var ratings = localizationManager.GetParentalRatings().ToList();
+
+            Assert.Equal(23, ratings.Count);
+
+            var tvma = ratings.FirstOrDefault(x => x.Name.Equals("TV-MA", StringComparison.Ordinal));
+            Assert.NotNull(tvma);
+            Assert.Equal(9, tvma!.Value);
+        }
+
+        [Fact]
+        public async Task GetParentalRatings_ConfiguredCountryCode_Success()
+        {
+            var localizationManager = Setup(new ServerConfiguration()
+            {
+                MetadataCountryCode = "DE"
+            });
+            await localizationManager.LoadAll();
+            var ratings = localizationManager.GetParentalRatings().ToList();
+
+            Assert.Equal(10, ratings.Count);
+
+            var fsk = ratings.FirstOrDefault(x => x.Name.Equals("FSK-12", StringComparison.Ordinal));
+            Assert.NotNull(fsk);
+            Assert.Equal(7, fsk!.Value);
+        }
+
+        [Theory]
+        [InlineData("CA-R", "CA", 10)]
+        [InlineData("FSK-16", "DE", 8)]
+        [InlineData("FSK-18", "DE", 9)]
+        [InlineData("FSK-18", "US", 9)]
+        [InlineData("TV-MA", "US", 9)]
+        [InlineData("XXX", "asdf", 100)]
+        [InlineData("Germany: FSK-18", "DE", 9)]
+        public async Task GetRatingLevel_GivenValidString_Success(string value, string countryCode, int expectedLevel)
+        {
+            var localizationManager = Setup(new ServerConfiguration()
+            {
+                MetadataCountryCode = countryCode
+            });
+            await localizationManager.LoadAll();
+            var level = localizationManager.GetRatingLevel(value);
+            Assert.NotNull(level);
+            Assert.Equal(expectedLevel, level!);
+        }
+
+        [Fact]
+        public async Task GetRatingLevel_GivenUnratedString_Success()
+        {
+            var localizationManager = Setup(new ServerConfiguration()
+            {
+                UICulture = "de-DE"
+            });
+            await localizationManager.LoadAll();
+            Assert.Null(localizationManager.GetRatingLevel("n/a"));
+        }
+
+        [Theory]
+        [InlineData("Default", "Default")]
+        [InlineData("HeaderLiveTV", "Live TV")]
+        public void GetLocalizedString_Valid_Success(string key, string expected)
+        {
+            var localizationManager = Setup(new ServerConfiguration()
+            {
+                UICulture = "en-US"
+            });
+
+            var translated = localizationManager.GetLocalizedString(key);
+            Assert.NotNull(translated);
+            Assert.Equal(expected, translated);
+        }
+
+        [Fact]
+        public void GetLocalizedString_Invalid_Success()
+        {
+            var localizationManager = Setup(new ServerConfiguration()
+            {
+                UICulture = "en-US"
+            });
+
+            var key = "SuperInvalidTranslationKeyThatWillNeverBeAdded";
+
+            var translated = localizationManager.GetLocalizedString(key);
+            Assert.NotNull(translated);
+            Assert.Equal(key, translated);
+        }
+
+        private LocalizationManager Setup(ServerConfiguration config)
+        {
+            var mockConfiguration = new Mock<IServerConfigurationManager>();
+            mockConfiguration.SetupGet(x => x.Configuration).Returns(config);
+
+            return new LocalizationManager(mockConfiguration.Object, new NullLogger<LocalizationManager>());
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Plugins/PluginManagerTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Plugins/PluginManagerTests.cs
new file mode 100644
index 000000000..bc6a44741
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Plugins/PluginManagerTests.cs
@@ -0,0 +1,45 @@
+using System;
+using System.IO;
+using Emby.Server.Implementations.Plugins;
+using MediaBrowser.Common.Plugins;
+using Microsoft.Extensions.Logging.Abstractions;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.Plugins
+{
+    public class PluginManagerTests
+    {
+        private static readonly string _testPathRoot = Path.Combine(Path.GetTempPath(), "jellyfin-test-data");
+
+        [Fact]
+        public void SaveManifest_RoundTrip_Success()
+        {
+            var pluginManager = new PluginManager(new NullLogger<PluginManager>(), null!, null!, null!, new Version(1, 0));
+            var manifest = new PluginManifest()
+            {
+                Version = "1.0"
+            };
+
+            var tempPath = Path.Combine(_testPathRoot, "manifest-" + Path.GetRandomFileName());
+            Directory.CreateDirectory(tempPath);
+
+            Assert.True(pluginManager.SaveManifest(manifest, tempPath));
+
+            var res = pluginManager.LoadManifest(tempPath);
+
+            Assert.Equal(manifest.Category, res.Manifest.Category);
+            Assert.Equal(manifest.Changelog, res.Manifest.Changelog);
+            Assert.Equal(manifest.Description, res.Manifest.Description);
+            Assert.Equal(manifest.Id, res.Manifest.Id);
+            Assert.Equal(manifest.Name, res.Manifest.Name);
+            Assert.Equal(manifest.Overview, res.Manifest.Overview);
+            Assert.Equal(manifest.Owner, res.Manifest.Owner);
+            Assert.Equal(manifest.TargetAbi, res.Manifest.TargetAbi);
+            Assert.Equal(manifest.Timestamp, res.Manifest.Timestamp);
+            Assert.Equal(manifest.Version, res.Manifest.Version);
+            Assert.Equal(manifest.Status, res.Manifest.Status);
+            Assert.Equal(manifest.AutoUpdate, res.Manifest.AutoUpdate);
+            Assert.Equal(manifest.ImagePath, res.Manifest.ImagePath);
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/QuickConnect/QuickConnectManagerTests.cs b/tests/Jellyfin.Server.Implementations.Tests/QuickConnect/QuickConnectManagerTests.cs
new file mode 100644
index 000000000..28d832ef8
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/QuickConnect/QuickConnectManagerTests.cs
@@ -0,0 +1,124 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using AutoFixture;
+using AutoFixture.AutoMoq;
+using Emby.Server.Implementations.QuickConnect;
+using MediaBrowser.Common.Extensions;
+using MediaBrowser.Controller.Authentication;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Net;
+using MediaBrowser.Model.Configuration;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.QuickConnect
+{
+    public class QuickConnectManagerTests
+    {
+        private static readonly AuthorizationInfo _quickConnectAuthInfo = new AuthorizationInfo
+        {
+            Device = "Device",
+            DeviceId = "DeviceId",
+            Client = "Client",
+            Version = "1.0.0"
+        };
+
+        private readonly Fixture _fixture;
+        private readonly ServerConfiguration _config;
+        private readonly QuickConnectManager _quickConnectManager;
+
+        public QuickConnectManagerTests()
+        {
+            _config = new ServerConfiguration();
+            var configManager = new Mock<IServerConfigurationManager>();
+            configManager.Setup(x => x.Configuration).Returns(_config);
+
+            _fixture = new Fixture();
+            _fixture.Customize(new AutoMoqCustomization
+            {
+                ConfigureMembers = true
+            }).Inject(configManager.Object);
+
+            // User object contains circular references.
+            _fixture.Behaviors.OfType<ThrowingRecursionBehavior>().ToList()
+                .ForEach(b => _fixture.Behaviors.Remove(b));
+            _fixture.Behaviors.Add(new OmitOnRecursionBehavior());
+
+            _quickConnectManager = _fixture.Create<QuickConnectManager>();
+        }
+
+        [Fact]
+        public void IsEnabled_QuickConnectUnavailable_False()
+            => Assert.False(_quickConnectManager.IsEnabled);
+
+        [Theory]
+        [InlineData("", "DeviceId", "Client", "1.0.0")]
+        [InlineData("Device", "", "Client", "1.0.0")]
+        [InlineData("Device", "DeviceId", "", "1.0.0")]
+        [InlineData("Device", "DeviceId", "Client", "")]
+        public void TryConnect_InvalidAuthorizationInfo_ThrowsArgumentException(string device, string deviceId, string client, string version)
+            => Assert.Throws<ArgumentException>(() => _quickConnectManager.TryConnect(
+                new AuthorizationInfo
+                {
+                    Device = device,
+                    DeviceId = deviceId,
+                    Client = client,
+                    Version = version
+                }));
+
+        [Fact]
+        public void TryConnect_QuickConnectUnavailable_ThrowsAuthenticationException()
+            => Assert.Throws<AuthenticationException>(() => _quickConnectManager.TryConnect(_quickConnectAuthInfo));
+
+        [Fact]
+        public void CheckRequestStatus_QuickConnectUnavailable_ThrowsAuthenticationException()
+            => Assert.Throws<AuthenticationException>(() => _quickConnectManager.CheckRequestStatus(string.Empty));
+
+        [Fact]
+        public void AuthorizeRequest_QuickConnectUnavailable_ThrowsAuthenticationException()
+            => Assert.ThrowsAsync<AuthenticationException>(() => _quickConnectManager.AuthorizeRequest(Guid.Empty, string.Empty));
+
+        [Fact]
+        public void GetAuthorizedRequest_QuickConnectUnavailable_ThrowsAuthenticationException()
+            => Assert.Throws<AuthenticationException>(() => _quickConnectManager.GetAuthorizedRequest(string.Empty));
+
+        [Fact]
+        public void IsEnabled_QuickConnectAvailable_True()
+        {
+            _config.QuickConnectAvailable = true;
+            Assert.True(_quickConnectManager.IsEnabled);
+        }
+
+        [Fact]
+        public void CheckRequestStatus_QuickConnectAvailable_Success()
+        {
+            _config.QuickConnectAvailable = true;
+            var res1 = _quickConnectManager.TryConnect(_quickConnectAuthInfo);
+            var res2 = _quickConnectManager.CheckRequestStatus(res1.Secret);
+            Assert.Equal(res1, res2);
+        }
+
+        [Fact]
+        public void CheckRequestStatus_UnknownSecret_ThrowsResourceNotFoundException()
+        {
+            _config.QuickConnectAvailable = true;
+            Assert.Throws<ResourceNotFoundException>(() => _quickConnectManager.CheckRequestStatus("Unknown secret"));
+        }
+
+        [Fact]
+        public void GetAuthorizedRequest_UnknownSecret_ThrowsResourceNotFoundException()
+        {
+            _config.QuickConnectAvailable = true;
+            Assert.Throws<ResourceNotFoundException>(() => _quickConnectManager.GetAuthorizedRequest("Unknown secret"));
+        }
+
+        [Fact]
+        public async Task AuthorizeRequest_QuickConnectAvailable_Success()
+        {
+            _config.QuickConnectAvailable = true;
+            var res = _quickConnectManager.TryConnect(_quickConnectAuthInfo);
+            Assert.True(await _quickConnectManager.AuthorizeRequest(Guid.Empty, res.Code));
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Sorting/AiredEpisodeOrderComparerTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Sorting/AiredEpisodeOrderComparerTests.cs
new file mode 100644
index 000000000..59d82678e
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Sorting/AiredEpisodeOrderComparerTests.cs
@@ -0,0 +1,164 @@
+using System;
+using Emby.Server.Implementations.Sorting;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Entities.TV;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.Sorting
+{
+    public class AiredEpisodeOrderComparerTests
+    {
+        [Theory]
+        [ClassData(typeof(EpisodeBadData))]
+        public void Compare_GivenNull_ThrowsArgumentNullException(BaseItem? x, BaseItem? y)
+        {
+            var cmp = new AiredEpisodeOrderComparer();
+            Assert.Throws<ArgumentNullException>(() => cmp.Compare(x, y));
+        }
+
+        [Theory]
+        [ClassData(typeof(EpisodeTestData))]
+        public void AiredEpisodeOrderCompareTest(BaseItem x, BaseItem y, int expected)
+        {
+            var cmp = new AiredEpisodeOrderComparer();
+
+            Assert.Equal(expected, cmp.Compare(x, y));
+            Assert.Equal(-expected, cmp.Compare(y, x));
+        }
+
+        private class EpisodeBadData : TheoryData<BaseItem?, BaseItem?>
+        {
+            public EpisodeBadData()
+            {
+                Add(null, new Episode());
+                Add(new Episode(), null);
+            }
+        }
+
+        private class EpisodeTestData : TheoryData<BaseItem, BaseItem, int>
+        {
+            public EpisodeTestData()
+            {
+                Add(
+                    new Movie(),
+                    new Movie(),
+                    0);
+
+                Add(
+                    new Movie(),
+                    new Episode(),
+                    1);
+
+                // Good cases
+                Add(
+                    new Episode(),
+                    new Episode(),
+                    0);
+
+                Add(
+                    new Episode { ParentIndexNumber = 1, IndexNumber = 1 },
+                    new Episode { ParentIndexNumber = 1, IndexNumber = 1 },
+                    0);
+
+                Add(
+                    new Episode { ParentIndexNumber = 1, IndexNumber = 2 },
+                    new Episode { ParentIndexNumber = 1, IndexNumber = 1 },
+                    1);
+
+                Add(
+                    new Episode { ParentIndexNumber = 2, IndexNumber = 1 },
+                    new Episode { ParentIndexNumber = 1, IndexNumber = 1 },
+                    1);
+
+                // Good Specials
+                Add(
+                    new Episode { ParentIndexNumber = 0, IndexNumber = 1 },
+                    new Episode { ParentIndexNumber = 0, IndexNumber = 1 },
+                    0);
+
+                Add(
+                    new Episode { ParentIndexNumber = 0, IndexNumber = 2 },
+                    new Episode { ParentIndexNumber = 0, IndexNumber = 1 },
+                    1);
+
+                // Specials to Episodes
+                Add(
+                    new Episode { ParentIndexNumber = 1, IndexNumber = 1 },
+                    new Episode { ParentIndexNumber = 0, IndexNumber = 1 },
+                    1);
+
+                Add(
+                    new Episode { ParentIndexNumber = 1, IndexNumber = 1 },
+                    new Episode { ParentIndexNumber = 0, IndexNumber = 2 },
+                    1);
+
+                Add(
+                    new Episode { ParentIndexNumber = 1, IndexNumber = 2 },
+                    new Episode { ParentIndexNumber = 0, IndexNumber = 1 },
+                    1);
+
+                Add(
+                    new Episode { ParentIndexNumber = 1, IndexNumber = 2 },
+                    new Episode { ParentIndexNumber = 0, IndexNumber = 1 },
+                    1);
+
+                Add(
+                    new Episode { ParentIndexNumber = 1, IndexNumber = 1 },
+                    new Episode { ParentIndexNumber = 0, IndexNumber = 2 },
+                    1);
+
+                Add(
+                    new Episode { ParentIndexNumber = 0, IndexNumber = 1, AirsAfterSeasonNumber = 1 },
+                    new Episode { ParentIndexNumber = 1, IndexNumber = 1 },
+                    1);
+
+                Add(
+                    new Episode { ParentIndexNumber = 3, IndexNumber = 1 },
+                    new Episode { ParentIndexNumber = 0, IndexNumber = 1, AirsAfterSeasonNumber = 1 },
+                    1);
+
+                Add(
+                    new Episode { ParentIndexNumber = 3, IndexNumber = 1 },
+                    new Episode { ParentIndexNumber = 0, IndexNumber = 1, AirsAfterSeasonNumber = 1, AirsBeforeEpisodeNumber = 2 },
+                    1);
+
+                Add(
+                    new Episode { ParentIndexNumber = 1, IndexNumber = 1 },
+                    new Episode { ParentIndexNumber = 0, IndexNumber = 1, AirsBeforeSeasonNumber = 1 },
+                    1);
+
+                Add(
+                    new Episode { ParentIndexNumber = 1, IndexNumber = 2 },
+                    new Episode { ParentIndexNumber = 0, IndexNumber = 1, AirsBeforeSeasonNumber = 1, AirsBeforeEpisodeNumber = 2 },
+                    1);
+
+                Add(
+                    new Episode { ParentIndexNumber = 1 },
+                    new Episode { ParentIndexNumber = 0, IndexNumber = 1, AirsBeforeSeasonNumber = 1, AirsBeforeEpisodeNumber = 2 },
+                    0);
+
+                Add(
+                    new Episode { ParentIndexNumber = 1, IndexNumber = 3 },
+                    new Episode { ParentIndexNumber = 0, IndexNumber = 1, AirsBeforeSeasonNumber = 1, AirsBeforeEpisodeNumber = 2 },
+                    1);
+
+                // Premiere Date
+                Add(
+                    new Episode { ParentIndexNumber = 1, IndexNumber = 1, PremiereDate = new DateTime(2021, 09, 12, 0, 0, 0) },
+                    new Episode { ParentIndexNumber = 1, IndexNumber = 1, PremiereDate = new DateTime(2021, 09, 12, 0, 0, 0) },
+                    0);
+
+                Add(
+                    new Episode { ParentIndexNumber = 1, IndexNumber = 1, PremiereDate = new DateTime(2021, 09, 11, 0, 0, 0) },
+                    new Episode { ParentIndexNumber = 1, IndexNumber = 1, PremiereDate = new DateTime(2021, 09, 12, 0, 0, 0) },
+                    -1);
+
+                Add(
+                    new Episode { ParentIndexNumber = 1, IndexNumber = 1, PremiereDate = new DateTime(2021, 09, 12, 0, 0, 0) },
+                    new Episode { ParentIndexNumber = 1, IndexNumber = 1, PremiereDate = new DateTime(2021, 09, 11, 0, 0, 0) },
+                    1);
+            }
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Test Data/HttpServer/ForceKeepAlive.json b/tests/Jellyfin.Server.Implementations.Tests/Test Data/HttpServer/ForceKeepAlive.json
new file mode 100644
index 000000000..0472a3cd0
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Test Data/HttpServer/ForceKeepAlive.json
@@ -0,0 +1 @@
+{"MessageType":"ForceKeepAlive","MessageId":"00000000-0000-0000-0000-000000000000","ServerId":null,"Data":60}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Test Data/HttpServer/Partial.json b/tests/Jellyfin.Server.Implementations.Tests/Test Data/HttpServer/Partial.json
new file mode 100644
index 000000000..72f810725
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Test Data/HttpServer/Partial.json
@@ -0,0 +1 @@
+{"MessageType":"KeepAlive","MessageId":"d29ef449-6965-4000
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Test Data/HttpServer/ValidPartial.json b/tests/Jellyfin.Server.Implementations.Tests/Test Data/HttpServer/ValidPartial.json
new file mode 100644
index 000000000..62d9099c8
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Test Data/HttpServer/ValidPartial.json
@@ -0,0 +1 @@
+{"MessageType":"ForceKeepAlive","MessageId":"00000000-0000-0000-0000-000000000000","ServerId":null,"Data":60}{"MessageType":"KeepAlive","MessageId":"d29ef449-6965-4000
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Test Data/LiveTv/10.10.10.100/discover.json b/tests/Jellyfin.Server.Implementations.Tests/Test Data/LiveTv/10.10.10.100/discover.json
new file mode 100644
index 000000000..a4ad4ed44
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Test Data/LiveTv/10.10.10.100/discover.json
@@ -0,0 +1 @@
+{"FriendlyName":"HDHomeRun DUAL","ModelNumber":"HDHR3-US","Legacy":1,"FirmwareName":"hdhomerun3_atsc","FirmwareVersion":"20200225","DeviceID":"10xxxxx5","TunerCount":2,"BaseURL":"http://10.10.10.100:80"}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Test Data/LiveTv/10.10.10.100/lineup.json b/tests/Jellyfin.Server.Implementations.Tests/Test Data/LiveTv/10.10.10.100/lineup.json
new file mode 100644
index 000000000..0967ef424
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Test Data/LiveTv/10.10.10.100/lineup.json
@@ -0,0 +1 @@
+{}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/LiveTv/discover.json b/tests/Jellyfin.Server.Implementations.Tests/Test Data/LiveTv/192.168.1.182/discover.json
index 851f17bb2..851f17bb2 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/LiveTv/discover.json
+++ b/tests/Jellyfin.Server.Implementations.Tests/Test Data/LiveTv/192.168.1.182/discover.json
diff --git a/tests/Jellyfin.Server.Implementations.Tests/LiveTv/lineup.json b/tests/Jellyfin.Server.Implementations.Tests/Test Data/LiveTv/192.168.1.182/lineup.json
index 4cb5ebc8e..4cb5ebc8e 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/LiveTv/lineup.json
+++ b/tests/Jellyfin.Server.Implementations.Tests/Test Data/LiveTv/192.168.1.182/lineup.json
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/headends_response.json b/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/headends_response.json
new file mode 100644
index 000000000..015afeecc
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/headends_response.json
@@ -0,0 +1 @@
+[{"headend":"CA00053","transport":"Cable","location":"Beverly Hills","lineups":[{"name":"Time Warner Cable - Cable","lineup":"USA-CA00053-DEFAULT","uri":"/20141201/lineups/USA-CA00053-DEFAULT"},{"name":"Time Warner Cable - Digital","lineup":"USA-CA00053-X","uri":"/20141201/lineups/USA-CA00053-X"}]},{"headend":"CA61222","transport":"Cable","location":"Beverly Hills","lineups":[{"name":"Mulholland Estates - Cable","lineup":"USA-CA61222-DEFAULT","uri":"/20141201/lineups/USA-CA61222-DEFAULT"}]},{"headend":"CA66511","transport":"Cable","location":"Los Angeles","lineups":[{"name":"AT&T U-verse TV - Digital","lineup":"USA-CA66511-X","uri":"/20141201/lineups/USA-CA66511-X"}]},{"headend":"CA67309","transport":"Cable","location":"Westchester","lineups":[{"name":"Time Warner Cable Sherman Oaks - Cable","lineup":"USA-CA67309-DEFAULT","uri":"/20141201/lineups/USA-CA67309-DEFAULT"},{"name":"Time Warner Cable Sherman Oaks - Digital","lineup":"USA-CA67309-X","uri":"/20141201/lineups/USA-CA67309-X"}]},{"headend":"CA67310","transport":"Cable","location":"Eagle Rock","lineups":[{"name":"Time Warner Cable City of Los Angeles - Cable","lineup":"USA-CA67310-DEFAULT","uri":"/20141201/lineups/USA-CA67310-DEFAULT"},{"name":"Time Warner Cable City of Los Angeles - Digital","lineup":"USA-CA67310-X","uri":"/20141201/lineups/USA-CA67310-X"}]},{"headend":"DISH803","transport":"Satellite","location":"Los Angeles","lineups":[{"name":"DISH Los Angeles - Satellite","lineup":"USA-DISH803-DEFAULT","uri":"/20141201/lineups/USA-DISH803-DEFAULT"}]},{"headend":"DITV803","transport":"Satellite","location":"Los Angeles","lineups":[{"name":"DIRECTV Los Angeles - Satellite","lineup":"USA-DITV803-DEFAULT","uri":"/20141201/lineups/USA-DITV803-DEFAULT"}]},{"headend":"90210","transport":"Antenna","location":"90210","lineups":[{"name":"Antenna","lineup":"USA-OTA-90210","uri":"/20141201/lineups/USA-OTA-90210"}]}]
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/lineup_response.json b/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/lineup_response.json
new file mode 100644
index 000000000..072089470
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/lineup_response.json
@@ -0,0 +1 @@
+{"map":[{"stationID":"24326","channel":"001","providerCallsign":"BBC ONE South","logicalChannelNumber":"1","matchType":"providerCallsign"},{"stationID":"17154","channel":"002","providerCallsign":"BBC TWO","logicalChannelNumber":"2","matchType":"providerCallsign"}]}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/lineups_response.json b/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/lineups_response.json
new file mode 100644
index 000000000..032a84e59
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/lineups_response.json
@@ -0,0 +1 @@
+{"code":0,"serverID":"20141201.web.1","datetime":"2015-04-17T14:22:17Z","lineups":[{"lineup":"GBR-0001317-DEFAULT","name":"Freeview - Carlton - LWT (Southeast)","transport":"DVB-T","location":"London","uri":"/20141201/lineups/GBR-0001317-DEFAULT"},{"lineup":"USA-IL57303-X","name":"Comcast Waukegan/Lake Forest Area - Digital","transport":"Cable","location":"Lake Forest","uri":"/20141201/lineups/USA-IL57303-X"},{"lineup":"USA-NY67791-X","name":"Verizon Fios Queens - Digital","transport":"Cable","location":"Fresh Meadows","uri":"/20141201/lineups/USA-NY67791-X"},{"lineup":"USA-OTA-60030","name":"Local Over the Air Broadcast","transport":"Antenna","location":"60030","uri":"/20141201/lineups/USA-OTA-60030"},{"lineup":"USA-WI61859-DEFAULT","name":"DELETED LINEUP","isDeleted":true}]}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/metadata_programs_response.json b/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/metadata_programs_response.json
new file mode 100644
index 000000000..78166f09a
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/metadata_programs_response.json
@@ -0,0 +1 @@
+[{"programID":"SH00712240","data":[{"width":"135","height":"180","uri":"assets/p282288_b_v2_aa.jpg","size":"Sm","aspect":"3x4","category":"Banner-L3","text":"yes","primary":"true","tier":"Series"},{"width":"720","height":"540","uri":"assets/p282288_b_h6_aa.jpg","size":"Lg","aspect":"4x3","category":"Banner-L3","text":"yes","primary":"true","tier":"Series"},{"width":"960","height":"1440","uri":"assets/p282288_b_v8_aa.jpg","size":"Ms","aspect":"2x3","category":"Banner-L3","text":"yes","primary":"true","tier":"Series"},{"width":"180","height":"135","uri":"assets/p282288_b_h5_aa.jpg","size":"Sm","aspect":"4x3","category":"Banner-L3","text":"yes","primary":"true","tier":"Series"}]}]
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/programs_response.json b/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/programs_response.json
new file mode 100644
index 000000000..fe2a94436
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/programs_response.json
@@ -0,0 +1 @@
+[{"programID":"EP000000060003","titles":[{"title120":"'Allo 'Allo!"}],"eventDetails":{"subType":"Series"},"descriptions":{"description1000":[{"descriptionLanguage":"en","description":"A disguised British Intelligence officer is sent to help the airmen."}]},"originalAirDate":"1985-11-04","genres":["Sitcom"],"episodeTitle150":"The Poloceman Cometh","metadata":[{"Gracenote":{"season":2,"episode":3}}],"cast":[{"personId":"383774","nameId":"392649","name":"Gorden Kaye","role":"Actor","billingOrder":"01"},{"personId":"246840","nameId":"250387","name":"Carmen Silvera","role":"Actor","billingOrder":"02"},{"personId":"376955","nameId":"385830","name":"Rose Hill","role":"Actor","billingOrder":"03"},{"personId":"259773","nameId":"263340","name":"Vicki Michelle","role":"Actor","billingOrder":"04"},{"personId":"353113","nameId":"361987","name":"Kirsten Cooke","role":"Actor","billingOrder":"05"},{"personId":"77787","nameId":"77787","name":"Richard Marner","role":"Actor","billingOrder":"06"},{"personId":"230921","nameId":"234193","name":"Guy Siner","role":"Actor","billingOrder":"07"},{"personId":"374934","nameId":"383809","name":"Kim Hartman","role":"Actor","billingOrder":"08"},{"personId":"369151","nameId":"378026","name":"Richard Gibson","role":"Actor","billingOrder":"09"},{"personId":"343690","nameId":"352564","name":"Arthur Bostrom","role":"Actor","billingOrder":"10"},{"personId":"352557","nameId":"361431","name":"John D. Collins","role":"Actor","billingOrder":"11"},{"personId":"605275","nameId":"627734","name":"Nicholas Frankau","role":"Actor","billingOrder":"12"},{"personId":"373394","nameId":"382269","name":"Jack Haig","role":"Actor","billingOrder":"13"}],"crew":[{"personId":"354407","nameId":"363281","name":"David Croft","role":"Director","billingOrder":"01"},{"personId":"354407","nameId":"363281","name":"David Croft","role":"Writer","billingOrder":"02"},{"personId":"105145","nameId":"105145","name":"Jeremy Lloyd","role":"Writer","billingOrder":"03"}],"showType":"Series","hasImageArtwork":true,"md5":"Jo5NKxoo44xRvBCAq8QT2A"},{"programID":"EP000000510142","titles":[{"title120":"A Different World"}],"eventDetails":{"subType":"Series"},"descriptions":{"description1000":[{"descriptionLanguage":"en","description":"Whitley and Dwayne tell new students about their honeymoon in Los Angeles."}]},"originalAirDate":"1992-09-24","genres":["Sitcom"],"episodeTitle150":"Honeymoon in L.A.","metadata":[{"Gracenote":{"season":6,"episode":1}}],"cast":[{"personId":"700","nameId":"700","name":"Jasmine Guy","role":"Actor","billingOrder":"01"},{"personId":"729","nameId":"729","name":"Kadeem Hardison","role":"Actor","billingOrder":"02"},{"personId":"120","nameId":"120","name":"Darryl M. Bell","role":"Actor","billingOrder":"03"},{"personId":"1729","nameId":"1729","name":"Cree Summer","role":"Actor","billingOrder":"04"},{"personId":"217","nameId":"217","name":"Charnele Brown","role":"Actor","billingOrder":"05"},{"personId":"1811","nameId":"1811","name":"Glynn Turman","role":"Actor","billingOrder":"06"},{"personId":"1232","nameId":"1232","name":"Lou Myers","role":"Actor","billingOrder":"07"},{"personId":"1363","nameId":"1363","name":"Jada Pinkett","role":"Guest Star","billingOrder":"08"},{"personId":"222967","nameId":"225536","name":"Ajai Sanders","role":"Guest Star","billingOrder":"09"},{"personId":"181744","nameId":"183292","name":"Karen Malina White","role":"Guest Star","billingOrder":"10"},{"personId":"305017","nameId":"318897","name":"Patrick Y. Malone","role":"Guest Star","billingOrder":"11"},{"personId":"9841","nameId":"9841","name":"Bumper Robinson","role":"Guest Star","billingOrder":"12"},{"personId":"426422","nameId":"435297","name":"Sister Souljah","role":"Guest Star","billingOrder":"13"},{"personId":"25","nameId":"25","name":"Debbie Allen","role":"Guest Star","billingOrder":"14"},{"personId":"668","nameId":"668","name":"Gilbert Gottfried","role":"Guest Star","billingOrder":"15"}],"showType":"Series","hasImageArtwork":true,"md5":"P5kz0QmCeYxIA+yL0H4DWw"}]
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/schedules_request.json b/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/schedules_request.json
new file mode 100644
index 000000000..5ef1bfb1c
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/schedules_request.json
@@ -0,0 +1 @@
+[{"stationID":"20454","date":["2015-03-13","2015-03-17"]},{"stationID":"10021","date":["2015-03-12","2015-03-13"]}]
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/schedules_response.json b/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/schedules_response.json
new file mode 100644
index 000000000..4a97e5517
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/schedules_response.json
@@ -0,0 +1 @@
+[{"stationID":"20454","programs":[{"programID":"SH005371070000","airDateTime":"2015-03-03T00:00:00Z","duration":1800,"md5":"Sy8HEMBPcuiAx3FBukUhKQ","new":true,"audioProperties":["stereo","cc"],"videoProperties":["hdtv"]},{"programID":"EP000014577244","airDateTime":"2015-03-03T00:30:00Z","duration":1800,"md5":"25DNXVXO192JI7Y9vSW9lQ","new":true,"audioProperties":["stereo","cc"],"videoProperties":["hdtv"]}]}]
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/token_live_response.json b/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/token_live_response.json
new file mode 100644
index 000000000..e5fb64a6f
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/token_live_response.json
@@ -0,0 +1 @@
+{"code":0,"message":"OK","serverID":"AWS-SD-web.1","datetime":"2016-08-23T13:55:25Z","token":"f3fca79989cafe7dead71beefedc812b"}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/token_offline_response.json b/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/token_offline_response.json
new file mode 100644
index 000000000..b66a4ed0c
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Test Data/SchedulesDirect/token_offline_response.json
@@ -0,0 +1 @@
+{"response":"SERVICE_OFFLINE","code":3000,"serverID":"20141201.web.1","message":"Server offline for maintenance.","datetime":"2015-04-23T00:03:32Z","token":"CAFEDEADBEEFCAFEDEADBEEFCAFEDEADBEEFCAFE"}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Test Data/Updates/empty.zip b/tests/Jellyfin.Server.Implementations.Tests/Test Data/Updates/empty.zip
new file mode 100644
index 000000000..15628e26b
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Test Data/Updates/empty.zip
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Test Data/Updates/manifest-stable.json b/tests/Jellyfin.Server.Implementations.Tests/Test Data/Updates/manifest-stable.json
new file mode 100644
index 000000000..b766e668e
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Test Data/Updates/manifest-stable.json
@@ -0,0 +1,684 @@
+[
+    {
+        "guid": "a4df60c5-6ab4-412a-8f79-2cab93fb2bc5",
+        "name": "Anime",
+        "description": "Manage your anime in Jellyfin. This plugin supports several different metadata providers and options for organizing your collection.\n",
+        "overview": "Manage your anime from Jellyfin",
+        "owner": "jellyfin",
+        "category": "Metadata",
+        "versions": [
+            {
+                "version": "10.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/anime/anime_10.0.0.0.zip",
+                "checksum": "93e969adeba1050423fc8817ed3c36f8",
+                "timestamp": "2020-08-17T01:41:13Z"
+            },
+            {
+                "version": "9.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/anime/anime_9.0.0.0.zip",
+                "checksum": "9b1cebff835813e15f414f44b40c41c8",
+                "timestamp": "2020-07-20T01:30:16Z"
+            }
+        ]
+    },
+    {
+        "guid": "70b7b43b-471b-4159-b4be-56750c795499",
+        "name": "Auto Organize",
+        "description": "Automatically organize your media",
+        "overview": "Automatically organize your media",
+        "owner": "jellyfin",
+        "category": "General",
+        "versions": [
+            {
+                "version": "9.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.7.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/auto-organize/auto-organize_9.0.0.0.zip",
+                "checksum": "ff29ac3cbe05d208b6af94cd6d9dea39",
+                "timestamp": "2020-12-05T22:31:12Z"
+            },
+            {
+                "version": "8.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/auto-organize/auto-organize_8.0.0.0.zip",
+                "checksum": "460bbb45e556464a8476b18e41c097f5",
+                "timestamp": "2020-07-20T01:30:25Z"
+            }
+        ]
+    },
+    {
+        "guid": "9c4e63f1-031b-4f25-988b-4f7d78a8b53e",
+        "name": "Bookshelf",
+        "description": "Supports several different metadata providers and options for organizing your collection.\n",
+        "overview": "Manage your books",
+        "owner": "jellyfin",
+        "category": "Metadata",
+        "versions": [
+            {
+                "version": "5.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.7.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/bookshelf/bookshelf_5.0.0.0.zip",
+                "checksum": "2063fb8ab317b8d77b200fde41eb5e1e",
+                "timestamp": "2020-12-05T22:03:13Z"
+            },
+            {
+                "version": "4.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/bookshelf/bookshelf_4.0.0.0.zip",
+                "checksum": "fc9f76c0815d766491e5b0f30ede55ed",
+                "timestamp": "2020-07-20T01:30:33Z"
+            }
+        ]
+    },
+    {
+        "guid": "cfa0f7f4-4155-4d71-849b-d6598dc4c5bb",
+        "name": "Email",
+        "description": "Send SMTP email notifications",
+        "overview": "Send SMTP email notifications",
+        "owner": "jellyfin",
+        "category": "Notifications",
+        "versions": [
+            {
+                "version": "9.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.7.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/email/email_9.0.0.0.zip",
+                "checksum": "cfe7afc00f3fbd6d6ab8244d7ff968ce",
+                "timestamp": "2020-12-05T22:20:32Z"
+            },
+            {
+                "version": "7.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/email/email_7.0.0.0.zip",
+                "checksum": "680ca511d8ad84923cb04f024fd8eb19",
+                "timestamp": "2020-07-20T01:30:40Z"
+            }
+        ]
+    },
+    {
+        "guid": "170a157f-ac6c-437a-abdd-ca9c25cebd39",
+        "name": "Fanart",
+        "description": "Scrape poster images for movies, shows, and artists in your library.",
+        "overview": "Scrape poster images from Fanart",
+        "owner": "jellyfin",
+        "category": "Metadata",
+        "versions": [
+            {
+                "version": "6.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.7.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/fanart/fanart_6.0.0.0.zip",
+                "checksum": "ee4360bfcc8722d5a3a54cfe7eef640f",
+                "timestamp": "2020-12-05T22:25:43Z"
+            },
+            {
+                "version": "5.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/fanart/fanart_5.0.0.0.zip",
+                "checksum": "f842f7d65d23f377761c907d40b89647",
+                "timestamp": "2020-07-20T01:30:48Z"
+            }
+        ]
+    },
+    {
+        "guid": "e29621a5-fa9e-4330-982e-ef6e54c0cad2",
+        "name": "Gotify Notification",
+        "description": "You must have a Gotify server to use this plugin!\n",
+        "overview": "Sends notifications to your Gotify server",
+        "owner": "crobibero",
+        "category": "Notifications",
+        "versions": [
+            {
+                "version": "7.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/gotify-notification/gotify-notification_7.0.0.0.zip",
+                "checksum": "7c5ff9e8792c8cdee7e8a2aaeb6cc093",
+                "timestamp": "2020-07-20T01:30:56Z"
+            }
+        ]
+    },
+    {
+        "guid": "a59b5c4b-05a8-488f-bfa8-7a63fffc7639",
+        "name": "IPTV",
+        "description": "Enable IPTV support in Jellyfin",
+        "overview": "Enable IPTV support in Jellyfin",
+        "owner": "jellyfin",
+        "category": "Channel",
+        "versions": [
+            {
+                "version": "6.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/iptv/iptv_6.0.0.0.zip",
+                "checksum": "9cf103bf67a4eda7c3a42d9b235f6447",
+                "timestamp": "2020-07-20T01:31:05Z"
+            }
+        ]
+    },
+    {
+        "guid": "4682DD4C-A675-4F1B-8E7C-79ADF137A8F8",
+        "name": "ISO Mounter",
+        "description": "Mount your ISO files for Jellyfin.\n",
+        "overview": "Mount your ISO files for Jellyfin",
+        "owner": "jellyfin",
+        "category": "Metadata",
+        "versions": [
+            {
+                "version": "1.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/iso-mounter/iso-mounter_1.0.0.0.zip",
+                "checksum": "847e5bc7ac34c1bf4dc5b28173170fae",
+                "timestamp": "2020-07-20T01:31:13Z"
+            }
+        ]
+    },
+    {
+        "guid": "771e19d6-5385-4caf-b35c-28a0e865cf63",
+        "name": "Kodi Sync Queue",
+        "description": "This plugin will track all media changes while Kodi clients are offline to decrease sync times.",
+        "overview": "Sync all media changes with Kodi clients",
+        "owner": "jellyfin",
+        "category": "General",
+        "versions": [
+            {
+                "version": "6.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.7.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/kodi-sync-queue/kodi-sync-queue_6.0.0.0.zip",
+                "checksum": "787c856c0d2ad2224cdd8b3094cf0329",
+                "timestamp": "2020-12-05T22:10:37Z"
+            },
+            {
+                "version": "5.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/kodi-sync-queue/kodi-sync-queue_5.0.0.0.zip",
+                "checksum": "08285397aecd93ea64a4f15d38b1bd7b",
+                "timestamp": "2020-07-20T01:31:22Z"
+            }
+        ]
+    },
+    {
+        "guid": "958aad66-3784-4d2a-b89a-a7b6fab6e25c",
+        "name": "LDAP Authentication",
+        "description": "Authenticate your Jellyfin users against an LDAP database, and optionally create users who do not yet exist automatically.\nAllows the administrator to customize most aspects of the LDAP authentication process, including customizable search attributes, username attribute, and a search filter for administrative users (set on user creation). The user, via the \"Manual Login\" process, can enter any valid attribute value, which will be mapped back to the specified username attribute automatically as well.\n",
+        "overview": "Authenticate users against an LDAP database",
+        "owner": "jellyfin",
+        "category": "Authentication",
+        "versions": [
+            {
+                "version": "10.0.0.0",
+                "changelog": "Update for 10.7 support\n",
+                "targetAbi": "10.7.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/ldap-authentication/ldap-authentication_10.0.0.0.zip",
+                "checksum": "62e7e1cd3ffae0944c14750a3c90df4f",
+                "timestamp": "2020-12-05T19:48:10Z"
+            },
+            {
+                "version": "9.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/ldap-authentication/ldap-authentication_9.0.0.0.zip",
+                "checksum": "7f2f83587a65a43ebf168e4058421463",
+                "timestamp": "2020-07-22T15:42:57Z"
+            },
+            {
+                "version": "8.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/ldap-authentication/ldap-authentication_8.0.0.0.zip",
+                "checksum": "8af8cee62717d63577f8b1e710839415",
+                "timestamp": "2020-07-20T01:31:30Z"
+            }
+        ]
+    },
+    {
+        "guid": "9574ac10-bf23-49bc-949f-924f23cfa48f",
+        "name": "NextPVR",
+        "description": "Provides access to live TV, program guide, and recordings from NextPVR.\n",
+        "overview": "Live TV plugin for NextPVR",
+        "owner": "jellyfin",
+        "category": "LiveTV",
+        "versions": [
+            {
+                "version": "5.0.0.0",
+                "changelog": "Updated to use NextPVR API v5, no longer compatable with API v4.\n",
+                "targetAbi": "10.7.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/nextpvr/nextpvr_5.0.0.0.zip",
+                "checksum": "d70f694d14bf9462ba2b2ebe110068d3",
+                "timestamp": "2020-12-05T22:24:03Z"
+            },
+            {
+                "version": "4.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/nextpvr/nextpvr_4.0.0.0.zip",
+                "checksum": "b15949d895ac5a8c89496581db350478",
+                "timestamp": "2020-07-20T01:31:38Z"
+            }
+        ]
+    },
+    {
+        "guid": "4b9ed42f-5185-48b5-9803-6ff2989014c4",
+        "name": "Open Subtitles",
+        "description": "Download subtitles from the internet to use with your media files.",
+        "overview": "Download subtitles for your media",
+        "owner": "jellyfin",
+        "category": "Metadata",
+        "versions": [
+            {
+                "version": "10.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.7.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/open-subtitles/open-subtitles_10.0.0.0.zip",
+                "checksum": "ed99d03ec463bf15fca1256a113f57b4",
+                "timestamp": "2020-12-05T21:56:19Z"
+            },
+            {
+                "version": "9.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/open-subtitles/open-subtitles_9.0.0.0.zip",
+                "checksum": "16789b26497cea0509daf6b18c579340",
+                "timestamp": "2020-07-20T01:32:00Z"
+            }
+        ]
+    },
+    {
+        "guid": "5c534381-91a3-43cb-907a-35aa02eb9d2c",
+        "name": "Playback Reporting",
+        "description": "Collect and show user play statistics",
+        "overview": "Collect and show user play statistics",
+        "owner": "jellyfin",
+        "category": "General",
+        "versions": [
+            {
+                "version": "9.0.0.0",
+                "changelog": "Add authentication to plugin endpoints\n",
+                "targetAbi": "10.7.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/playback-reporting/playback-reporting_9.0.0.0.zip",
+                "checksum": "ca323b3dcb2cb86cc2e72a7a0f1eee22",
+                "timestamp": "2020-12-05T22:15:48Z"
+            },
+            {
+                "version": "8.0.0.0",
+                "changelog": "Add authentication to plugin endpoints\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/playback-reporting/playback-reporting_8.0.0.0.zip",
+                "checksum": "58644c505586542ef0b8b65e2f704bd1",
+                "timestamp": "2020-11-18T03:01:51Z"
+            },
+            {
+                "version": "7.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/playback-reporting/playback-reporting_7.0.0.0.zip",
+                "checksum": "6a361ef33bca97f9155856d02ff47380",
+                "timestamp": "2020-07-20T01:32:09Z"
+            }
+        ]
+    },
+    {
+        "guid": "de228f12-e43e-4bd9-9fc0-2830819c3b92",
+        "name": "Pushbullet",
+        "description": "Get notifications via Pushbullet.\n",
+        "overview": "Pushbullet notification plugin",
+        "owner": "jellyfin",
+        "category": "Notifications",
+        "versions": [
+            {
+                "version": "6.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.7.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/pushbullet/pushbullet_6.0.0.0.zip",
+                "checksum": "248cf3d56644f1d909e75aaddbdfb3a6",
+                "timestamp": "2020-12-06T02:47:53Z"
+            },
+            {
+                "version": "5.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/pushbullet/pushbullet_5.0.0.0.zip",
+                "checksum": "dabbdd86328b2922a69dfa0c9e1c8343",
+                "timestamp": "2020-07-20T01:32:17Z"
+            }
+        ]
+    },
+    {
+        "guid": "F240D6BE-5743-441B-87F1-A70ECAC42642",
+        "name": "Pushover",
+        "description": "Send messages to a wide range of devices through Pushover.",
+        "overview": "Send notifications via Pushover",
+        "owner": "crobibero",
+        "category": "Notifications",
+        "versions": [
+            {
+                "version": "4.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/pushover/pushover_4.0.0.0.zip",
+                "checksum": "56a0da16c7e48cc184987737b7e155dd",
+                "timestamp": "2020-07-20T01:32:25Z"
+            }
+        ]
+    },
+    {
+        "guid": "d4312cd9-5c90-4f38-82e8-51da566790e8",
+        "name": "Reports",
+        "description": "Generate reports of your media library",
+        "overview": "Generate reports of your media library",
+        "owner": "jellyfin",
+        "category": "General",
+        "versions": [
+            {
+                "version": "11.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.7.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/reports/reports_11.0.0.0.zip",
+                "checksum": "d71bc6a4c008e58ee70ad44c83bfd310",
+                "timestamp": "2020-12-05T22:00:46Z"
+            },
+            {
+                "version": "10.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/reports/reports_10.0.0.0.zip",
+                "checksum": "3917e75839337475b42daf2ba0b5bd7b",
+                "timestamp": "2020-10-19T19:30:41Z"
+            },
+            {
+                "version": "9.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/reports/reports_9.0.0.0.zip",
+                "checksum": "5b5ad8d885616a21e8d1e8eecf5ea979",
+                "timestamp": "2020-10-16T23:52:37Z"
+            }
+        ]
+    },
+    {
+        "guid": "1fc322a1-af2e-49a5-b2eb-a89b4240f700",
+        "name": "ServerWMC",
+        "description": "Provides access to Live TV, Program Guide and Recordings from your Windows MediaCenter Server running ServerWMC. Requires ServerWMC to be installed and running on your Windows MediaCenter machine.\n",
+        "overview": "Jellyfin Live TV plugin for Windows MediaCenter with ServerWMC",
+        "owner": "jellyfin",
+        "category": "LiveTV",
+        "versions": [
+            {
+                "version": "6.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.7.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/serverwmc/serverwmc_6.0.0.0.zip",
+                "checksum": "3120af0cea2c1cb8b7cf578d9b4b862c",
+                "timestamp": "2020-12-05T22:28:15Z"
+            },
+            {
+                "version": "5.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/serverwmc/serverwmc_5.0.0.0.zip",
+                "checksum": "dc44b039aa1b66eaf40a44fbf02d37e2",
+                "timestamp": "2020-07-20T01:32:42Z"
+            }
+        ]
+    },
+    {
+        "guid": "94fb77c3-55ad-4c50-bf4e-4e5497467b79",
+        "name": "Slack Notifications",
+        "description": "Get notifications via Slack.\n",
+        "overview": "Get notifications via Slack",
+        "owner": "jellyfin",
+        "category": "Notifications",
+        "versions": [
+            {
+                "version": "7.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.7.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/slack-notifications/slack-notifications_7.0.0.0.zip",
+                "checksum": "1d5330a77ce7b2a9ac8e5d58088a012c",
+                "timestamp": "2020-12-05T22:40:02Z"
+            },
+            {
+                "version": "6.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/slack-notifications/slack-notifications_6.0.0.0.zip",
+                "checksum": "ede4cbe064542d1ecccc5823921bee4b",
+                "timestamp": "2020-07-20T01:32:50Z"
+            }
+        ]
+    },
+    {
+        "guid": "bc4aad2e-d3d0-4725-a5e2-fd07949e5b42",
+        "name": "TMDb Box Sets",
+        "description": "Automatically create movie box sets based on TMDb collections",
+        "overview": "Automatically create movie box sets based on TMDb collections",
+        "owner": "jellyfin",
+        "category": "Metadata",
+        "versions": [
+            {
+                "version": "7.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.7.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/tmdb-box-sets/tmdb-box-sets_7.0.0.0.zip",
+                "checksum": "1551792e6af4d36f2cead01153c73cf0",
+                "timestamp": "2020-12-05T22:07:21Z"
+            },
+            {
+                "version": "6.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/tmdb-box-sets/tmdb-box-sets_6.0.0.0.zip",
+                "checksum": "b92b68a922c5fcbb8f4d47b8601b01b6",
+                "timestamp": "2020-07-20T01:32:58Z"
+            }
+        ]
+    },
+    {
+        "guid": "4fe3201e-d6ae-4f2e-8917-e12bda571281",
+        "name": "Trakt",
+        "description": "Record your watched media with Trakt.\n",
+        "overview": "Record your watched media with Trakt",
+        "owner": "jellyfin",
+        "category": "General",
+        "versions": [
+            {
+                "version": "11.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.7.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/trakt/trakt_11.0.0.0.zip",
+                "checksum": "2257ccde1e39114644a27e0966a0bf2d",
+                "timestamp": "2020-12-05T19:56:12Z"
+            },
+            {
+                "version": "10.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/trakt/trakt_10.0.0.0.zip",
+                "checksum": "ab67e6b59ea2e7860a6a3ff7b8452759",
+                "timestamp": "2020-07-20T01:33:06Z"
+            }
+        ]
+    },
+    {
+        "guid": "3fd018e5-5e78-4e58-b280-a0c068febee0",
+        "name": "TVHeadend",
+        "description": "Manage TVHeadend from Jellyfin",
+        "overview": "Manage TVHeadend from Jellyfin",
+        "owner": "jellyfin",
+        "category": "LiveTV",
+        "versions": [
+            {
+                "version": "7.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.7.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/tvheadend/tvheadend_7.0.0.0.zip",
+                "checksum": "1abbfce737b6962f4b1b2255dc63e932",
+                "timestamp": "2021-01-05T16:20:33Z"
+            },
+            {
+                "version": "6.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/tvheadend/tvheadend_6.0.0.0.zip",
+                "checksum": "143c34fd70d7173b8912cc03ce4b517d",
+                "timestamp": "2020-07-20T01:33:15Z"
+            }
+        ]
+    },
+    {
+        "guid": "022a3003-993f-45f1-8565-87d12af2e12a",
+        "name": "InfuseSync",
+        "description": "This plugin will track all media changes while any Infuse clients are offline to decrease sync times when logging back in to your server.",
+        "overview": "Blazing fast indexing for Infuse",
+        "owner": "Firecore LLC",
+        "category": "General",
+        "versions": [
+            {
+                "version": "1.2.4.0",
+                "changelog": "New Playlist support.\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://github.com/firecore/InfuseSync/releases/download/v1.2.4/InfuseSync-jellyfin-1.2.4.zip",
+                "checksum": "7adde11b8c8404fd2923f59d98fb1a30",
+                "timestamp": "2020-10-12T08:00:00Z"
+            },
+            {
+                "version": "1.2.1.3",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://github.com/firecore/InfuseSync/releases/download/v1.2.3/InfuseSync-jellyfin-1.2.3.zip",
+                "checksum": "d8e2c5fe736a302097bb3bac3d04b1c4",
+                "timestamp": "2020-09-18T12:19:00Z"
+            },
+            {
+                "version": "1.2.1.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://github.com/firecore/InfuseSync/releases/download/v1.2.1/InfuseSync-jellyfin-1.2.1.zip",
+                "checksum": "1a853e926cc422f5d79d398d9ae18ee8",
+                "timestamp": "2020-08-21T10:48:00Z"
+            },
+            {
+                "version": "1.2.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://github.com/firecore/InfuseSync/releases/download/v1.2.0/InfuseSync-jellyfin-1.2.0.zip",
+                "checksum": "2d3c7859852695a7f05adc6d3fcbc783",
+                "timestamp": "2020-07-20T11:51:00Z"
+            }
+        ]
+    },
+    {
+        "guid": "8119f3c6-cfc2-4d9c-a0ba-028f1d93e526",
+        "name": "Cover Art Archive",
+        "description": "This plugin provides images from the Cover Art Archive https://musicbrainz.org/doc/Cover_Art_Archive and depends on the MusicBrainz metadata provider to know what images belong where\n",
+        "overview": "MusicBrainz Cover Art Archive",
+        "owner": "jellyfin",
+        "category": "Metadata",
+        "versions": [
+            {
+                "version": "2.0.0.0",
+                "changelog": "changelog\n",
+                "targetAbi": "10.7.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/cover-art-archive/cover-art-archive_2.0.0.0.zip",
+                "checksum": "bea8fa4a37b3e7ed74e22266e7597a68",
+                "timestamp": "2020-12-06T02:51:03Z"
+            },
+            {
+                "version": "1.0.0.3",
+                "changelog": "changelog\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/cover-art-archive/cover-art-archive_1.0.0.3.zip",
+                "checksum": "c502a5c54b168810614c1c40709b9598",
+                "timestamp": "2020-08-06T21:21:22Z"
+            }
+        ]
+    },
+    {
+        "guid": "A4A488D0-17A3-4919-8D82-7F3DE4F6B209",
+        "name": "TV Maze",
+        "description": "Get TV metadata from TV Maze\n",
+        "overview": "Get TV metadata from TV Maze",
+        "owner": "jellyfin",
+        "category": "Metadata",
+        "versions": [
+            {
+                "version": "5.0.0.0",
+                "changelog": "Get additional image types\n",
+                "targetAbi": "10.7.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/tv-maze/tv-maze_5.0.0.0.zip",
+                "checksum": "509a85e40b1d1ac36eef45673deaf606",
+                "timestamp": "2020-12-06T02:51:56Z"
+            },
+            {
+                "version": "4.0.0.0",
+                "changelog": "Get additional image types\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/tv-maze/tv-maze_4.0.0.0.zip",
+                "checksum": "58ee9ab3f129151bdfff033ad889ad87",
+                "timestamp": "2020-11-24T14:44:37Z"
+            },
+            {
+                "version": "3.0.0.0",
+                "changelog": "Remove unused dependencies \n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/tv-maze/tv-maze_3.0.0.0.zip",
+                "checksum": "f3b2c70b3e136fb15c917e4420f4fdec",
+                "timestamp": "2020-11-09T14:32:56Z"
+            },
+            {
+                "version": "2.0.0.0",
+                "changelog": "Remove unused dependencies \n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/tv-maze/tv-maze_2.0.0.0.zip",
+                "checksum": "c7662ae8ae52ce8a4e8d685d55f36e80",
+                "timestamp": "2020-11-09T02:33:11Z"
+            },
+            {
+                "version": "1.0.0.0",
+                "changelog": "Initial release.\n",
+                "targetAbi": "10.6.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/tv-maze/tv-maze_1.0.0.0.zip",
+                "checksum": "c90eee48c12f2c07880b4b28e507fd14",
+                "timestamp": "2020-11-08T19:05:32Z"
+            }
+        ]
+    },
+    {
+        "guid": "a677c0da-fac5-4cde-941a-7134223f14c8",
+        "name": "TheTVDB",
+        "description": "Get TV metadata from TheTvdb\n",
+        "overview": "Get TV metadata from TheTvdb",
+        "owner": "jellyfin",
+        "category": "Metadata",
+        "versions": [
+            {
+                "version": "2.0.0.0",
+                "changelog": "Remove from Jellyfin core.\n",
+                "targetAbi": "10.7.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/thetvdb/thetvdb_2.0.0.0.zip",
+                "checksum": "e46cee334476a1b475e5c553171c4cb6",
+                "timestamp": "2020-12-16T20:03:28Z"
+            },
+            {
+                "version": "1.0.0.0",
+                "changelog": "Remove from Jellyfin core.\n",
+                "targetAbi": "10.7.0.0",
+                "sourceUrl": "https://repo.jellyfin.org/releases/plugin/thetvdb/thetvdb_1.0.0.0.zip",
+                "checksum": "5a3dca5c0db4824d83bfd4e7e2b7bf11",
+                "timestamp": "2020-12-06T02:56:40Z"
+            }
+        ]
+    }
+]
\ No newline at end of file
diff --git a/tests/Jellyfin.Server.Implementations.Tests/TypedBaseItem/BaseItemKindTests.cs b/tests/Jellyfin.Server.Implementations.Tests/TypedBaseItem/BaseItemKindTests.cs
new file mode 100644
index 000000000..31f33c682
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/TypedBaseItem/BaseItemKindTests.cs
@@ -0,0 +1,63 @@
+using System;
+using System.Linq;
+using Jellyfin.Data.Enums;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.TypedBaseItem
+{
+    public class BaseItemKindTests
+    {
+        public static TheoryData<Type> BaseItemKind_TestData()
+        {
+            var data = new TheoryData<Type>();
+
+            var loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies();
+            foreach (var assembly in loadedAssemblies)
+            {
+                if (IsProjectAssemblyName(assembly.FullName))
+                {
+                    var baseItemTypes = assembly.GetTypes()
+                        .Where(targetType => targetType.IsClass
+                                             && !targetType.IsAbstract
+                                             && targetType.IsSubclassOf(typeof(MediaBrowser.Controller.Entities.BaseItem)));
+                    foreach (var baseItemType in baseItemTypes)
+                    {
+                        data.Add(baseItemType);
+                    }
+                }
+            }
+
+            return data;
+        }
+
+        [Theory]
+        [MemberData(nameof(BaseItemKind_TestData))]
+        public void EnumParse_GivenValidBaseItemType_ReturnsEnumValue(Type baseItemDescendantType)
+        {
+            var enumValue = Enum.Parse<BaseItemKind>(baseItemDescendantType.Name);
+            Assert.True(Enum.IsDefined(typeof(BaseItemKind), enumValue));
+        }
+
+        [Theory]
+        [MemberData(nameof(BaseItemKind_TestData))]
+        public void GetBaseItemKind_WhenCalledAfterDefaultCtor_DoesNotThrow(Type baseItemDescendantType)
+        {
+            var defaultConstructor = baseItemDescendantType.GetConstructor(Type.EmptyTypes);
+            var instance = (MediaBrowser.Controller.Entities.BaseItem)defaultConstructor!.Invoke(null);
+            var exception = Record.Exception(() => instance.GetBaseItemKind());
+            Assert.Null(exception);
+        }
+
+        private static bool IsProjectAssemblyName(string? name)
+        {
+            if (name == null)
+            {
+                return false;
+            }
+
+            return name.StartsWith("Jellyfin", StringComparison.OrdinalIgnoreCase)
+                   || name.StartsWith("Emby", StringComparison.OrdinalIgnoreCase)
+                   || name.StartsWith("MediaBrowser", StringComparison.OrdinalIgnoreCase);
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Updates/InstallationManagerTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Updates/InstallationManagerTests.cs
new file mode 100644
index 000000000..7abd2e685
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Updates/InstallationManagerTests.cs
@@ -0,0 +1,110 @@
+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.Updates;
+using MediaBrowser.Model.Updates;
+using Moq;
+using Moq.Protected;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.Updates
+{
+    public class InstallationManagerTests
+    {
+        private readonly Fixture _fixture;
+        private readonly InstallationManager _installationManager;
+
+        public InstallationManagerTests()
+        {
+            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("Test Data/Updates/" + 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
+            });
+            _fixture.Inject(http);
+            _installationManager = _fixture.Create<InstallationManager>();
+        }
+
+        [Fact]
+        public async Task GetPackages_Valid_Success()
+        {
+            PackageInfo[] packages = await _installationManager.GetPackages(
+                "Jellyfin Stable",
+                "https://repo.jellyfin.org/releases/plugin/manifest-stable.json",
+                false);
+
+            Assert.Equal(25, packages.Length);
+        }
+
+        [Fact]
+        public async Task FilterPackages_NameOnly_Success()
+        {
+            PackageInfo[] packages = await _installationManager.GetPackages(
+                "Jellyfin Stable",
+                "https://repo.jellyfin.org/releases/plugin/manifest-stable.json",
+                false);
+
+            packages = _installationManager.FilterPackages(packages, "Anime").ToArray();
+            Assert.Single(packages);
+        }
+
+        [Fact]
+        public async Task FilterPackages_GuidOnly_Success()
+        {
+            PackageInfo[] packages = await _installationManager.GetPackages(
+                "Jellyfin Stable",
+                "https://repo.jellyfin.org/releases/plugin/manifest-stable.json",
+                false);
+
+            packages = _installationManager.FilterPackages(packages, id: new Guid("a4df60c5-6ab4-412a-8f79-2cab93fb2bc5")).ToArray();
+            Assert.Single(packages);
+        }
+
+        [Fact]
+        public async Task InstallPackage_InvalidChecksum_ThrowsInvalidDataException()
+        {
+            var packageInfo = new InstallationInfo()
+            {
+                Name = "Test",
+                SourceUrl = "https://repo.jellyfin.org/releases/plugin/empty/empty.zip",
+                Checksum = "InvalidChecksum"
+            };
+
+            await Assert.ThrowsAsync<InvalidDataException>(() => _installationManager.InstallPackage(packageInfo, CancellationToken.None)).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task InstallPackage_Valid_Success()
+        {
+            var packageInfo = new InstallationInfo()
+            {
+                Name = "Test",
+                SourceUrl = "https://repo.jellyfin.org/releases/plugin/empty/empty.zip",
+                Checksum = "11b5b2f1a9ebc4f66d6ef19018543361"
+            };
+
+            var ex = await Record.ExceptionAsync(() => _installationManager.InstallPackage(packageInfo, CancellationToken.None)).ConfigureAwait(false);
+            Assert.Null(ex);
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Users/UserManagerTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Users/UserManagerTests.cs
new file mode 100644
index 000000000..867dda29d
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Users/UserManagerTests.cs
@@ -0,0 +1,28 @@
+using System;
+using Jellyfin.Server.Implementations.Users;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.Users
+{
+    public class UserManagerTests
+    {
+        [Theory]
+        [InlineData("this_is_valid")]
+        [InlineData("this is also valid")]
+        [InlineData("0@_-' .")]
+        public void ThrowIfInvalidUsername_WhenValidUsername_DoesNotThrowArgumentException(string username)
+        {
+            var ex = Record.Exception(() => UserManager.ThrowIfInvalidUsername(username));
+            Assert.Null(ex);
+        }
+
+        [Theory]
+        [InlineData(" ")]
+        [InlineData("")]
+        [InlineData("special characters like & $ ? are not allowed")]
+        public void ThrowIfInvalidUsername_WhenInvalidUsername_ThrowsArgumentException(string username)
+        {
+            Assert.Throws<ArgumentException>(() => UserManager.ThrowIfInvalidUsername(username));
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Integration.Tests/AuthHelper.cs b/tests/Jellyfin.Server.Integration.Tests/AuthHelper.cs
new file mode 100644
index 000000000..21131eb97
--- /dev/null
+++ b/tests/Jellyfin.Server.Integration.Tests/AuthHelper.cs
@@ -0,0 +1,58 @@
+using System;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Net.Http.Headers;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Jellyfin.Api.Models.StartupDtos;
+using Jellyfin.Api.Models.UserDtos;
+using Jellyfin.Extensions.Json;
+using Xunit;
+
+namespace Jellyfin.Server.Integration.Tests
+{
+    public static class AuthHelper
+    {
+        public const string AuthHeaderName = "X-Emby-Authorization";
+        public const string DummyAuthHeader = "MediaBrowser Client=\"Jellyfin.Server Integration Tests\", DeviceId=\"69420\", Device=\"Apple II\", Version=\"10.8.0\"";
+
+        public static async Task<string> CompleteStartupAsync(HttpClient client)
+        {
+            var jsonOptions = JsonDefaults.Options;
+            var userResponse = await client.GetByteArrayAsync("/Startup/User").ConfigureAwait(false);
+            var user = JsonSerializer.Deserialize<StartupUserDto>(userResponse, jsonOptions);
+
+            using var completeResponse = await client.PostAsync("/Startup/Complete", new ByteArrayContent(Array.Empty<byte>())).ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.NoContent, completeResponse.StatusCode);
+
+            using var content = JsonContent.Create(
+                new AuthenticateUserByName()
+                {
+                    Username = user!.Name,
+                    Pw = user.Password,
+                },
+                options: jsonOptions);
+            content.Headers.Add("X-Emby-Authorization", DummyAuthHeader);
+
+            using var authResponse = await client.PostAsync("/Users/AuthenticateByName", content).ConfigureAwait(false);
+            var auth = await JsonSerializer.DeserializeAsync<AuthenticationResultDto>(
+                await authResponse.Content.ReadAsStreamAsync().ConfigureAwait(false),
+                jsonOptions).ConfigureAwait(false);
+
+            return auth!.AccessToken;
+        }
+
+        public static void AddAuthHeader(this HttpHeaders headers, string accessToken)
+        {
+            headers.Add(AuthHeaderName, DummyAuthHeader + $", Token={accessToken}");
+        }
+
+        private class AuthenticationResultDto
+        {
+            public string AccessToken { get; set; } = string.Empty;
+
+            public string ServerId { get; set; } = string.Empty;
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Integration.Tests/Controllers/ActivityLogControllerTests.cs b/tests/Jellyfin.Server.Integration.Tests/Controllers/ActivityLogControllerTests.cs
new file mode 100644
index 000000000..be89fbc9a
--- /dev/null
+++ b/tests/Jellyfin.Server.Integration.Tests/Controllers/ActivityLogControllerTests.cs
@@ -0,0 +1,30 @@
+using System.Net;
+using System.Net.Mime;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Jellyfin.Server.Integration.Tests.Controllers
+{
+    public sealed class ActivityLogControllerTests : IClassFixture<JellyfinApplicationFactory>
+    {
+        private readonly JellyfinApplicationFactory _factory;
+        private static string? _accessToken;
+
+        public ActivityLogControllerTests(JellyfinApplicationFactory factory)
+        {
+            _factory = factory;
+        }
+
+        [Fact]
+        public async Task ActivityLog_GetEntries_Ok()
+        {
+            var client = _factory.CreateClient();
+            client.DefaultRequestHeaders.AddAuthHeader(_accessToken ??= await AuthHelper.CompleteStartupAsync(client).ConfigureAwait(false));
+
+            var response = await client.GetAsync("System/ActivityLog/Entries").ConfigureAwait(false);
+
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            Assert.Equal(MediaTypeNames.Application.Json, response.Content.Headers.ContentType?.MediaType);
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Integration.Tests/Controllers/BaseJellyfinTestController.cs b/tests/Jellyfin.Server.Integration.Tests/Controllers/BaseJellyfinTestController.cs
new file mode 100644
index 000000000..9db8689a7
--- /dev/null
+++ b/tests/Jellyfin.Server.Integration.Tests/Controllers/BaseJellyfinTestController.cs
@@ -0,0 +1,14 @@
+using Jellyfin.Api;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Jellyfin.Server.Integration.Tests.Controllers
+{
+    /// <summary>
+    /// Base controller for testing infrastructure.
+    /// Automatically ignored in generated openapi spec.
+    /// </summary>
+    [ApiExplorerSettings(IgnoreApi = true)]
+    public class BaseJellyfinTestController : BaseJellyfinApiController
+    {
+    }
+}
diff --git a/tests/Jellyfin.Api.Tests/BrandingServiceTests.cs b/tests/Jellyfin.Server.Integration.Tests/Controllers/BrandingControllerTests.cs
index 1cbe94c5b..87136dfc8 100644
--- a/tests/Jellyfin.Api.Tests/BrandingServiceTests.cs
+++ b/tests/Jellyfin.Server.Integration.Tests/Controllers/BrandingControllerTests.cs
@@ -1,15 +1,18 @@
+using System.Net;
+using System.Net.Mime;
+using System.Text;
 using System.Text.Json;
 using System.Threading.Tasks;
 using MediaBrowser.Model.Branding;
 using Xunit;
 
-namespace Jellyfin.Api.Tests
+namespace Jellyfin.Server.Integration.Tests
 {
-    public sealed class BrandingServiceTests : IClassFixture<JellyfinApplicationFactory>
+    public sealed class BrandingControllerTests : IClassFixture<JellyfinApplicationFactory>
     {
         private readonly JellyfinApplicationFactory _factory;
 
-        public BrandingServiceTests(JellyfinApplicationFactory factory)
+        public BrandingControllerTests(JellyfinApplicationFactory factory)
         {
             _factory = factory;
         }
@@ -24,8 +27,9 @@ namespace Jellyfin.Api.Tests
             var response = await client.GetAsync("/Branding/Configuration");
 
             // Assert
-            response.EnsureSuccessStatusCode();
-            Assert.Equal("application/json; charset=utf-8", response.Content.Headers.ContentType?.ToString());
+            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 responseBody = await response.Content.ReadAsStreamAsync();
             _ = await JsonSerializer.DeserializeAsync<BrandingOptions>(responseBody);
         }
@@ -42,8 +46,9 @@ namespace Jellyfin.Api.Tests
             var response = await client.GetAsync(url);
 
             // Assert
-            response.EnsureSuccessStatusCode();
-            Assert.Equal("text/css; charset=utf-8", response.Content.Headers.ContentType?.ToString());
+            Assert.True(response.IsSuccessStatusCode);
+            Assert.Equal("text/css", response.Content.Headers.ContentType?.MediaType);
+            Assert.Equal(Encoding.UTF8.BodyName, response.Content.Headers.ContentType?.CharSet);
         }
     }
 }
diff --git a/tests/Jellyfin.Server.Integration.Tests/Controllers/DashboardControllerTests.cs b/tests/Jellyfin.Server.Integration.Tests/Controllers/DashboardControllerTests.cs
new file mode 100644
index 000000000..3396a94e5
--- /dev/null
+++ b/tests/Jellyfin.Server.Integration.Tests/Controllers/DashboardControllerTests.cs
@@ -0,0 +1,86 @@
+using System.IO;
+using System.Net;
+using System.Net.Mime;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Jellyfin.Api.Models;
+using Jellyfin.Extensions.Json;
+using Xunit;
+
+namespace Jellyfin.Server.Integration.Tests.Controllers
+{
+    public sealed class DashboardControllerTests : IClassFixture<JellyfinApplicationFactory>
+    {
+        private readonly JellyfinApplicationFactory _factory;
+        private readonly JsonSerializerOptions _jsonOpions = JsonDefaults.Options;
+
+        public DashboardControllerTests(JellyfinApplicationFactory factory)
+        {
+            _factory = factory;
+        }
+
+        [Fact]
+        public async Task GetDashboardConfigurationPage_NonExistingPage_NotFound()
+        {
+            var client = _factory.CreateClient();
+
+            var response = await client.GetAsync("web/ConfigurationPage?name=ThisPageDoesntExists").ConfigureAwait(false);
+
+            Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
+        }
+
+        [Fact]
+        public async Task GetDashboardConfigurationPage_ExistingPage_CorrectPage()
+        {
+            var client = _factory.CreateClient();
+
+            var response = await client.GetAsync("/web/ConfigurationPage?name=TestPlugin").ConfigureAwait(false);
+
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            Assert.Equal(MediaTypeNames.Text.Html, response.Content.Headers.ContentType?.MediaType);
+            StreamReader reader = new StreamReader(typeof(TestPlugin).Assembly.GetManifestResourceStream("Jellyfin.Server.Integration.Tests.TestPage.html")!);
+            Assert.Equal(await response.Content.ReadAsStringAsync().ConfigureAwait(false), await reader.ReadToEndAsync().ConfigureAwait(false));
+        }
+
+        [Fact]
+        public async Task GetDashboardConfigurationPage_BrokenPage_NotFound()
+        {
+            var client = _factory.CreateClient();
+
+            var response = await client.GetAsync("/web/ConfigurationPage?name=BrokenPage").ConfigureAwait(false);
+
+            Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
+        }
+
+        [Fact]
+        public async Task GetConfigurationPages_NoParams_AllConfigurationPages()
+        {
+            var client = _factory.CreateClient();
+
+            var response = await client.GetAsync("/web/ConfigurationPages").ConfigureAwait(false);
+
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+
+            var res = await response.Content.ReadAsStreamAsync();
+            _ = await JsonSerializer.DeserializeAsync<ConfigurationPageInfo[]>(res, _jsonOpions);
+            // TODO: check content
+        }
+
+        [Fact]
+        public async Task GetConfigurationPages_True_MainMenuConfigurationPages()
+        {
+            var client = _factory.CreateClient();
+
+            var response = await client.GetAsync("/web/ConfigurationPages?enableInMainMenu=true").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 res = await response.Content.ReadAsStreamAsync();
+            var data = await JsonSerializer.DeserializeAsync<ConfigurationPageInfo[]>(res, _jsonOpions);
+            Assert.Empty(data);
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Integration.Tests/Controllers/DlnaControllerTests.cs b/tests/Jellyfin.Server.Integration.Tests/Controllers/DlnaControllerTests.cs
new file mode 100644
index 000000000..5d7b0e874
--- /dev/null
+++ b/tests/Jellyfin.Server.Integration.Tests/Controllers/DlnaControllerTests.cs
@@ -0,0 +1,134 @@
+using System;
+using System.Linq;
+using System.Net;
+using System.Net.Http.Json;
+using System.Net.Mime;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Jellyfin.Extensions.Json;
+using MediaBrowser.Model.Dlna;
+using Xunit;
+using Xunit.Priority;
+
+namespace Jellyfin.Server.Integration.Tests.Controllers
+{
+    [TestCaseOrderer(PriorityOrderer.Name, PriorityOrderer.Assembly)]
+    public sealed class DlnaControllerTests : IClassFixture<JellyfinApplicationFactory>
+    {
+        private const string NonExistentProfile = "1322f35b8f2c434dad3cc07c9b97dbd1";
+        private readonly JellyfinApplicationFactory _factory;
+        private readonly JsonSerializerOptions _jsonOptions = JsonDefaults.Options;
+        private static string? _accessToken;
+        private static string? _newDeviceProfileId;
+
+        public DlnaControllerTests(JellyfinApplicationFactory factory)
+        {
+            _factory = factory;
+        }
+
+        [Fact]
+        [Priority(0)]
+        public async Task GetProfile_DoesNotExist_NotFound()
+        {
+            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);
+        }
+
+        [Fact]
+        [Priority(0)]
+        public async Task DeleteProfile_DoesNotExist_NotFound()
+        {
+            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);
+        }
+
+        [Fact]
+        [Priority(0)]
+        public async Task UpdateProfile_DoesNotExist_NotFound()
+        {
+            var client = _factory.CreateClient();
+            client.DefaultRequestHeaders.AddAuthHeader(_accessToken ??= await AuthHelper.CompleteStartupAsync(client).ConfigureAwait(false));
+
+            var deviceProfile = new DeviceProfile()
+            {
+                Name = "ThisProfileDoesNotExist"
+            };
+
+            using var getResponse = await client.PostAsJsonAsync("/Dlna/Profiles/" + NonExistentProfile, deviceProfile, _jsonOptions).ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.NotFound, getResponse.StatusCode);
+        }
+
+        [Fact]
+        [Priority(1)]
+        public async Task CreateProfile_Valid_NoContent()
+        {
+            var client = _factory.CreateClient();
+            client.DefaultRequestHeaders.AddAuthHeader(_accessToken ??= await AuthHelper.CompleteStartupAsync(client).ConfigureAwait(false));
+
+            var deviceProfile = new DeviceProfile()
+            {
+                Name = "ThisProfileIsNew"
+            };
+
+            using var getResponse = await client.PostAsJsonAsync("/Dlna/Profiles", deviceProfile, _jsonOptions).ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.NoContent, getResponse.StatusCode);
+        }
+
+        [Fact]
+        [Priority(2)]
+        public async Task GetProfileInfos_Valid_ContainsThisProfileIsNew()
+        {
+            var client = _factory.CreateClient();
+            client.DefaultRequestHeaders.AddAuthHeader(_accessToken ??= await AuthHelper.CompleteStartupAsync(client).ConfigureAwait(false));
+
+            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);
+
+            var newProfile = profiles?.FirstOrDefault(x => string.Equals(x.Name, "ThisProfileIsNew", StringComparison.Ordinal));
+            Assert.NotNull(newProfile);
+            _newDeviceProfileId = newProfile!.Id;
+        }
+
+        [Fact]
+        [Priority(3)]
+        public async Task UpdateProfile_Valid_NoContent()
+        {
+            var client = _factory.CreateClient();
+            client.DefaultRequestHeaders.AddAuthHeader(_accessToken ??= await AuthHelper.CompleteStartupAsync(client).ConfigureAwait(false));
+
+            var updatedProfile = new DeviceProfile()
+            {
+                Name = "ThisProfileIsUpdated",
+                Id = _newDeviceProfileId
+            };
+
+            using var getResponse = await client.PostAsJsonAsync("/Dlna/Profiles", updatedProfile, _jsonOptions).ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.NoContent, getResponse.StatusCode);
+        }
+
+        [Fact]
+        [Priority(4)]
+        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);
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Integration.Tests/Controllers/EncoderController.cs b/tests/Jellyfin.Server.Integration.Tests/Controllers/EncoderController.cs
new file mode 100644
index 000000000..1a720c2f6
--- /dev/null
+++ b/tests/Jellyfin.Server.Integration.Tests/Controllers/EncoderController.cs
@@ -0,0 +1,53 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Jellyfin.Server.Integration.Tests.Controllers
+{
+    /// <summary>
+    /// Controller for testing the encoded url.
+    /// </summary>
+    public class EncoderController : BaseJellyfinTestController
+    {
+        /// <summary>
+        /// Tests the url decoding.
+        /// </summary>
+        /// <param name="params">Parameters to echo back in the response.</param>
+        /// <returns>An <see cref="OkResult"/>.</returns>
+        /// <response code="200">Information retrieved.</response>
+        [HttpGet("UrlDecode")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public ContentResult TestUrlDecoding([FromQuery] Dictionary<string, string>? @params = null)
+        {
+            return new ContentResult()
+            {
+                Content = (@params != null && @params.Count > 0)
+                    ? string.Join("&", @params.Select(x => x.Key + "=" + x.Value))
+                    : string.Empty,
+                ContentType = "text/plain; charset=utf-8",
+                StatusCode = 200
+            };
+        }
+
+        /// <summary>
+        /// Tests the url decoding.
+        /// </summary>
+        /// <param name="params">Parameters to echo back in the response.</param>
+        /// <returns>An <see cref="OkResult"/>.</returns>
+        /// <response code="200">Information retrieved.</response>
+        [HttpGet("UrlArrayDecode")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public ContentResult TestUrlArrayDecoding([FromQuery] Dictionary<string, string[]>? @params = null)
+        {
+            return new ContentResult()
+            {
+                Content = (@params != null && @params.Count > 0)
+                    ? string.Join("&", @params.Select(x => x.Key + "=" + string.Join(',', x.Value)))
+                    : string.Empty,
+                ContentType = "text/plain; charset=utf-8",
+                StatusCode = 200
+            };
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Integration.Tests/Controllers/MediaInfoControllerTests.cs b/tests/Jellyfin.Server.Integration.Tests/Controllers/MediaInfoControllerTests.cs
new file mode 100644
index 000000000..34d26680a
--- /dev/null
+++ b/tests/Jellyfin.Server.Integration.Tests/Controllers/MediaInfoControllerTests.cs
@@ -0,0 +1,61 @@
+using System.Globalization;
+using System.Net;
+using System.Net.Mime;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Jellyfin.Server.Integration.Tests.Controllers
+{
+    public sealed class MediaInfoControllerTests : IClassFixture<JellyfinApplicationFactory>
+    {
+        private readonly JellyfinApplicationFactory _factory;
+        private static string? _accessToken;
+
+        public MediaInfoControllerTests(JellyfinApplicationFactory factory)
+        {
+            _factory = factory;
+        }
+
+        [Fact]
+        public async Task BitrateTest_Default_Ok()
+        {
+            var client = _factory.CreateClient();
+            client.DefaultRequestHeaders.AddAuthHeader(_accessToken ??= await AuthHelper.CompleteStartupAsync(client).ConfigureAwait(false));
+
+            var response = await client.GetAsync("Playback/BitrateTest").ConfigureAwait(false);
+
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            Assert.Equal(MediaTypeNames.Application.Octet, response.Content.Headers.ContentType?.MediaType);
+            Assert.NotNull(response.Content.Headers.ContentLength);
+        }
+
+        [Theory]
+        [InlineData(102400)]
+        public async Task BitrateTest_WithValidParam_Ok(int size)
+        {
+            var client = _factory.CreateClient();
+            client.DefaultRequestHeaders.AddAuthHeader(_accessToken ??= await AuthHelper.CompleteStartupAsync(client).ConfigureAwait(false));
+
+            var response = await client.GetAsync("Playback/BitrateTest?size=" + size.ToString(CultureInfo.InvariantCulture)).ConfigureAwait(false);
+
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            Assert.Equal(MediaTypeNames.Application.Octet, response.Content.Headers.ContentType?.MediaType);
+            Assert.NotNull(response.Content.Headers.ContentLength);
+            Assert.InRange(response.Content.Headers.ContentLength!.Value, size, long.MaxValue);
+        }
+
+        [Theory]
+        [InlineData(0)] // Zero
+        [InlineData(-102400)] // Negative value
+        [InlineData(1000000000)] // Too large
+        public async Task BitrateTest_InvalidValue_BadRequest(int size)
+        {
+            var client = _factory.CreateClient();
+            client.DefaultRequestHeaders.AddAuthHeader(_accessToken ??= await AuthHelper.CompleteStartupAsync(client).ConfigureAwait(false));
+
+            var response = await client.GetAsync("Playback/BitrateTest?size=" + size.ToString(CultureInfo.InvariantCulture)).ConfigureAwait(false);
+
+            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Integration.Tests/Controllers/MediaStructureControllerTests.cs b/tests/Jellyfin.Server.Integration.Tests/Controllers/MediaStructureControllerTests.cs
new file mode 100644
index 000000000..24251013c
--- /dev/null
+++ b/tests/Jellyfin.Server.Integration.Tests/Controllers/MediaStructureControllerTests.cs
@@ -0,0 +1,117 @@
+using System;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Jellyfin.Api.Models.LibraryStructureDto;
+using Jellyfin.Extensions.Json;
+using MediaBrowser.Model.Configuration;
+using Xunit;
+
+namespace Jellyfin.Server.Integration.Tests.Controllers
+{
+    public sealed class MediaStructureControllerTests : IClassFixture<JellyfinApplicationFactory>
+    {
+        private readonly JellyfinApplicationFactory _factory;
+        private readonly JsonSerializerOptions _jsonOptions = JsonDefaults.Options;
+        private static string? _accessToken;
+
+        public MediaStructureControllerTests(JellyfinApplicationFactory factory)
+        {
+            _factory = factory;
+        }
+
+        [Fact]
+        public async Task RenameVirtualFolder_WhiteSpaceName_ReturnsBadRequest()
+        {
+            var client = _factory.CreateClient();
+            client.DefaultRequestHeaders.AddAuthHeader(_accessToken ??= await AuthHelper.CompleteStartupAsync(client).ConfigureAwait(false));
+
+            using var postContent = new ByteArrayContent(Array.Empty<byte>());
+            var response = await client.PostAsync("Library/VirtualFolders/Name?name=+&newName=test", postContent).ConfigureAwait(false);
+
+            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+        }
+
+        [Fact]
+        public async Task RenameVirtualFolder_WhiteSpaceNewName_ReturnsBadRequest()
+        {
+            var client = _factory.CreateClient();
+            client.DefaultRequestHeaders.AddAuthHeader(_accessToken ??= await AuthHelper.CompleteStartupAsync(client).ConfigureAwait(false));
+
+            using var postContent = new ByteArrayContent(Array.Empty<byte>());
+            var response = await client.PostAsync("Library/VirtualFolders/Name?name=test&newName=+", postContent).ConfigureAwait(false);
+
+            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+        }
+
+        [Fact]
+        public async Task RenameVirtualFolder_NameDoesntExist_ReturnsNotFound()
+        {
+            var client = _factory.CreateClient();
+            client.DefaultRequestHeaders.AddAuthHeader(_accessToken ??= await AuthHelper.CompleteStartupAsync(client).ConfigureAwait(false));
+
+            using var postContent = new ByteArrayContent(Array.Empty<byte>());
+            var response = await client.PostAsync("Library/VirtualFolders/Name?name=doesnt+exist&newName=test", postContent).ConfigureAwait(false);
+
+            Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
+        }
+
+        [Fact]
+        public async Task AddMediaPath_PathDoesntExist_ReturnsNotFound()
+        {
+            var client = _factory.CreateClient();
+            client.DefaultRequestHeaders.AddAuthHeader(_accessToken ??= await AuthHelper.CompleteStartupAsync(client).ConfigureAwait(false));
+
+            var data = new MediaPathDto()
+            {
+                Name = "Test",
+                Path = "/this/path/doesnt/exist"
+            };
+
+            var response = await client.PostAsJsonAsync("Library/VirtualFolders/Paths", data, _jsonOptions).ConfigureAwait(false);
+
+            Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
+        }
+
+        [Fact]
+        public async Task UpdateMediaPath_WhiteSpaceName_ReturnsBadRequest()
+        {
+            var client = _factory.CreateClient();
+            client.DefaultRequestHeaders.AddAuthHeader(_accessToken ??= await AuthHelper.CompleteStartupAsync(client).ConfigureAwait(false));
+
+            var data = new UpdateMediaPathRequestDto()
+            {
+                Name = " ",
+                PathInfo = new MediaPathInfo("test")
+            };
+
+            var response = await client.PostAsJsonAsync("Library/VirtualFolders/Paths/Update", data, _jsonOptions).ConfigureAwait(false);
+
+            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+        }
+
+        [Fact]
+        public async Task RemoveMediaPath_WhiteSpaceName_ReturnsBadRequest()
+        {
+            var client = _factory.CreateClient();
+            client.DefaultRequestHeaders.AddAuthHeader(_accessToken ??= await AuthHelper.CompleteStartupAsync(client).ConfigureAwait(false));
+
+            var response = await client.DeleteAsync("Library/VirtualFolders/Paths?name=+").ConfigureAwait(false);
+
+            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+        }
+
+        [Fact]
+        public async Task RemoveMediaPath_PathDoesntExist_ReturnsNotFound()
+        {
+            var client = _factory.CreateClient();
+            client.DefaultRequestHeaders.AddAuthHeader(_accessToken ??= await AuthHelper.CompleteStartupAsync(client).ConfigureAwait(false));
+
+            var response = await client.DeleteAsync("Library/VirtualFolders/Paths?name=none&path=%2Fthis%2Fpath%2Fdoesnt%2Fexist").ConfigureAwait(false);
+
+            Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Integration.Tests/Controllers/StartupControllerTests.cs b/tests/Jellyfin.Server.Integration.Tests/Controllers/StartupControllerTests.cs
new file mode 100644
index 000000000..e72dacfe0
--- /dev/null
+++ b/tests/Jellyfin.Server.Integration.Tests/Controllers/StartupControllerTests.cs
@@ -0,0 +1,115 @@
+using System;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Net.Mime;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Jellyfin.Api.Models.StartupDtos;
+using Jellyfin.Extensions.Json;
+using Xunit;
+using Xunit.Priority;
+
+namespace Jellyfin.Server.Integration.Tests.Controllers
+{
+    [TestCaseOrderer(PriorityOrderer.Name, PriorityOrderer.Assembly)]
+    public sealed class StartupControllerTests : IClassFixture<JellyfinApplicationFactory>
+    {
+        private readonly JellyfinApplicationFactory _factory;
+        private readonly JsonSerializerOptions _jsonOptions = JsonDefaults.Options;
+
+        public StartupControllerTests(JellyfinApplicationFactory factory)
+        {
+            _factory = factory;
+        }
+
+        [Fact]
+        [Priority(-2)]
+        public async Task Configuration_EditConfig_Success()
+        {
+            var client = _factory.CreateClient();
+
+            var config = new StartupConfigurationDto()
+            {
+                UICulture = "NewCulture",
+                MetadataCountryCode = "be",
+                PreferredMetadataLanguage = "nl"
+            };
+
+            using var postResponse = await client.PostAsJsonAsync("/Startup/Configuration", config, _jsonOptions).ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.NoContent, postResponse.StatusCode);
+
+            using var getResponse = await client.GetAsync("/Startup/Configuration").ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.OK, getResponse.StatusCode);
+            Assert.Equal(MediaTypeNames.Application.Json, getResponse.Content.Headers.ContentType?.MediaType);
+
+            using var responseStream = await getResponse.Content.ReadAsStreamAsync().ConfigureAwait(false);
+            var newConfig = await JsonSerializer.DeserializeAsync<StartupConfigurationDto>(responseStream, _jsonOptions).ConfigureAwait(false);
+            Assert.Equal(config.UICulture, newConfig!.UICulture);
+            Assert.Equal(config.MetadataCountryCode, newConfig.MetadataCountryCode);
+            Assert.Equal(config.PreferredMetadataLanguage, newConfig.PreferredMetadataLanguage);
+        }
+
+        [Fact]
+        [Priority(-2)]
+        public async Task User_DefaultUser_NameWithoutPassword()
+        {
+            var client = _factory.CreateClient();
+
+            using var response = await client.GetAsync("/Startup/User").ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            Assert.Equal(MediaTypeNames.Application.Json, response.Content.Headers.ContentType?.MediaType);
+
+            using var contentStream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
+            var user = await JsonSerializer.DeserializeAsync<StartupUserDto>(contentStream, _jsonOptions).ConfigureAwait(false);
+            Assert.NotEmpty(user!.Name);
+            Assert.Null(user.Password);
+        }
+
+        [Fact]
+        [Priority(-1)]
+        public async Task User_EditUser_Success()
+        {
+            var client = _factory.CreateClient();
+
+            var user = new StartupUserDto()
+            {
+                Name = "NewName",
+                Password = "NewPassword"
+            };
+
+            var postResponse = await client.PostAsJsonAsync("/Startup/User", user, _jsonOptions).ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.NoContent, postResponse.StatusCode);
+
+            var getResponse = await client.GetAsync("/Startup/User").ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.OK, getResponse.StatusCode);
+            Assert.Equal(MediaTypeNames.Application.Json, getResponse.Content.Headers.ContentType?.MediaType);
+
+            var contentStream = await getResponse.Content.ReadAsStreamAsync().ConfigureAwait(false);
+            var newUser = await JsonSerializer.DeserializeAsync<StartupUserDto>(contentStream, _jsonOptions).ConfigureAwait(false);
+            Assert.Equal(user.Name, newUser!.Name);
+            Assert.NotEmpty(newUser.Password);
+            Assert.NotEqual(user.Password, newUser.Password);
+        }
+
+        [Fact]
+        [Priority(0)]
+        public async Task CompleteWizard_Success()
+        {
+            var client = _factory.CreateClient();
+
+            var response = await client.PostAsync("/Startup/Complete", new ByteArrayContent(Array.Empty<byte>())).ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
+        }
+
+        [Fact]
+        [Priority(1)]
+        public async Task GetFirstUser_CompleteWizard_Unauthorized()
+        {
+            var client = _factory.CreateClient();
+
+            using var response = await client.GetAsync("/Startup/User").ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Integration.Tests/Controllers/UserControllerTests.cs b/tests/Jellyfin.Server.Integration.Tests/Controllers/UserControllerTests.cs
new file mode 100644
index 000000000..588e25a82
--- /dev/null
+++ b/tests/Jellyfin.Server.Integration.Tests/Controllers/UserControllerTests.cs
@@ -0,0 +1,161 @@
+using System;
+using System.Globalization;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Jellyfin.Api.Models.UserDtos;
+using Jellyfin.Extensions.Json;
+using MediaBrowser.Model.Dto;
+using Xunit;
+using Xunit.Priority;
+
+namespace Jellyfin.Server.Integration.Tests.Controllers
+{
+    [TestCaseOrderer(PriorityOrderer.Name, PriorityOrderer.Assembly)]
+    public sealed class UserControllerTests : IClassFixture<JellyfinApplicationFactory>
+    {
+        private const string TestUsername = "testUser01";
+
+        private readonly JellyfinApplicationFactory _factory;
+        private readonly JsonSerializerOptions _jsonOpions = JsonDefaults.Options;
+        private static string? _accessToken;
+        private static Guid _testUserId = Guid.Empty;
+
+        public UserControllerTests(JellyfinApplicationFactory factory)
+        {
+            _factory = factory;
+        }
+
+        private Task<HttpResponseMessage> CreateUserByName(HttpClient httpClient, CreateUserByName request)
+            => httpClient.PostAsJsonAsync("Users/New", request, _jsonOpions);
+
+        private Task<HttpResponseMessage> UpdateUserPassword(HttpClient httpClient, Guid userId, UpdateUserPassword request)
+            => httpClient.PostAsJsonAsync("Users/" + userId.ToString("N", CultureInfo.InvariantCulture) + "/Password", request, _jsonOpions);
+
+        [Fact]
+        [Priority(-1)]
+        public async Task GetPublicUsers_Valid_Success()
+        {
+            var client = _factory.CreateClient();
+
+            using var response = await client.GetAsync("Users/Public").ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            var users = await JsonSerializer.DeserializeAsync<UserDto[]>(
+                await response.Content.ReadAsStreamAsync().ConfigureAwait(false), _jsonOpions).ConfigureAwait(false);
+            // User are hidden by default
+            Assert.Empty(users);
+        }
+
+        [Fact]
+        [Priority(-1)]
+        public async Task GetUsers_Valid_Success()
+        {
+            var client = _factory.CreateClient();
+            client.DefaultRequestHeaders.AddAuthHeader(_accessToken ??= await AuthHelper.CompleteStartupAsync(client).ConfigureAwait(false));
+
+            using var response = await client.GetAsync("Users").ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            var users = await JsonSerializer.DeserializeAsync<UserDto[]>(
+                await response.Content.ReadAsStreamAsync().ConfigureAwait(false), _jsonOpions).ConfigureAwait(false);
+            Assert.Single(users);
+            Assert.False(users![0].HasConfiguredPassword);
+        }
+
+        [Fact]
+        [Priority(0)]
+        public async Task New_Valid_Success()
+        {
+            var client = _factory.CreateClient();
+
+            // access token can't be null here as the previous test populated it
+            client.DefaultRequestHeaders.AddAuthHeader(_accessToken!);
+
+            var createRequest = new CreateUserByName()
+            {
+                Name = TestUsername
+            };
+
+            using var response = await CreateUserByName(client, createRequest).ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            var user = await JsonSerializer.DeserializeAsync<UserDto>(
+                await response.Content.ReadAsStreamAsync().ConfigureAwait(false), _jsonOpions).ConfigureAwait(false);
+            Assert.Equal(TestUsername, user!.Name);
+            Assert.False(user.HasPassword);
+            Assert.False(user.HasConfiguredPassword);
+
+            _testUserId = user.Id;
+
+            Console.WriteLine(user.Id.ToString("N", CultureInfo.InvariantCulture));
+        }
+
+        [Theory]
+        [InlineData(null)]
+        [InlineData("")]
+        [InlineData("   ")]
+        [InlineData("‼️")]
+        [Priority(0)]
+        public async Task New_Invalid_Fail(string? username)
+        {
+            var client = _factory.CreateClient();
+
+            // access token can't be null here as the previous test populated it
+            client.DefaultRequestHeaders.AddAuthHeader(_accessToken!);
+
+            var createRequest = new CreateUserByName()
+            {
+                Name = username
+            };
+
+            using var response = await CreateUserByName(client, createRequest).ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+        }
+
+        [Fact]
+        [Priority(1)]
+        public async Task UpdateUserPassword_Valid_Success()
+        {
+            var client = _factory.CreateClient();
+            client.DefaultRequestHeaders.AddAuthHeader(_accessToken!);
+
+            var createRequest = new UpdateUserPassword()
+            {
+                NewPw = "4randomPa$$word"
+            };
+
+            using var response = await UpdateUserPassword(client, _testUserId, createRequest).ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
+
+            var users = await JsonSerializer.DeserializeAsync<UserDto[]>(
+                await client.GetStreamAsync("Users").ConfigureAwait(false), _jsonOpions).ConfigureAwait(false);
+            var user = users!.First(x => x.Id == _testUserId);
+            Assert.True(user.HasPassword);
+            Assert.True(user.HasConfiguredPassword);
+        }
+
+        [Fact]
+        [Priority(2)]
+        public async Task UpdateUserPassword_Empty_RemoveSetPassword()
+        {
+            var client = _factory.CreateClient();
+
+            client.DefaultRequestHeaders.AddAuthHeader(_accessToken!);
+
+            var createRequest = new UpdateUserPassword()
+            {
+                CurrentPw = "4randomPa$$word",
+            };
+
+            using var response = await UpdateUserPassword(client, _testUserId, createRequest).ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
+
+            var users = await JsonSerializer.DeserializeAsync<UserDto[]>(
+                await client.GetStreamAsync("Users").ConfigureAwait(false), _jsonOpions).ConfigureAwait(false);
+            var user = users!.First(x => x.Id == _testUserId);
+            Assert.False(user.HasPassword);
+            Assert.False(user.HasConfiguredPassword);
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Integration.Tests/EncodedQueryStringTest.cs b/tests/Jellyfin.Server.Integration.Tests/EncodedQueryStringTest.cs
new file mode 100644
index 000000000..2361e4aa4
--- /dev/null
+++ b/tests/Jellyfin.Server.Integration.Tests/EncodedQueryStringTest.cs
@@ -0,0 +1,49 @@
+using System.Net;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Jellyfin.Server.Integration.Tests
+{
+    /// <summary>
+    /// Defines the test for encoded querystrings in the url.
+    /// </summary>
+    public class EncodedQueryStringTest : IClassFixture<JellyfinApplicationFactory>
+    {
+        private readonly JellyfinApplicationFactory _factory;
+
+        public EncodedQueryStringTest(JellyfinApplicationFactory factory)
+        {
+            _factory = factory;
+        }
+
+        [Theory]
+        [InlineData("a=1&b=2&c=3", "a=1&b=2&c=3")] // won't be processed as there is more than 1.
+        [InlineData("a=1", "a=1")] // won't be processed as it has a value
+        [InlineData("a%3D1%26b%3D2%26c%3D3", "a=1&b=2&c=3")] // will be processed.
+        [InlineData("a=b&a=c", "a=b")]
+        [InlineData("a%3D1", "a=1")]
+        [InlineData("a%3Db%26a%3Dc", "a=b")]
+        public async Task Ensure_Decoding_Of_Urls_Is_Working(string sourceUrl, string unencodedUrl)
+        {
+            var client = _factory.CreateClient();
+
+            var response = await client.GetAsync("Encoder/UrlDecode?" + sourceUrl).ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            string reply = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
+            Assert.Equal(unencodedUrl, reply);
+        }
+
+        [Theory]
+        [InlineData("a=b&a=c", "a=b,c")]
+        [InlineData("a%3Db%26a%3Dc", "a=b,c")]
+        public async Task Ensure_Array_Decoding_Of_Urls_Is_Working(string sourceUrl, string unencodedUrl)
+        {
+            var client = _factory.CreateClient();
+
+            var response = await client.GetAsync("Encoder/UrlArrayDecode?" + sourceUrl).ConfigureAwait(false);
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            string reply = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
+            Assert.Equal(unencodedUrl, reply);
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Integration.Tests/Jellyfin.Server.Integration.Tests.csproj b/tests/Jellyfin.Server.Integration.Tests/Jellyfin.Server.Integration.Tests.csproj
new file mode 100644
index 000000000..a59900b02
--- /dev/null
+++ b/tests/Jellyfin.Server.Integration.Tests/Jellyfin.Server.Integration.Tests.csproj
@@ -0,0 +1,44 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <IsPackable>false</IsPackable>
+    <CodeAnalysisRuleSet>../jellyfin-tests.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="AutoFixture" Version="4.17.0" />
+    <PackageReference Include="AutoFixture.AutoMoq" Version="4.17.0" />
+    <PackageReference Include="AutoFixture.Xunit2" Version="4.17.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="6.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Options" Version="6.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
+    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" />
+    <PackageReference Include="Xunit.Priority" Version="1.1.6" />
+    <PackageReference Include="coverlet.collector" Version="3.1.0" />
+    <PackageReference Include="Moq" Version="4.16.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <!-- Don't run tests in parallel -->
+    <None Update="xunit.runner.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
+  <!-- Code Analyzers -->
+  <ItemGroup Condition=" '$(Configuration)' == 'Debug' ">
+    <PackageReference Include="SerilogAnalyzer" Version="0.15.0" PrivateAssets="All" />
+    <PackageReference Include="StyleCop.Analyzers" Version="1.1.118" PrivateAssets="All" />
+    <PackageReference Include="SmartAnalyzers.MultithreadingAnalyzer" Version="1.1.31" PrivateAssets="All" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../../Jellyfin.Server/Jellyfin.Server.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <EmbeddedResource Include="TestPage.html" />
+  </ItemGroup>
+
+</Project>
diff --git a/tests/Jellyfin.Api.Tests/JellyfinApplicationFactory.cs b/tests/Jellyfin.Server.Integration.Tests/JellyfinApplicationFactory.cs
index 54f8eb225..3d34a18e7 100644
--- a/tests/Jellyfin.Api.Tests/JellyfinApplicationFactory.cs
+++ b/tests/Jellyfin.Server.Integration.Tests/JellyfinApplicationFactory.cs
@@ -1,19 +1,19 @@
 using System;
 using System.Collections.Concurrent;
 using System.IO;
+using System.Threading;
 using Emby.Server.Implementations;
-using Emby.Server.Implementations.IO;
-using Jellyfin.Server;
 using MediaBrowser.Common;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Mvc.Testing;
 using Microsoft.AspNetCore.TestHost;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Serilog;
 using Serilog.Extensions.Logging;
 
-namespace Jellyfin.Api.Tests
+namespace Jellyfin.Server.Integration.Tests
 {
     /// <summary>
     /// Factory for bootstrapping the Jellyfin application in memory for functional end to end tests.
@@ -21,12 +21,12 @@ namespace Jellyfin.Api.Tests
     public class JellyfinApplicationFactory : WebApplicationFactory<Startup>
     {
         private static readonly string _testPathRoot = Path.Combine(Path.GetTempPath(), "jellyfin-test-data");
-        private static readonly ConcurrentBag<IDisposable> _disposableComponents = new ConcurrentBag<IDisposable>();
+        private readonly ConcurrentBag<IDisposable> _disposableComponents = new ConcurrentBag<IDisposable>();
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="JellyfinApplicationFactory"/> class.
+        /// Initializes static members of the <see cref="JellyfinApplicationFactory"/> class.
         /// </summary>
-        public JellyfinApplicationFactory()
+        static JellyfinApplicationFactory()
         {
             // Perform static initialization that only needs to happen once per test-run
             Log.Logger = new LoggerConfiguration().WriteTo.Console().CreateLogger();
@@ -43,10 +43,7 @@ namespace Jellyfin.Api.Tests
         protected override void ConfigureWebHost(IWebHostBuilder builder)
         {
             // Specify the startup command line options
-            var commandLineOpts = new StartupOptions
-            {
-                NoWebClient = true
-            };
+            var commandLineOpts = new StartupOptions();
 
             // Use a temporary directory for the application paths
             var webHostPathRoot = Path.Combine(_testPathRoot, "test-host-" + Path.GetFileNameWithoutExtension(Path.GetRandomFileName()));
@@ -69,18 +66,18 @@ namespace Jellyfin.Api.Tests
             var startupConfig = Program.CreateAppConfiguration(commandLineOpts, appPaths);
 
             ILoggerFactory loggerFactory = new SerilogLoggerFactory();
-            var serviceCollection = new ServiceCollection();
+
             _disposableComponents.Add(loggerFactory);
 
             // Create the app host and initialize it
-            var appHost = new CoreAppHost(
+            var appHost = new TestAppHost(
                 appPaths,
                 loggerFactory,
                 commandLineOpts,
-                new ManagedFileSystem(loggerFactory.CreateLogger<ManagedFileSystem>(), appPaths),
-                serviceCollection);
+                new ConfigurationBuilder().Build());
             _disposableComponents.Add(appHost);
-            appHost.Init();
+            var serviceCollection = new ServiceCollection();
+            appHost.Init(serviceCollection);
 
             // Configure the web host builder
             Program.ConfigureWebHostBuilder(builder, appHost, serviceCollection, commandLineOpts, startupConfig, appPaths);
@@ -93,10 +90,10 @@ namespace Jellyfin.Api.Tests
             var testServer = base.CreateServer(builder);
 
             // Finish initializing the app host
-            var appHost = (CoreAppHost)testServer.Services.GetRequiredService<IApplicationHost>();
+            var appHost = (TestAppHost)testServer.Services.GetRequiredService<IApplicationHost>();
             appHost.ServiceProvider = testServer.Services;
             appHost.InitializeServices().GetAwaiter().GetResult();
-            appHost.RunStartupTasksAsync().GetAwaiter().GetResult();
+            appHost.RunStartupTasksAsync(CancellationToken.None).GetAwaiter().GetResult();
 
             return testServer;
         }
diff --git a/tests/Jellyfin.Server.Integration.Tests/Middleware/RobotsRedirectionMiddlewareTests.cs b/tests/Jellyfin.Server.Integration.Tests/Middleware/RobotsRedirectionMiddlewareTests.cs
new file mode 100644
index 000000000..8c49a2e2b
--- /dev/null
+++ b/tests/Jellyfin.Server.Integration.Tests/Middleware/RobotsRedirectionMiddlewareTests.cs
@@ -0,0 +1,32 @@
+using System.Net;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Xunit;
+
+namespace Jellyfin.Server.Integration.Tests.Middleware
+{
+    public sealed class RobotsRedirectionMiddlewareTests : IClassFixture<JellyfinApplicationFactory>
+    {
+        private readonly JellyfinApplicationFactory _factory;
+
+        public RobotsRedirectionMiddlewareTests(JellyfinApplicationFactory factory)
+        {
+            _factory = factory;
+        }
+
+        [Fact]
+        public async Task RobotsDotTxtRedirects()
+        {
+            var client = _factory.CreateClient(
+                new WebApplicationFactoryClientOptions()
+                {
+                    AllowAutoRedirect = false
+                });
+
+            var response = await client.GetAsync("robots.txt").ConfigureAwait(false);
+
+            Assert.Equal(HttpStatusCode.Redirect, response.StatusCode);
+            Assert.Equal("web/robots.txt", response.Headers.Location?.ToString());
+        }
+    }
+}
diff --git a/tests/Jellyfin.Api.Tests/OpenApiSpecTests.cs b/tests/Jellyfin.Server.Integration.Tests/OpenApiSpecTests.cs
index 03ab56d1f..0ade345a1 100644
--- a/tests/Jellyfin.Api.Tests/OpenApiSpecTests.cs
+++ b/tests/Jellyfin.Server.Integration.Tests/OpenApiSpecTests.cs
@@ -1,12 +1,10 @@
 using System.IO;
 using System.Reflection;
-using System.Text.Json;
 using System.Threading.Tasks;
-using MediaBrowser.Model.Branding;
 using Xunit;
 using Xunit.Abstractions;
 
-namespace Jellyfin.Api.Tests
+namespace Jellyfin.Server.Integration.Tests
 {
     public sealed class OpenApiSpecTests : IClassFixture<JellyfinApplicationFactory>
     {
diff --git a/tests/Jellyfin.Server.Integration.Tests/TestAppHost.cs b/tests/Jellyfin.Server.Integration.Tests/TestAppHost.cs
new file mode 100644
index 000000000..bf74efa09
--- /dev/null
+++ b/tests/Jellyfin.Server.Integration.Tests/TestAppHost.cs
@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+using System.Reflection;
+using Emby.Server.Implementations;
+using MediaBrowser.Controller;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Server.Integration.Tests
+{
+    /// <summary>
+    /// Implementation of the abstract <see cref="ApplicationHost" /> class.
+    /// </summary>
+    public class TestAppHost : CoreAppHost
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TestAppHost" /> class.
+        /// </summary>
+        /// <param name="applicationPaths">The <see cref="ServerApplicationPaths" /> to be used by the <see cref="CoreAppHost" />.</param>
+        /// <param name="loggerFactory">The <see cref="ILoggerFactory" /> to be used by the <see cref="CoreAppHost" />.</param>
+        /// <param name="options">The <see cref="StartupOptions" /> to be used by the <see cref="CoreAppHost" />.</param>
+        /// <param name="startup">The <see cref="IConfiguration" /> to be used by the <see cref="CoreAppHost" />.</param>
+        public TestAppHost(
+            IServerApplicationPaths applicationPaths,
+            ILoggerFactory loggerFactory,
+            IStartupOptions options,
+            IConfiguration startup)
+            : base(
+                applicationPaths,
+                loggerFactory,
+                options,
+                startup)
+        {
+        }
+
+        /// <inheritdoc />
+        protected override IEnumerable<Assembly> GetAssembliesWithPartsInternal()
+        {
+            foreach (var a in base.GetAssembliesWithPartsInternal())
+            {
+                yield return a;
+            }
+
+            yield return typeof(TestPlugin).Assembly;
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Integration.Tests/TestPage.html b/tests/Jellyfin.Server.Integration.Tests/TestPage.html
new file mode 100644
index 000000000..8037af8a6
--- /dev/null
+++ b/tests/Jellyfin.Server.Integration.Tests/TestPage.html
@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>TestPlugin</title>
+</head>
+<body>
+    <h1>This is a Test Page.</h1>
+</body>
+</html>
diff --git a/tests/Jellyfin.Server.Integration.Tests/TestPlugin.cs b/tests/Jellyfin.Server.Integration.Tests/TestPlugin.cs
new file mode 100644
index 000000000..1d67ac487
--- /dev/null
+++ b/tests/Jellyfin.Server.Integration.Tests/TestPlugin.cs
@@ -0,0 +1,43 @@
+#pragma warning disable CS1591
+
+using System;
+using System.Collections.Generic;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Common.Plugins;
+using MediaBrowser.Model.Plugins;
+using MediaBrowser.Model.Serialization;
+
+namespace Jellyfin.Server.Integration.Tests
+{
+    public class TestPlugin : BasePlugin<BasePluginConfiguration>, IHasWebPages
+    {
+        public TestPlugin(IApplicationPaths applicationPaths, IXmlSerializer xmlSerializer)
+            : base(applicationPaths, xmlSerializer)
+        {
+            Instance = this;
+        }
+
+        public static TestPlugin? Instance { get; private set; }
+
+        public override Guid Id => new Guid("2d350a13-0bf7-4b61-859c-d5e601b5facf");
+
+        public override string Name => nameof(TestPlugin);
+
+        public override string Description => "Server test Plugin.";
+
+        public IEnumerable<PluginPageInfo> GetPages()
+        {
+            yield return new PluginPageInfo
+            {
+                Name = Name,
+                EmbeddedResourcePath = GetType().Namespace + ".TestPage.html"
+            };
+
+            yield return new PluginPageInfo
+            {
+                Name = "BrokenPage",
+                EmbeddedResourcePath = GetType().Namespace + ".foobar"
+            };
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Integration.Tests/TestPluginWithoutPages.cs b/tests/Jellyfin.Server.Integration.Tests/TestPluginWithoutPages.cs
new file mode 100644
index 000000000..ac10c4784
--- /dev/null
+++ b/tests/Jellyfin.Server.Integration.Tests/TestPluginWithoutPages.cs
@@ -0,0 +1,27 @@
+#pragma warning disable CS1591
+
+using System;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Common.Plugins;
+using MediaBrowser.Model.Plugins;
+using MediaBrowser.Model.Serialization;
+
+namespace Jellyfin.Server.Integration.Tests
+{
+    public class TestPluginWithoutPages : BasePlugin<BasePluginConfiguration>
+    {
+        public TestPluginWithoutPages(IApplicationPaths applicationPaths, IXmlSerializer xmlSerializer)
+            : base(applicationPaths, xmlSerializer)
+        {
+            Instance = this;
+        }
+
+        public static TestPluginWithoutPages? Instance { get; private set; }
+
+        public override Guid Id => new Guid("ae95cbe6-bd3d-4d73-8596-490db334611e");
+
+        public override string Name => nameof(TestPluginWithoutPages);
+
+        public override string Description => "Server test Plugin without web pages.";
+    }
+}
diff --git a/tests/Jellyfin.Server.Integration.Tests/WebSocketTests.cs b/tests/Jellyfin.Server.Integration.Tests/WebSocketTests.cs
new file mode 100644
index 000000000..ffdc04eba
--- /dev/null
+++ b/tests/Jellyfin.Server.Integration.Tests/WebSocketTests.cs
@@ -0,0 +1,32 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Jellyfin.Server.Integration.Tests
+{
+    public sealed class WebSocketTests : IClassFixture<JellyfinApplicationFactory>
+    {
+        private readonly JellyfinApplicationFactory _factory;
+
+        public WebSocketTests(JellyfinApplicationFactory factory)
+        {
+            _factory = factory;
+        }
+
+        [Fact]
+        public async Task WebSocket_Unauthenticated_ThrowsInvalidOperationException()
+        {
+            var server = _factory.Server;
+            var client = server.CreateWebSocketClient();
+
+            await Assert.ThrowsAsync<InvalidOperationException>(
+                () => client.ConnectAsync(
+                    new UriBuilder(server.BaseAddress)
+                    {
+                        Scheme = "ws",
+                        Path = "websocket"
+                    }.Uri, CancellationToken.None));
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Integration.Tests/xunit.runner.json b/tests/Jellyfin.Server.Integration.Tests/xunit.runner.json
new file mode 100644
index 000000000..809e880c7
--- /dev/null
+++ b/tests/Jellyfin.Server.Integration.Tests/xunit.runner.json
@@ -0,0 +1,4 @@
+{
+    "parallelizeAssembly": false,
+    "parallelizeTestCollections": false
+}
diff --git a/tests/Jellyfin.Server.Tests/Jellyfin.Server.Tests.csproj b/tests/Jellyfin.Server.Tests/Jellyfin.Server.Tests.csproj
new file mode 100644
index 000000000..ada9034df
--- /dev/null
+++ b/tests/Jellyfin.Server.Tests/Jellyfin.Server.Tests.csproj
@@ -0,0 +1,33 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <IsPackable>false</IsPackable>
+    <CodeAnalysisRuleSet>../jellyfin-tests.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="AutoFixture" Version="4.17.0" />
+    <PackageReference Include="AutoFixture.AutoMoq" Version="4.17.0" />
+    <PackageReference Include="AutoFixture.Xunit2" Version="4.17.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="6.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Options" Version="6.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
+    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" />
+    <PackageReference Include="coverlet.collector" Version="3.1.0" />
+    <PackageReference Include="Moq" Version="4.16.1" />
+  </ItemGroup>
+
+  <!-- Code Analyzers -->
+  <ItemGroup Condition=" '$(Configuration)' == 'Debug' ">
+    <PackageReference Include="SerilogAnalyzer" Version="0.15.0" PrivateAssets="All" />
+    <PackageReference Include="StyleCop.Analyzers" Version="1.1.118" PrivateAssets="All" />
+    <PackageReference Include="SmartAnalyzers.MultithreadingAnalyzer" Version="1.1.31" PrivateAssets="All" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../../Jellyfin.Server/Jellyfin.Server.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/tests/Jellyfin.Server.Tests/ParseNetworkTests.cs b/tests/Jellyfin.Server.Tests/ParseNetworkTests.cs
new file mode 100644
index 000000000..a1bdfa31b
--- /dev/null
+++ b/tests/Jellyfin.Server.Tests/ParseNetworkTests.cs
@@ -0,0 +1,126 @@
+using System;
+using System.Linq;
+using System.Net;
+using Jellyfin.Networking.Configuration;
+using Jellyfin.Networking.Manager;
+using Jellyfin.Server.Extensions;
+using MediaBrowser.Common.Configuration;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.HttpOverrides;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.Server.Tests
+{
+    public class ParseNetworkTests
+    {
+        public static TheoryData<bool, bool, string[], IPAddress[], IPNetwork[]> TestNetworks_TestData()
+        {
+            var data = new TheoryData<bool, bool, string[], IPAddress[], IPNetwork[]>();
+            data.Add(
+                true,
+                true,
+                new string[] { "192.168.t", "127.0.0.1", "1234.1232.12.1234" },
+                new IPAddress[] { IPAddress.Loopback.MapToIPv6() },
+                Array.Empty<IPNetwork>());
+
+            data.Add(
+                true,
+                false,
+                new string[] { "192.168.x", "127.0.0.1", "1234.1232.12.1234" },
+                new IPAddress[] { IPAddress.Loopback },
+                Array.Empty<IPNetwork>());
+
+            data.Add(
+                true,
+                true,
+                new string[] { "::1" },
+                Array.Empty<IPAddress>(),
+                new IPNetwork[] { new IPNetwork(IPAddress.IPv6Loopback, 128) });
+
+            data.Add(
+                false,
+                false,
+                new string[] { "localhost" },
+                Array.Empty<IPAddress>(),
+                Array.Empty<IPNetwork>());
+
+            data.Add(
+                true,
+                false,
+                new string[] { "localhost" },
+                new IPAddress[] { IPAddress.Loopback },
+                Array.Empty<IPNetwork>());
+
+            data.Add(
+                false,
+                true,
+                new string[] { "localhost" },
+                Array.Empty<IPAddress>(),
+                new IPNetwork[] { new IPNetwork(IPAddress.IPv6Loopback, 128) });
+
+            data.Add(
+                true,
+                true,
+                new string[] { "localhost" },
+                new IPAddress[] { IPAddress.Loopback.MapToIPv6() },
+                new IPNetwork[] { new IPNetwork(IPAddress.IPv6Loopback, 128) });
+            return data;
+        }
+
+        [Theory]
+        [MemberData(nameof(TestNetworks_TestData))]
+        public void TestNetworks(bool ip4, bool ip6, string[] hostList, IPAddress[] knownProxies, IPNetwork[] knownNetworks)
+        {
+            using var nm = CreateNetworkManager();
+
+            var settings = new NetworkConfiguration
+            {
+                EnableIPV4 = ip4,
+                EnableIPV6 = ip6
+            };
+
+            ForwardedHeadersOptions options = new ForwardedHeadersOptions();
+
+            // Need this here as ::1 and 127.0.0.1 are in them by default.
+            options.KnownProxies.Clear();
+            options.KnownNetworks.Clear();
+
+            ApiServiceCollectionExtensions.AddProxyAddresses(settings, hostList, options);
+
+            Assert.Equal(knownProxies.Length, options.KnownProxies.Count);
+            foreach (var item in knownProxies)
+            {
+                Assert.True(options.KnownProxies.Contains(item));
+            }
+
+            Assert.Equal(knownNetworks.Length, options.KnownNetworks.Count);
+            foreach (var item in knownNetworks)
+            {
+                Assert.NotNull(options.KnownNetworks.FirstOrDefault(x => x.Prefix.Equals(item.Prefix) && x.PrefixLength == item.PrefixLength));
+            }
+        }
+
+        private static IConfigurationManager GetMockConfig(NetworkConfiguration conf)
+        {
+            var configManager = new Mock<IConfigurationManager>
+            {
+                CallBase = true
+            };
+            configManager.Setup(x => x.GetConfiguration(It.IsAny<string>())).Returns(conf);
+            return configManager.Object;
+        }
+
+        private static NetworkManager CreateNetworkManager()
+        {
+            var conf = new NetworkConfiguration()
+            {
+                EnableIPV6 = true,
+                EnableIPV4 = true,
+            };
+
+            return new NetworkManager(GetMockConfig(conf), new NullLogger<NetworkManager>());
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Tests/UrlDecodeQueryFeatureTests.cs b/tests/Jellyfin.Server.Tests/UrlDecodeQueryFeatureTests.cs
new file mode 100644
index 000000000..d15c9d6f5
--- /dev/null
+++ b/tests/Jellyfin.Server.Tests/UrlDecodeQueryFeatureTests.cs
@@ -0,0 +1,28 @@
+using System.Collections.Generic;
+using System.Linq;
+using Jellyfin.Server.Middleware;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.Features;
+using Microsoft.Extensions.Primitives;
+using Xunit;
+
+namespace Jellyfin.Server.Tests
+{
+    public static class UrlDecodeQueryFeatureTests
+    {
+        [Theory]
+        [InlineData("e0a72cb2a2c7", "e0a72cb2a2c7")] // isn't encoded
+        public static void EmptyValueTest(string query, string key)
+        {
+            var dict = new Dictionary<string, StringValues>
+            {
+                { query, StringValues.Empty }
+            };
+            var test = new UrlDecodeQueryFeature(new QueryFeature(new QueryCollection(dict)));
+            Assert.Single(test.Query);
+            var (k, v) = test.Query.First();
+            Assert.Equal(key, k);
+            Assert.Empty(v);
+        }
+    }
+}
diff --git a/tests/Jellyfin.XbmcMetadata.Tests/Jellyfin.XbmcMetadata.Tests.csproj b/tests/Jellyfin.XbmcMetadata.Tests/Jellyfin.XbmcMetadata.Tests.csproj
index f02ac03f7..edf9e0fef 100644
--- a/tests/Jellyfin.XbmcMetadata.Tests/Jellyfin.XbmcMetadata.Tests.csproj
+++ b/tests/Jellyfin.XbmcMetadata.Tests/Jellyfin.XbmcMetadata.Tests.csproj
@@ -1,10 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
     <IsPackable>false</IsPackable>
-    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-    <Nullable>enable</Nullable>
+    <CodeAnalysisRuleSet>../jellyfin-tests.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
 
   <ItemGroup>
@@ -14,16 +13,15 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3" />
-    <PackageReference Include="Moq" Version="4.15.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
+    <PackageReference Include="Moq" Version="4.16.1" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" />
-    <PackageReference Include="coverlet.collector" Version="3.0.0" />
+    <PackageReference Include="coverlet.collector" Version="3.1.0" />
   </ItemGroup>
 
   <!-- Code Analyzers -->
   <ItemGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="2.9.8" PrivateAssets="All" />
     <PackageReference Include="SerilogAnalyzer" Version="0.15.0" PrivateAssets="All" />
     <PackageReference Include="StyleCop.Analyzers" Version="1.1.118" PrivateAssets="All" />
     <PackageReference Include="SmartAnalyzers.MultithreadingAnalyzer" Version="1.1.31" PrivateAssets="All" />
@@ -31,10 +29,7 @@
 
   <ItemGroup>
     <ProjectReference Include="../../MediaBrowser.XbmcMetadata/MediaBrowser.XbmcMetadata.csproj" />
+    <ProjectReference Include="../../MediaBrowser.Providers/MediaBrowser.Providers.csproj" />
   </ItemGroup>
 
-  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <CodeAnalysisRuleSet>../jellyfin-tests.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-
 </Project>
diff --git a/tests/Jellyfin.XbmcMetadata.Tests/Location/MovieNfoLocationTests.cs b/tests/Jellyfin.XbmcMetadata.Tests/Location/MovieNfoLocationTests.cs
new file mode 100644
index 000000000..8019e0ab3
--- /dev/null
+++ b/tests/Jellyfin.XbmcMetadata.Tests/Location/MovieNfoLocationTests.cs
@@ -0,0 +1,65 @@
+using System;
+using System.Linq;
+using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.XbmcMetadata.Savers;
+using Xunit;
+
+namespace Jellyfin.XbmcMetadata.Tests.Location
+{
+    public class MovieNfoLocationTests
+    {
+        [Fact]
+        public static void Movie_MixedFolder_Success()
+        {
+            var movie = new Movie() { Path = "/media/movies/Avengers Endgame.mp4", IsInMixedFolder = true };
+
+            var paths = MovieNfoSaver.GetMovieSavePaths(new ItemInfo(movie)).ToArray();
+            Assert.Single(paths);
+            Assert.Contains("/media/movies/Avengers Endgame.nfo", paths);
+        }
+
+        [Fact]
+        public static void Movie_SeparateFolder_Success()
+        {
+            var movie = new Movie() { Path = "/media/movies/Avengers Endgame/Avengers Endgame.mp4" };
+            var path1 = "/media/movies/Avengers Endgame/Avengers Endgame.nfo";
+            var path2 = "/media/movies/Avengers Endgame/movie.nfo";
+
+            // uses ContainingFolderPath which uses Operating system specific paths
+            if (OperatingSystem.IsWindows())
+            {
+                movie.Path = movie.Path.Replace('/', '\\');
+                path1 = path1.Replace('/', '\\');
+                path2 = path2.Replace('/', '\\');
+            }
+
+            var paths = MovieNfoSaver.GetMovieSavePaths(new ItemInfo(movie)).ToArray();
+            Assert.Equal(2, paths.Length);
+            Assert.Contains(path1, paths);
+            Assert.Contains(path2, paths);
+        }
+
+        [Fact]
+        public void Movie_DVD_Success()
+        {
+            var movie = new Movie() { Path = "/media/movies/Avengers Endgame", VideoType = VideoType.Dvd };
+            var path1 = "/media/movies/Avengers Endgame/Avengers Endgame.nfo";
+            var path2 = "/media/movies/Avengers Endgame/VIDEO_TS/VIDEO_TS.nfo";
+
+            // uses ContainingFolderPath which uses Operating system specific paths
+            if (OperatingSystem.IsWindows())
+            {
+                movie.Path = movie.Path.Replace('/', '\\');
+                path1 = path1.Replace('/', '\\');
+                path2 = path2.Replace('/', '\\');
+            }
+
+            var paths = MovieNfoSaver.GetMovieSavePaths(new ItemInfo(movie)).ToArray();
+            Assert.Equal(2, paths.Length);
+            Assert.Contains(path1, paths);
+            Assert.Contains(path2, paths);
+        }
+    }
+}
diff --git a/tests/Jellyfin.XbmcMetadata.Tests/Parsers/EpisodeNfoProviderTests.cs b/tests/Jellyfin.XbmcMetadata.Tests/Parsers/EpisodeNfoProviderTests.cs
new file mode 100644
index 000000000..3e726f23d
--- /dev/null
+++ b/tests/Jellyfin.XbmcMetadata.Tests/Parsers/EpisodeNfoProviderTests.cs
@@ -0,0 +1,144 @@
+using System;
+using System.Linq;
+using System.Threading;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Configuration;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Providers;
+using MediaBrowser.Providers.Movies;
+using MediaBrowser.XbmcMetadata.Parsers;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.XbmcMetadata.Tests.Parsers
+{
+    public class EpisodeNfoProviderTests
+    {
+        private readonly EpisodeNfoParser _parser;
+
+        public EpisodeNfoProviderTests()
+        {
+            var providerManager = new Mock<IProviderManager>();
+
+            var imdbExternalId = new ImdbExternalId();
+            var externalIdInfo = new ExternalIdInfo(imdbExternalId.ProviderName, imdbExternalId.Key, imdbExternalId.Type, imdbExternalId.UrlFormatString);
+
+            providerManager.Setup(x => x.GetExternalIdInfos(It.IsAny<IHasProviderIds>()))
+                .Returns(new[] { externalIdInfo });
+
+            var config = new Mock<IConfigurationManager>();
+            config.Setup(x => x.GetConfiguration(It.IsAny<string>()))
+                .Returns(new XbmcMetadataOptions());
+            var user = new Mock<IUserManager>();
+            var userData = new Mock<IUserDataManager>();
+            var directoryService = new Mock<IDirectoryService>();
+
+            _parser = new EpisodeNfoParser(
+                new NullLogger<EpisodeNfoParser>(),
+                config.Object,
+                providerManager.Object,
+                user.Object,
+                userData.Object,
+                directoryService.Object);
+        }
+
+        [Fact]
+        public void Fetch_Valid_Success()
+        {
+            var result = new MetadataResult<Episode>()
+            {
+                Item = new Episode()
+            };
+
+            _parser.Fetch(result, "Test Data/The Bone Orchard.nfo", CancellationToken.None);
+
+            var item = result.Item;
+            Assert.Equal("The Bone Orchard", item.Name);
+            Assert.Equal("American Gods", item.SeriesName);
+            Assert.Equal(1, item.IndexNumber);
+            Assert.Equal(1, item.ParentIndexNumber);
+            Assert.Equal("When Shadow Moon is released from prison early after the death of his wife, he meets Mr. Wednesday and is recruited as his bodyguard. Shadow discovers that this may be more than he bargained for.", item.Overview);
+            Assert.Equal(0, item.RunTimeTicks);
+            Assert.Equal("16", item.OfficialRating);
+            Assert.Contains("Drama", item.Genres);
+            Assert.Contains("Mystery", item.Genres);
+            Assert.Contains("Sci-Fi & Fantasy", item.Genres);
+            Assert.Equal(new DateTime(2017, 4, 30), item.PremiereDate);
+            Assert.Equal(2017, item.ProductionYear);
+            Assert.Single(item.Studios);
+            Assert.Contains("Starz", item.Studios);
+            Assert.Equal(1, item.IndexNumberEnd);
+            Assert.Equal(2, item.AirsAfterSeasonNumber);
+            Assert.Equal(3, item.AirsBeforeSeasonNumber);
+            Assert.Equal(1, item.AirsBeforeEpisodeNumber);
+            Assert.Equal("tt5017734", item.ProviderIds[MetadataProvider.Imdb.ToString()]);
+            Assert.Equal("1276153", item.ProviderIds[MetadataProvider.Tmdb.ToString()]);
+
+            // Credits
+            var writers = result.People.Where(x => x.Type == PersonType.Writer).ToArray();
+            Assert.Equal(2, writers.Length);
+            Assert.Contains("Bryan Fuller", writers.Select(x => x.Name));
+            Assert.Contains("Michael Green", writers.Select(x => x.Name));
+
+            // Direcotrs
+            var directors = result.People.Where(x => x.Type == PersonType.Director).ToArray();
+            Assert.Single(directors);
+            Assert.Contains("David Slade", directors.Select(x => x.Name));
+
+            // Actors
+            var actors = result.People.Where(x => x.Type == PersonType.Actor).ToArray();
+            Assert.Equal(11, actors.Length);
+            // Only test one actor
+            var shadow = actors.FirstOrDefault(x => x.Role.Equals("Shadow Moon", StringComparison.Ordinal));
+            Assert.NotNull(shadow);
+            Assert.Equal("Ricky Whittle", shadow!.Name);
+            Assert.Equal(0, shadow!.SortOrder);
+            Assert.Equal("http://image.tmdb.org/t/p/original/cjeDbVfBp6Qvb3C74Dfy7BKDTQN.jpg", shadow!.ImageUrl);
+
+            Assert.Equal(new DateTime(2017, 10, 7, 14, 25, 47), item.DateCreated);
+        }
+
+        [Fact]
+        public void Fetch_Valid_MultiEpisode_Success()
+        {
+            var result = new MetadataResult<Episode>()
+            {
+                Item = new Episode()
+            };
+
+            _parser.Fetch(result, "Test Data/Rising.nfo", CancellationToken.None);
+
+            var item = result.Item;
+            Assert.Equal("Rising (1)", item.Name);
+            Assert.Equal(1, item.IndexNumber);
+            Assert.Equal(2, item.IndexNumberEnd);
+            Assert.Equal(1, item.ParentIndexNumber);
+            Assert.Equal("A new Stargate team embarks on a dangerous mission to a distant galaxy, where they discover a mythical lost city -- and a deadly new enemy.", item.Overview);
+            Assert.Equal(new DateTime(2004, 7, 16), item.PremiereDate);
+            Assert.Equal(2004, item.ProductionYear);
+        }
+
+        [Fact]
+        public void Fetch_WithNullItem_ThrowsArgumentException()
+        {
+            var result = new MetadataResult<Episode>();
+
+            Assert.Throws<ArgumentException>(() => _parser.Fetch(result, "Test Data/The Bone Orchard.nfo", CancellationToken.None));
+        }
+
+        [Fact]
+        public void Fetch_NullResult_ThrowsArgumentException()
+        {
+            var result = new MetadataResult<Episode>()
+            {
+                Item = new Episode()
+            };
+
+            Assert.Throws<ArgumentException>(() => _parser.Fetch(result, string.Empty, CancellationToken.None));
+        }
+    }
+}
diff --git a/tests/Jellyfin.XbmcMetadata.Tests/Parsers/MovieNfoParserTests.cs b/tests/Jellyfin.XbmcMetadata.Tests/Parsers/MovieNfoParserTests.cs
index 7651653a1..7ea45d14d 100644
--- a/tests/Jellyfin.XbmcMetadata.Tests/Parsers/MovieNfoParserTests.cs
+++ b/tests/Jellyfin.XbmcMetadata.Tests/Parsers/MovieNfoParserTests.cs
@@ -1,48 +1,95 @@
 using System;
 using System.Linq;
 using System.Threading;
+using Jellyfin.Data.Entities;
 using MediaBrowser.Common.Configuration;
 using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.Model.Configuration;
 using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.IO;
 using MediaBrowser.Model.Providers;
+using MediaBrowser.Providers.Plugins.Tmdb.Movies;
 using MediaBrowser.XbmcMetadata.Parsers;
 using Microsoft.Extensions.Logging.Abstractions;
 using Moq;
 using Xunit;
 
-namespace Jellyfin.XbmcMetadata.Parsers.Tests
+namespace Jellyfin.XbmcMetadata.Tests.Parsers
 {
     public class MovieNfoParserTests
     {
         private readonly MovieNfoParser _parser;
+        private readonly IUserDataManager _userDataManager;
+        private readonly User _testUser;
+        private readonly FileSystemMetadata _localImageFileMetadata;
 
         public MovieNfoParserTests()
         {
+            _testUser = new User("Test User", "Auth provider", "Reset provider");
+
             var providerManager = new Mock<IProviderManager>();
+
+            var tmdbExternalId = new TmdbMovieExternalId();
+            var externalIdInfo = new ExternalIdInfo(tmdbExternalId.ProviderName, tmdbExternalId.Key, tmdbExternalId.Type, tmdbExternalId.UrlFormatString);
+
             providerManager.Setup(x => x.GetExternalIdInfos(It.IsAny<IHasProviderIds>()))
-                .Returns(Enumerable.Empty<ExternalIdInfo>());
-            var config = new Mock<IConfigurationManager>();
-            config.Setup(x => x.GetConfiguration(It.IsAny<string>()))
-                .Returns(new XbmcMetadataOptions());
-            _parser = new MovieNfoParser(new NullLogger<MovieNfoParser>(), config.Object, providerManager.Object);
+                .Returns(new[] { externalIdInfo });
+
+            var nfoConfig = new XbmcMetadataOptions()
+            {
+                UserId = "F38E6443-090B-4F7A-BD12-9CFF5020F7BC"
+            };
+            var configManager = new Mock<IConfigurationManager>();
+            configManager.Setup(x => x.GetConfiguration(It.IsAny<string>()))
+                .Returns(nfoConfig);
+
+            var user = new Mock<IUserManager>();
+            user.Setup(x => x.GetUserById(It.IsAny<Guid>()))
+                .Returns(_testUser);
+
+            var userData = new Mock<IUserDataManager>();
+            userData.Setup(x => x.GetUserData(_testUser, It.IsAny<BaseItem>()))
+                .Returns(new UserItemData());
+
+            var directoryService = new Mock<IDirectoryService>();
+            _localImageFileMetadata = new FileSystemMetadata()
+            {
+                Exists = true,
+                FullName = OperatingSystem.IsWindows() ?
+                    "C:\\media\\movies\\Justice League (2017).jpg"
+                    : "/media/movies/Justice League (2017).jpg"
+            };
+            directoryService.Setup(x => x.GetFile(_localImageFileMetadata.FullName))
+                .Returns(_localImageFileMetadata);
+
+            _userDataManager = userData.Object;
+            _parser = new MovieNfoParser(
+                new NullLogger<MovieNfoParser>(),
+                configManager.Object,
+                providerManager.Object,
+                user.Object,
+                userData.Object,
+                directoryService.Object);
         }
 
         [Fact]
-        public void Fetch_Valid_Succes()
+        public void Fetch_Valid_Success()
         {
             var result = new MetadataResult<Video>()
             {
-                Item = new Video()
+                Item = new Movie()
             };
 
             _parser.Fetch(result, "Test Data/Justice League.nfo", CancellationToken.None);
-            var item = result.Item;
+            var item = (Movie)result.Item;
 
             Assert.Equal("Justice League", item.OriginalTitle);
             Assert.Equal("Justice for all.", item.Tagline);
-            Assert.Equal("tt0974015", item.ProviderIds["imdb"]);
+            Assert.Equal("tt0974015", item.ProviderIds[MetadataProvider.Imdb.ToString()]);
+            Assert.Equal("141052", item.ProviderIds[MetadataProvider.Tmdb.ToString()]);
 
             Assert.Equal(4, item.Genres.Length);
             Assert.Contains("Action", item.Genres);
@@ -51,22 +98,31 @@ namespace Jellyfin.XbmcMetadata.Parsers.Tests
             Assert.Contains("Sci-Fi", item.Genres);
 
             Assert.Equal(new DateTime(2017, 11, 15), item.PremiereDate);
+            Assert.Equal(new DateTime(2017, 11, 16), item.EndDate);
             Assert.Single(item.Studios);
             Assert.Contains("DC Comics", item.Studios);
 
             Assert.Equal("1.777778", item.AspectRatio);
+            Assert.Equal(Video3DFormat.HalfSideBySide, item.Video3DFormat);
             Assert.Equal(1920, item.Width);
             Assert.Equal(1080, item.Height);
             Assert.Equal(new TimeSpan(0, 0, 6268).Ticks, item.RunTimeTicks);
             Assert.True(item.HasSubtitles);
+            Assert.Equal(7.6f, item.CriticRating);
+            Assert.Equal("8.7", item.CustomRating);
+            Assert.Equal("en", item.PreferredMetadataLanguage);
+            Assert.Equal("us", item.PreferredMetadataCountryCode);
+            Assert.Single(item.RemoteTrailers);
+            Assert.Equal("https://www.youtube.com/watch?v=dQw4w9WgXcQ", item.RemoteTrailers[0].Url);
 
-            Assert.Equal(18, result.People.Count);
+            Assert.Equal(20, result.People.Count);
 
             var writers = result.People.Where(x => x.Type == PersonType.Writer).ToArray();
-            Assert.Equal(2, writers.Length);
+            Assert.Equal(3, writers.Length);
             var writerNames = writers.Select(x => x.Name);
             Assert.Contains("Jerry Siegel", writerNames);
             Assert.Contains("Joe Shuster", writerNames);
+            Assert.Contains("Test", writerNames);
 
             var directors = result.People.Where(x => x.Type == PersonType.Director).ToArray();
             Assert.Single(directors);
@@ -82,7 +138,101 @@ namespace Jellyfin.XbmcMetadata.Parsers.Tests
             Assert.Equal(5, aquaman!.SortOrder);
             Assert.Equal("https://m.media-amazon.com/images/M/MV5BMTI5MTU5NjM1MV5BMl5BanBnXkFtZTcwODc4MDk0Mw@@._V1_SX1024_SY1024_.jpg", aquaman!.ImageUrl);
 
+            var lyricist = result.People.FirstOrDefault(x => x.Type == PersonType.Lyricist);
+            Assert.NotNull(lyricist);
+            Assert.Equal("Test Lyricist", lyricist!.Name);
+
             Assert.Equal(new DateTime(2019, 8, 6, 9, 1, 18), item.DateCreated);
+
+            // userData
+            var userData = _userDataManager.GetUserData(_testUser, item);
+            Assert.Equal(2, userData.PlayCount);
+            Assert.True(userData.Played);
+            Assert.Equal(new DateTime(2021, 02, 11, 07, 47, 23), userData.LastPlayedDate);
+
+            // Movie set
+            Assert.Equal("702342", item.ProviderIds[MetadataProvider.TmdbCollection.ToString()]);
+            Assert.Equal("Justice League Collection", item.CollectionName);
+
+            // Images
+            Assert.Equal(7, result.RemoteImages.Count);
+
+            var posters = result.RemoteImages.Where(x => x.type == ImageType.Primary).ToList();
+            Assert.Single(posters);
+            Assert.Equal("http://image.tmdb.org/t/p/original/9rtrRGeRnL0JKtu9IMBWsmlmmZz.jpg", posters[0].url);
+
+            var logos = result.RemoteImages.Where(x => x.type == ImageType.Logo).ToList();
+            Assert.Single(logos);
+            Assert.Equal("https://assets.fanart.tv/fanart/movies/141052/hdmovielogo/justice-league-5865bf95cbadb.png", logos[0].url);
+
+            var banners = result.RemoteImages.Where(x => x.type == ImageType.Banner).ToList();
+            Assert.Single(banners);
+            Assert.Equal("https://assets.fanart.tv/fanart/movies/141052/moviebanner/justice-league-586017e95adbd.jpg", banners[0].url);
+
+            var thumbs = result.RemoteImages.Where(x => x.type == ImageType.Thumb).ToList();
+            Assert.Single(thumbs);
+            Assert.Equal("https://assets.fanart.tv/fanart/movies/141052/moviethumb/justice-league-585fb155c3743.jpg", thumbs[0].url);
+
+            var art = result.RemoteImages.Where(x => x.type == ImageType.Art).ToList();
+            Assert.Single(art);
+            Assert.Equal("https://assets.fanart.tv/fanart/movies/141052/hdmovieclearart/justice-league-5865c23193041.png", art[0].url);
+
+            var discArt = result.RemoteImages.Where(x => x.type == ImageType.Disc).ToList();
+            Assert.Single(discArt);
+            Assert.Equal("https://assets.fanart.tv/fanart/movies/141052/moviedisc/justice-league-5a3af26360617.png", discArt[0].url);
+
+            var backdrop = result.RemoteImages.Where(x => x.type == ImageType.Backdrop).ToList();
+            Assert.Single(backdrop);
+            Assert.Equal("https://assets.fanart.tv/fanart/movies/141052/moviebackground/justice-league-5793f518c6d6e.jpg", backdrop[0].url);
+
+            // Local Image - contains only one item depending on operating system
+            Assert.Single(result.Images);
+            Assert.Equal(_localImageFileMetadata.Name, result.Images[0].FileInfo.Name);
+        }
+
+        [Theory]
+        [InlineData("Test Data/Tmdb.nfo", "Tmdb", "30287")]
+        [InlineData("Test Data/Imdb.nfo", "Imdb", "tt0944947")]
+        public void Parse_UrlFile_Success(string path, string provider, string id)
+        {
+            var result = new MetadataResult<Video>()
+            {
+                Item = new Movie()
+            };
+
+            _parser.Fetch(result, path, CancellationToken.None);
+            var item = (Movie)result.Item;
+
+            Assert.Equal(id, item.ProviderIds[provider]);
+        }
+
+        [Fact]
+        public void Parse_GivenFileWithFanartTag_Success()
+        {
+            var result = new MetadataResult<Video>()
+            {
+                Item = new Movie()
+            };
+
+            _parser.Fetch(result, "Test Data/Fanart.nfo", CancellationToken.None);
+
+            Assert.Single(result.RemoteImages.Where(x => x.type == ImageType.Backdrop));
+            Assert.Equal("https://assets.fanart.tv/fanart/movies/141052/moviebackground/justice-league-5a5332c7b5e77.jpg", result.RemoteImages.First(x => x.type == ImageType.Backdrop).url);
+        }
+
+        [Fact]
+        public void Parse_RadarrUrlFile_Success()
+        {
+            var result = new MetadataResult<Video>()
+            {
+                Item = new Movie()
+            };
+
+            _parser.Fetch(result, "Test Data/Radarr.nfo", CancellationToken.None);
+            var item = (Movie)result.Item;
+
+            Assert.Equal("583689", item.ProviderIds[MetadataProvider.Tmdb.ToString()]);
+            Assert.Equal("tt4154796", item.ProviderIds[MetadataProvider.Imdb.ToString()]);
         }
 
         [Fact]
@@ -98,7 +248,7 @@ namespace Jellyfin.XbmcMetadata.Parsers.Tests
         {
             var result = new MetadataResult<Video>()
             {
-                Item = new Video()
+                Item = new Movie()
             };
 
             Assert.Throws<ArgumentException>(() => _parser.Fetch(result, string.Empty, CancellationToken.None));
diff --git a/tests/Jellyfin.XbmcMetadata.Tests/Parsers/MusicAlbumNfoProviderTests.cs b/tests/Jellyfin.XbmcMetadata.Tests/Parsers/MusicAlbumNfoProviderTests.cs
new file mode 100644
index 000000000..eea8cb50a
--- /dev/null
+++ b/tests/Jellyfin.XbmcMetadata.Tests/Parsers/MusicAlbumNfoProviderTests.cs
@@ -0,0 +1,86 @@
+using System;
+using System.Threading;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Configuration;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Providers;
+using MediaBrowser.Providers.Music;
+using MediaBrowser.XbmcMetadata.Parsers;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.XbmcMetadata.Tests.Parsers
+{
+    public class MusicAlbumNfoProviderTests
+    {
+        private readonly BaseNfoParser<MusicAlbum> _parser;
+
+        public MusicAlbumNfoProviderTests()
+        {
+            var providerManager = new Mock<IProviderManager>();
+
+            var musicBrainzArtist = new MusicBrainzArtistExternalId();
+            var externalIdInfo = new ExternalIdInfo(musicBrainzArtist.ProviderName, musicBrainzArtist.Key, musicBrainzArtist.Type, "MusicBrainzServer");
+
+            providerManager.Setup(x => x.GetExternalIdInfos(It.IsAny<IHasProviderIds>()))
+                .Returns(new[] { externalIdInfo });
+
+            var config = new Mock<IConfigurationManager>();
+            config.Setup(x => x.GetConfiguration(It.IsAny<string>()))
+                .Returns(new XbmcMetadataOptions());
+            var user = new Mock<IUserManager>();
+            var userData = new Mock<IUserDataManager>();
+            var directoryService = new Mock<IDirectoryService>();
+
+            _parser = new BaseNfoParser<MusicAlbum>(
+                new NullLogger<BaseNfoParser<MusicAlbum>>(),
+                config.Object,
+                providerManager.Object,
+                user.Object,
+                userData.Object,
+                directoryService.Object);
+        }
+
+        [Fact]
+        public void Fetch_Valid_Success()
+        {
+            var result = new MetadataResult<MusicAlbum>()
+            {
+                Item = new MusicAlbum()
+            };
+
+            _parser.Fetch(result, "Test Data/The Best of 1980-1990.nfo", CancellationToken.None);
+            var item = result.Item;
+
+            Assert.Equal("The Best of 1980-1990", item.Name);
+            Assert.Equal(1989, item.ProductionYear);
+            Assert.Contains("Pop", item.Genres);
+            Assert.Single(item.Genres);
+            Assert.Contains("Rock/Pop", item.Tags);
+            Assert.Equal("The Best of 1980-1990 is the first greatest hits compilation by Irish rock band U2, released in November 1998. It mostly contains the group's hit singles from the eighties but also mixes in some live staples as well as one new recording, Sweetest Thing. In April 1999, a companion video (featuring music videos and live footage) was released. The album was followed by another compilation, The Best of 1990-2000, in 2002.\nA limited edition version containing a special B-sides disc was released on the same date as the single-disc version. At the time of release, the official word was that the 2-disc album would be available the first week the album went on sale, then pulled from the stores. While this threat never materialized, it did result in the 2-disc version being in very high demand. Both versions charted in the Billboard 200.\nThe boy on the cover is Peter Rowan, brother of Bono's friend Guggi (real name Derek Rowan) of the Virgin Prunes. He also appears on the covers of the early EP Three, two of the band's first three albums (Boy and War), and Early Demos.", item.Overview);
+        }
+
+        [Fact]
+        public void Fetch_WithNullItem_ThrowsArgumentException()
+        {
+            var result = new MetadataResult<MusicAlbum>();
+
+            Assert.Throws<ArgumentException>(() => _parser.Fetch(result, "Test Data/The Best of 1980-1990.nfo", CancellationToken.None));
+        }
+
+        [Fact]
+        public void Fetch_NullResult_ThrowsArgumentException()
+        {
+            var result = new MetadataResult<MusicAlbum>()
+            {
+                Item = new MusicAlbum()
+            };
+
+            Assert.Throws<ArgumentException>(() => _parser.Fetch(result, string.Empty, CancellationToken.None));
+        }
+    }
+}
diff --git a/tests/Jellyfin.XbmcMetadata.Tests/Parsers/MusicArtistNfoParserTests.cs b/tests/Jellyfin.XbmcMetadata.Tests/Parsers/MusicArtistNfoParserTests.cs
index a8c6e5afd..8ca3dd96e 100644
--- a/tests/Jellyfin.XbmcMetadata.Tests/Parsers/MusicArtistNfoParserTests.cs
+++ b/tests/Jellyfin.XbmcMetadata.Tests/Parsers/MusicArtistNfoParserTests.cs
@@ -1,18 +1,19 @@
 using System;
-using System.Linq;
 using System.Threading;
 using MediaBrowser.Common.Configuration;
 using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.Model.Configuration;
 using MediaBrowser.Model.Entities;
 using MediaBrowser.Model.Providers;
+using MediaBrowser.Providers.Music;
 using MediaBrowser.XbmcMetadata.Parsers;
 using Microsoft.Extensions.Logging.Abstractions;
 using Moq;
 using Xunit;
 
-namespace Jellyfin.XbmcMetadata.Parsers.Tests
+namespace Jellyfin.XbmcMetadata.Tests.Parsers
 {
     public class MusicArtistNfoParserTests
     {
@@ -21,16 +22,31 @@ namespace Jellyfin.XbmcMetadata.Parsers.Tests
         public MusicArtistNfoParserTests()
         {
             var providerManager = new Mock<IProviderManager>();
+
+            var musicBrainzArtist = new MusicBrainzArtistExternalId();
+            var externalIdInfo = new ExternalIdInfo(musicBrainzArtist.ProviderName, musicBrainzArtist.Key, musicBrainzArtist.Type, "MusicBrainzServer");
+
             providerManager.Setup(x => x.GetExternalIdInfos(It.IsAny<IHasProviderIds>()))
-                .Returns(Enumerable.Empty<ExternalIdInfo>());
+                .Returns(new[] { externalIdInfo });
+
             var config = new Mock<IConfigurationManager>();
             config.Setup(x => x.GetConfiguration(It.IsAny<string>()))
                 .Returns(new XbmcMetadataOptions());
-            _parser = new BaseNfoParser<MusicArtist>(new NullLogger<BaseNfoParser<MusicArtist>>(), config.Object, providerManager.Object);
+            var user = new Mock<IUserManager>();
+            var userData = new Mock<IUserDataManager>();
+            var directoryService = new Mock<IDirectoryService>();
+
+            _parser = new BaseNfoParser<MusicArtist>(
+                new NullLogger<BaseNfoParser<MusicArtist>>(),
+                config.Object,
+                providerManager.Object,
+                user.Object,
+                userData.Object,
+                directoryService.Object);
         }
 
         [Fact]
-        public void Fetch_Valid_Succes()
+        public void Fetch_Valid_Success()
         {
             var result = new MetadataResult<MusicArtist>()
             {
diff --git a/tests/Jellyfin.XbmcMetadata.Tests/Parsers/MusicVideoNfoParserTests.cs b/tests/Jellyfin.XbmcMetadata.Tests/Parsers/MusicVideoNfoParserTests.cs
new file mode 100644
index 000000000..bf887cab1
--- /dev/null
+++ b/tests/Jellyfin.XbmcMetadata.Tests/Parsers/MusicVideoNfoParserTests.cs
@@ -0,0 +1,80 @@
+using System;
+using System.Linq;
+using System.Threading;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Configuration;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Providers;
+using MediaBrowser.XbmcMetadata.Parsers;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.XbmcMetadata.Tests.Parsers
+{
+    public class MusicVideoNfoParserTests
+    {
+        private readonly MovieNfoParser _parser;
+
+        public MusicVideoNfoParserTests()
+        {
+            var providerManager = new Mock<IProviderManager>();
+            providerManager.Setup(x => x.GetExternalIdInfos(It.IsAny<IHasProviderIds>()))
+                .Returns(Enumerable.Empty<ExternalIdInfo>());
+            var config = new Mock<IConfigurationManager>();
+            config.Setup(x => x.GetConfiguration(It.IsAny<string>()))
+                .Returns(new XbmcMetadataOptions());
+
+            var user = new Mock<IUserManager>();
+            var userData = new Mock<IUserDataManager>();
+            var directoryService = new Mock<IDirectoryService>();
+
+            _parser = new MovieNfoParser(
+                new NullLogger<BaseNfoParser<MusicVideo>>(),
+                config.Object,
+                providerManager.Object,
+                user.Object,
+                userData.Object,
+                directoryService.Object);
+        }
+
+        [Fact]
+        public void Fetch_Valid_Succes()
+        {
+            var result = new MetadataResult<Video>()
+            {
+                Item = new MusicVideo()
+            };
+
+            _parser.Fetch(result, "Test Data/Dancing Queen.nfo", CancellationToken.None);
+            var item = (MusicVideo)result.Item;
+
+            Assert.Equal("Dancing Queen", item.Name);
+            Assert.Single(item.Artists);
+            Assert.Contains("ABBA", item.Artists);
+            Assert.Equal("Arrival", item.Album);
+        }
+
+        [Fact]
+        public void Fetch_WithNullItem_ThrowsArgumentException()
+        {
+            var result = new MetadataResult<Video>();
+
+            Assert.Throws<ArgumentException>(() => _parser.Fetch(result, "Test Data/Dancing Queen.nfo", CancellationToken.None));
+        }
+
+        [Fact]
+        public void Fetch_NullResult_ThrowsArgumentException()
+        {
+            var result = new MetadataResult<Video>()
+            {
+                Item = new MusicVideo()
+            };
+
+            Assert.Throws<ArgumentException>(() => _parser.Fetch(result, string.Empty, CancellationToken.None));
+        }
+    }
+}
diff --git a/tests/Jellyfin.XbmcMetadata.Tests/Parsers/SeasonNfoProviderTests.cs b/tests/Jellyfin.XbmcMetadata.Tests/Parsers/SeasonNfoProviderTests.cs
new file mode 100644
index 000000000..31110dbd7
--- /dev/null
+++ b/tests/Jellyfin.XbmcMetadata.Tests/Parsers/SeasonNfoProviderTests.cs
@@ -0,0 +1,92 @@
+using System;
+using System.Linq;
+using System.Threading;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Configuration;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Providers;
+using MediaBrowser.XbmcMetadata.Parsers;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.XbmcMetadata.Tests.Parsers
+{
+    public class SeasonNfoProviderTests
+    {
+        private readonly SeasonNfoParser _parser;
+
+        public SeasonNfoProviderTests()
+        {
+            var providerManager = new Mock<IProviderManager>();
+            providerManager.Setup(x => x.GetExternalIdInfos(It.IsAny<IHasProviderIds>()))
+                .Returns(Enumerable.Empty<ExternalIdInfo>());
+            var config = new Mock<IConfigurationManager>();
+            config.Setup(x => x.GetConfiguration(It.IsAny<string>()))
+                .Returns(new XbmcMetadataOptions());
+            var user = new Mock<IUserManager>();
+            var userData = new Mock<IUserDataManager>();
+            var directoryService = new Mock<IDirectoryService>();
+
+            _parser = new SeasonNfoParser(
+                new NullLogger<SeasonNfoParser>(),
+                config.Object,
+                providerManager.Object,
+                user.Object,
+                userData.Object,
+                directoryService.Object);
+        }
+
+        [Fact]
+        public void Fetch_Valid_Success()
+        {
+            var result = new MetadataResult<Season>()
+            {
+                Item = new Season()
+            };
+
+            _parser.Fetch(result, "Test Data/Season 01.nfo", CancellationToken.None);
+            var item = result.Item;
+
+            Assert.Equal("Season 1", item.Name);
+            Assert.Equal(1, item.IndexNumber);
+            Assert.False(item.IsLocked);
+            Assert.Equal(2019, item.ProductionYear);
+            Assert.Equal(new DateTime(2019, 11, 08), item.PremiereDate);
+            Assert.Equal(new DateTime(2020, 06, 14, 17, 26, 51), item.DateCreated);
+
+            Assert.Equal(10, result.People.Count);
+
+            Assert.True(result.People.All(x => x.Type == PersonType.Actor));
+
+            // Only test one actor
+            var nini = result.People.FirstOrDefault(x => x.Role.Equals("Nini", StringComparison.Ordinal));
+            Assert.NotNull(nini);
+            Assert.Equal("Olivia Rodrigo", nini!.Name);
+            Assert.Equal(0, nini!.SortOrder);
+            Assert.Equal("/config/metadata/People/O/Olivia Rodrigo/poster.jpg", nini!.ImageUrl);
+        }
+
+        [Fact]
+        public void Fetch_WithNullItem_ThrowsArgumentException()
+        {
+            var result = new MetadataResult<Season>();
+
+            Assert.Throws<ArgumentException>(() => _parser.Fetch(result, "Test Data/Season 01.nfo", CancellationToken.None));
+        }
+
+        [Fact]
+        public void Fetch_NullResult_ThrowsArgumentException()
+        {
+            var result = new MetadataResult<Season>()
+            {
+                Item = new Season()
+            };
+
+            Assert.Throws<ArgumentException>(() => _parser.Fetch(result, string.Empty, CancellationToken.None));
+        }
+    }
+}
diff --git a/tests/Jellyfin.XbmcMetadata.Tests/Parsers/SeriesNfoParserTests.cs b/tests/Jellyfin.XbmcMetadata.Tests/Parsers/SeriesNfoParserTests.cs
index 37ca0fd05..bdedae205 100644
--- a/tests/Jellyfin.XbmcMetadata.Tests/Parsers/SeriesNfoParserTests.cs
+++ b/tests/Jellyfin.XbmcMetadata.Tests/Parsers/SeriesNfoParserTests.cs
@@ -3,6 +3,7 @@ using System.Linq;
 using System.Threading;
 using MediaBrowser.Common.Configuration;
 using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.Model.Configuration;
 using MediaBrowser.Model.Entities;
@@ -12,7 +13,7 @@ using Microsoft.Extensions.Logging.Abstractions;
 using Moq;
 using Xunit;
 
-namespace Jellyfin.XbmcMetadata.Parsers.Tests
+namespace Jellyfin.XbmcMetadata.Tests.Parsers
 {
     public class SeriesNfoParserTests
     {
@@ -26,11 +27,15 @@ namespace Jellyfin.XbmcMetadata.Parsers.Tests
             var config = new Mock<IConfigurationManager>();
             config.Setup(x => x.GetConfiguration(It.IsAny<string>()))
                 .Returns(new XbmcMetadataOptions());
-            _parser = new SeriesNfoParser(new NullLogger<SeriesNfoParser>(), config.Object, providerManager.Object);
+            var user = new Mock<IUserManager>();
+            var userData = new Mock<IUserDataManager>();
+            var directoryService = new Mock<IDirectoryService>();
+
+            _parser = new SeriesNfoParser(new NullLogger<SeriesNfoParser>(), config.Object, providerManager.Object, user.Object, userData.Object, directoryService.Object);
         }
 
         [Fact]
-        public void Fetch_Valid_Succes()
+        public void Fetch_Valid_Success()
         {
             var result = new MetadataResult<Series>()
             {
@@ -43,8 +48,9 @@ namespace Jellyfin.XbmcMetadata.Parsers.Tests
             Assert.Equal("American Gods", item.OriginalTitle);
             Assert.Equal(string.Empty, item.Tagline);
             Assert.Equal(0, item.RunTimeTicks);
-            Assert.Equal("46639", item.ProviderIds["tmdb"]);
-            Assert.Equal("253573", item.ProviderIds["tvdb"]);
+            Assert.Equal("46639", item.ProviderIds[MetadataProvider.Tmdb.ToString()]);
+            Assert.Equal("253573", item.ProviderIds[MetadataProvider.Tvdb.ToString()]);
+            Assert.Equal("tt11111", item.ProviderIds[MetadataProvider.Imdb.ToString()]);
 
             Assert.Equal(3, item.Genres.Length);
             Assert.Contains("Drama", item.Genres);
@@ -54,6 +60,10 @@ namespace Jellyfin.XbmcMetadata.Parsers.Tests
             Assert.Equal(new DateTime(2017, 4, 30), item.PremiereDate);
             Assert.Single(item.Studios);
             Assert.Contains("Starz", item.Studios);
+            Assert.Equal("9 PM", item.AirTime);
+            Assert.Single(item.AirDays);
+            Assert.Contains(DayOfWeek.Friday, item.AirDays);
+            Assert.Equal(SeriesStatus.Ended, item.Status);
 
             Assert.Equal(6, result.People.Count);
 
@@ -69,6 +79,21 @@ namespace Jellyfin.XbmcMetadata.Parsers.Tests
             Assert.Equal(new DateTime(2017, 10, 7, 14, 25, 47), item.DateCreated);
         }
 
+        [Theory]
+        [InlineData("Test Data/Tvdb.nfo", "Tvdb", "121361")]
+        public void Parse_UrlFile_Success(string path, string provider, string id)
+        {
+            var result = new MetadataResult<Series>()
+            {
+                Item = new Series()
+            };
+
+            _parser.Fetch(result, path, CancellationToken.None);
+            var item = (Series)result.Item;
+
+            Assert.Equal(id, item.ProviderIds[provider]);
+        }
+
         [Fact]
         public void Fetch_WithNullItem_ThrowsArgumentException()
         {
diff --git a/tests/Jellyfin.XbmcMetadata.Tests/Test Data/American Gods.nfo b/tests/Jellyfin.XbmcMetadata.Tests/Test Data/American Gods.nfo
index b9f31f2f6..5bf7e08eb 100644
--- a/tests/Jellyfin.XbmcMetadata.Tests/Test Data/American Gods.nfo
+++ b/tests/Jellyfin.XbmcMetadata.Tests/Test Data/American Gods.nfo
@@ -126,7 +126,7 @@
     <episodeguide>
         <url cache="tmdb-46639-en.json">http://api.themoviedb.org/3/tv/46639?api_key=6a5be4999abf74eba1f9a8311294c267&amp;language=en</url>
     </episodeguide>
-    <id>46639</id>
+    <id IMDB="tt11111" TMDB="46639">253573</id>
     <uniqueid type="tmdb" default="true">46639</uniqueid>
     <uniqueid type="tvdb">253573</uniqueid>
     <genre>Drama</genre>
@@ -134,7 +134,9 @@
     <genre>Sci-Fi &amp; Fantasy</genre>
     <premiered>2017-04-30</premiered>
     <year>2017</year>
-    <status></status>
+    <status>ended</status>
+    <airs_time>9 PM</airs_time>
+    <airs_dayofweek>Friday</airs_dayofweek>
     <code></code>
     <aired></aired>
     <studio>Starz</studio>
diff --git a/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Dancing Queen.nfo b/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Dancing Queen.nfo
new file mode 100644
index 000000000..29f19e1a0
--- /dev/null
+++ b/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Dancing Queen.nfo
@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes"?>
+<musicvideo>
+  <title>Dancing Queen</title>
+  <userrating>0</userrating>
+  <top250>0</top250>
+  <track>3</track>
+  <album>Arrival</album>
+  <outline></outline>
+  <plot>Dancing Queen est un des tubes emblématiques de l&apos;ère disco produits par le groupe suédois ABBA en 1976. Ce tube connaît un regain de popularité en 1994 lors de la sortie de Priscilla, folle du désert, et fait « presque » partie de la distribution du film Muriel.&#x0A;Le groupe a également enregistré une version espagnole de ce titre, La reina del baile, pour le marché d&apos;Amérique latine. On peut retrouver ces versions en espagnol des succès de ABBA sur l&apos;abum Oro. Le 18 juin 1976, ABBA a interprété cette chanson lors d&apos;un spectacle télévisé organisé en l&apos;honneur du roi Charles XVI Gustave de Suède, qui venait de se marier. Le titre sera repris en 2011 par Glee dans la saison 2, épisode 20.</plot>
+  <tagline></tagline>
+  <runtime>2</runtime>
+  <thumb preview="https://www.theaudiodb.com/images/media/album/thumb/arrival-4ee244732bbde.jpg/preview">https://www.theaudiodb.com/images/media/album/thumb/arrival-4ee244732bbde.jpg</thumb>
+  <thumb preview="https://assets.fanart.tv/preview/music/d87e52c5-bb8d-4da8-b941-9f4928627dc8/albumcover/arrival-548ab7a698b49.jpg">https://assets.fanart.tv/fanart/music/d87e52c5-bb8d-4da8-b941-9f4928627dc8/albumcover/arrival-548ab7a698b49.jpg</thumb>
+  <mpaa></mpaa>
+  <playcount>0</playcount>
+  <lastplayed></lastplayed>
+  <id></id>
+  <genre>Pop</genre>
+  <director>John Smith</director>
+  <premiered>1976-01-01</premiered>
+  <year>1976</year>
+  <status></status>
+  <code></code>
+  <aired></aired>
+  <studio>Studio 54</studio>
+  <trailer></trailer>
+  <fileinfo>
+    <streamdetails>
+      <video>
+        <codec>hevc</codec>
+        <aspect>1.792230</aspect>
+        <width>716</width>
+        <height>568</height>
+        <durationinseconds>143</durationinseconds>
+        <stereomode></stereomode>
+      </video>
+      <audio>
+        <codec>ac3</codec>
+        <language>eng</language>
+        <channels>2</channels>
+      </audio>
+    </streamdetails>
+  </fileinfo>
+  <artist>ABBA</artist>
+  <resume>
+    <position>0.000000</position>
+    <total>0.000000</total>
+  </resume>
+  <dateadded>2018-09-10 09:46:06</dateadded>
+</musicvideo>
diff --git a/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Fanart.nfo b/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Fanart.nfo
new file mode 100644
index 000000000..0b129bd8c
--- /dev/null
+++ b/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Fanart.nfo
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<movie>
+    <thumb aspect="clearlogo" preview="https://assets.fanart.tv/preview/movies/141052/hdmovielogo/justice-league-5865bf95cbadb.png">https://assets.fanart.tv/fanart/movies/141052/hdmovielogo/justice-league-5865bf95cbadb.png</thumb>
+    <thumb aspect="clearlogo" preview="https://assets.fanart.tv/preview/movies/141052/hdmovielogo/justice-league-585e9ca3bcf6a.png">https://assets.fanart.tv/fanart/movies/141052/hdmovielogo/justice-league-585e9ca3bcf6a.png</thumb>
+    <thumb aspect="clearlogo" preview="https://assets.fanart.tv/preview/movies/141052/hdmovielogo/justice-league-57b476a831d74.png">https://assets.fanart.tv/fanart/movies/141052/hdmovielogo/justice-league-57b476a831d74.png</thumb>
+    <thumb aspect="clearlogo" preview="https://assets.fanart.tv/preview/movies/141052/hdmovielogo/justice-league-57947e28cf10b.png">https://assets.fanart.tv/fanart/movies/141052/hdmovielogo/justice-league-57947e28cf10b.png</thumb>
+    <thumb aspect="clearlogo" preview="https://assets.fanart.tv/preview/movies/141052/hdmovielogo/justice-league-5863d5c0cf0c9.png">https://assets.fanart.tv/fanart/movies/141052/hdmovielogo/justice-league-5863d5c0cf0c9.png</thumb>
+    <thumb aspect="clearlogo" preview="https://assets.fanart.tv/preview/movies/141052/hdmovielogo/justice-league-5a801747e5545.png">https://assets.fanart.tv/fanart/movies/141052/hdmovielogo/justice-league-5a801747e5545.png</thumb>
+    <thumb aspect="clearlogo" preview="https://assets.fanart.tv/preview/movies/141052/hdmovielogo/justice-league-5cd75683df92b.png">https://assets.fanart.tv/fanart/movies/141052/hdmovielogo/justice-league-5cd75683df92b.png</thumb>
+    <thumb aspect="banner" preview="https://assets.fanart.tv/preview/movies/141052/moviebanner/justice-league-586017e95adbd.jpg">https://assets.fanart.tv/fanart/movies/141052/moviebanner/justice-league-586017e95adbd.jpg</thumb>
+    <thumb aspect="banner" preview="https://assets.fanart.tv/preview/movies/141052/moviebanner/justice-league-5934d45bc6592.jpg">https://assets.fanart.tv/fanart/movies/141052/moviebanner/justice-league-5934d45bc6592.jpg</thumb>
+    <thumb aspect="banner" preview="https://assets.fanart.tv/preview/movies/141052/moviebanner/justice-league-5aa9289a379fa.jpg">https://assets.fanart.tv/fanart/movies/141052/moviebanner/justice-league-5aa9289a379fa.jpg</thumb>
+    <thumb aspect="landscape" preview="https://assets.fanart.tv/preview/movies/141052/moviethumb/justice-league-585fb155c3743.jpg">https://assets.fanart.tv/fanart/movies/141052/moviethumb/justice-league-585fb155c3743.jpg</thumb>
+    <thumb aspect="landscape" preview="https://assets.fanart.tv/preview/movies/141052/moviethumb/justice-league-585edbda91d82.jpg">https://assets.fanart.tv/fanart/movies/141052/moviethumb/justice-league-585edbda91d82.jpg</thumb>
+    <thumb aspect="landscape" preview="https://assets.fanart.tv/preview/movies/141052/moviethumb/justice-league-5b86588882c12.jpg">https://assets.fanart.tv/fanart/movies/141052/moviethumb/justice-league-5b86588882c12.jpg</thumb>
+    <thumb aspect="landscape" preview="https://assets.fanart.tv/preview/movies/141052/moviethumb/justice-league-5bbb9babe600c.jpg">https://assets.fanart.tv/fanart/movies/141052/moviethumb/justice-league-5bbb9babe600c.jpg</thumb>
+    <thumb aspect="clearart" preview="https://assets.fanart.tv/preview/movies/141052/hdmovieclearart/justice-league-5865c23193041.png">https://assets.fanart.tv/fanart/movies/141052/hdmovieclearart/justice-league-5865c23193041.png</thumb>
+    <thumb aspect="discart" preview="https://assets.fanart.tv/preview/movies/141052/moviedisc/justice-league-5a3af26360617.png">https://assets.fanart.tv/fanart/movies/141052/moviedisc/justice-league-5a3af26360617.png</thumb>
+    <thumb aspect="discart" preview="https://assets.fanart.tv/preview/movies/141052/moviedisc/justice-league-58690967b9765.png">https://assets.fanart.tv/fanart/movies/141052/moviedisc/justice-league-58690967b9765.png</thumb>
+    <thumb aspect="discart" preview="https://assets.fanart.tv/preview/movies/141052/moviedisc/justice-league-5a953ca4db6a6.png">https://assets.fanart.tv/fanart/movies/141052/moviedisc/justice-league-5a953ca4db6a6.png</thumb>
+    <thumb aspect="discart" preview="https://assets.fanart.tv/preview/movies/141052/moviedisc/justice-league-5a0b913c233be.png">https://assets.fanart.tv/fanart/movies/141052/moviedisc/justice-league-5a0b913c233be.png</thumb>
+    <thumb aspect="discart" preview="https://assets.fanart.tv/preview/movies/141052/moviedisc/justice-league-5a87e0cdb1209.png">https://assets.fanart.tv/fanart/movies/141052/moviedisc/justice-league-5a87e0cdb1209.png</thumb>
+    <thumb aspect="discart" preview="https://assets.fanart.tv/preview/movies/141052/moviedisc/justice-league-59dc595362ef1.png">https://assets.fanart.tv/fanart/movies/141052/moviedisc/justice-league-59dc595362ef1.png</thumb>
+    <fanart>
+        <thumb preview="https://assets.fanart.tv/preview/movies/141052/moviebackground/justice-league-5a5332c7b5e77.jpg">https://assets.fanart.tv/fanart/movies/141052/moviebackground/justice-league-5a5332c7b5e77.jpg</thumb>
+        <thumb preview="https://assets.fanart.tv/preview/movies/141052/moviebackground/justice-league-5a53cf2dac1c8.jpg">https://assets.fanart.tv/fanart/movies/141052/moviebackground/justice-league-5a53cf2dac1c8.jpg</thumb>
+        <thumb preview="https://assets.fanart.tv/preview/movies/141052/moviebackground/justice-league-5976ba93eb5d3.jpg">https://assets.fanart.tv/fanart/movies/141052/moviebackground/justice-league-5976ba93eb5d3.jpg</thumb>
+        <thumb preview="https://assets.fanart.tv/preview/movies/141052/moviebackground/justice-league-58fa1f1932897.jpg">https://assets.fanart.tv/fanart/movies/141052/moviebackground/justice-league-58fa1f1932897.jpg</thumb>
+        <thumb preview="https://assets.fanart.tv/preview/movies/141052/moviebackground/justice-league-5a14f5fd8dd16.jpg">https://assets.fanart.tv/fanart/movies/141052/moviebackground/justice-league-5a14f5fd8dd16.jpg</thumb>
+        <thumb preview="https://assets.fanart.tv/preview/movies/141052/moviebackground/justice-league-5a119394ea362.jpg">https://assets.fanart.tv/fanart/movies/141052/moviebackground/justice-league-5a119394ea362.jpg</thumb>
+    </fanart>
+    <thumb aspect="fanart">This-should-not-be-saved-as-a-fanart-image.jpg</thumb>
+</movie>
diff --git a/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Imdb.nfo b/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Imdb.nfo
new file mode 100644
index 000000000..e30a1c660
--- /dev/null
+++ b/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Imdb.nfo
@@ -0,0 +1 @@
+https://www.imdb.com/title/tt0944947/
diff --git a/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Justice League.nfo b/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Justice League.nfo
index f838af8d0..4e8c79dca 100644
--- a/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Justice League.nfo
+++ b/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Justice League.nfo
@@ -24,12 +24,21 @@
 			<votes>119873</votes>
 		</rating>
     </ratings>
+    <criticrating>7.6</criticrating>
+    <language>en</language>
+    <countrycode>us</countrycode>
+    <customrating>8.7</customrating>
+    <aspectratio>1.777778</aspectratio>
     <userrating>0</userrating>
     <top250>0</top250>
     <outline>Fueled by his restored faith in humanity and inspired by Superman&apos;s selfless act, Bruce Wayne enlists the help of his new-found ally, Diana Prince, to face an even greater enemy.</outline>
     <plot>Fueled by his restored faith in humanity and inspired by Superman&apos;s selfless act, Bruce Wayne enlists the help of his newfound ally, Diana Prince, to face an even greater enemy. Together, Batman and Wonder Woman work quickly to find and recruit a team of meta-humans to stand against this newly awakened threat. But despite the formation of this unprecedented league of heroes-Batman, Wonder Woman, Aquaman, Cyborg and The Flash-it may already be too late to save the planet from an assault of catastrophic proportions.</plot>
     <tagline>Justice for all.</tagline>
     <runtime>120</runtime>
+    <playcount>2</playcount>
+    <watched>true</watched>
+    <lastplayed>2021-02-11 07:47:23</lastplayed>
+    <tmdbId>141052</tmdbId>
     <thumb aspect="set.poster" preview="https://assets.fanart.tv/preview/movies/468551/movieposter/justice-league-collection-5c24ea65591d3.jpg">https://assets.fanart.tv/fanart/movies/468551/movieposter/justice-league-collection-5c24ea65591d3.jpg</thumb>
     <thumb aspect="set.poster" preview="https://assets.fanart.tv/preview/movies/468551/movieposter/justice-league-collection-5c24ea65591d3.jpg">https://assets.fanart.tv/fanart/movies/468551/movieposter/justice-league-collection-5c24ea65591d3.jpg</thumb>
     <thumb aspect="set.clearlogo" preview="https://assets.fanart.tv/preview/movies/468551/hdmovielogo/justice-league-collection-5ba855ed4239a.png">https://assets.fanart.tv/fanart/movies/468551/hdmovielogo/justice-league-collection-5ba855ed4239a.png</thumb>
@@ -50,6 +59,8 @@
     <thumb aspect="poster" preview="http://image.tmdb.org/t/p/w500/exLtrlI7JjKcfQVTccI7XdQRFMz.jpg">http://image.tmdb.org/t/p/original/exLtrlI7JjKcfQVTccI7XdQRFMz.jpg</thumb>
     <thumb aspect="poster" preview="http://image.tmdb.org/t/p/w500/paLcue01KpfQftorfjKqqD4qvlL.jpg">http://image.tmdb.org/t/p/original/paLcue01KpfQftorfjKqqD4qvlL.jpg</thumb>
     <thumb aspect="poster" preview="http://image.tmdb.org/t/p/w500/yVDIfiKIsCbdFcgLXW34bAsnQvy.jpg">http://image.tmdb.org/t/p/original/yVDIfiKIsCbdFcgLXW34bAsnQvy.jpg</thumb>
+    <thumb aspect="poster">C:\media\movies\Justice League (2017).jpg</thumb>
+    <thumb aspect="poster">/media/movies/Justice League (2017).jpg</thumb>
     <thumb aspect="clearlogo" preview="https://assets.fanart.tv/preview/movies/141052/hdmovielogo/justice-league-5865bf95cbadb.png">https://assets.fanart.tv/fanart/movies/141052/hdmovielogo/justice-league-5865bf95cbadb.png</thumb>
     <thumb aspect="clearlogo" preview="https://assets.fanart.tv/preview/movies/141052/hdmovielogo/justice-league-585e9ca3bcf6a.png">https://assets.fanart.tv/fanart/movies/141052/hdmovielogo/justice-league-585e9ca3bcf6a.png</thumb>
     <thumb aspect="clearlogo" preview="https://assets.fanart.tv/preview/movies/141052/hdmovielogo/justice-league-57b476a831d74.png">https://assets.fanart.tv/fanart/movies/141052/hdmovielogo/justice-league-57b476a831d74.png</thumb>
@@ -71,8 +82,8 @@
     <thumb aspect="discart" preview="https://assets.fanart.tv/preview/movies/141052/moviedisc/justice-league-5a0b913c233be.png">https://assets.fanart.tv/fanart/movies/141052/moviedisc/justice-league-5a0b913c233be.png</thumb>
     <thumb aspect="discart" preview="https://assets.fanart.tv/preview/movies/141052/moviedisc/justice-league-5a87e0cdb1209.png">https://assets.fanart.tv/fanart/movies/141052/moviedisc/justice-league-5a87e0cdb1209.png</thumb>
     <thumb aspect="discart" preview="https://assets.fanart.tv/preview/movies/141052/moviedisc/justice-league-59dc595362ef1.png">https://assets.fanart.tv/fanart/movies/141052/moviedisc/justice-league-59dc595362ef1.png</thumb>
+    <thumb aspect="fanart">https://assets.fanart.tv/fanart/movies/141052/moviebackground/justice-league-5793f518c6d6e.jpg</thumb>
     <fanart>
-        <thumb preview="https://assets.fanart.tv/preview/movies/141052/moviebackground/justice-league-5793f518c6d6e.jpg">https://assets.fanart.tv/fanart/movies/141052/moviebackground/justice-league-5793f518c6d6e.jpg</thumb>
         <thumb preview="https://assets.fanart.tv/preview/movies/141052/moviebackground/justice-league-5a5332c7b5e77.jpg">https://assets.fanart.tv/fanart/movies/141052/moviebackground/justice-league-5a5332c7b5e77.jpg</thumb>
         <thumb preview="https://assets.fanart.tv/preview/movies/141052/moviebackground/justice-league-5a53cf2dac1c8.jpg">https://assets.fanart.tv/fanart/movies/141052/moviebackground/justice-league-5a53cf2dac1c8.jpg</thumb>
         <thumb preview="https://assets.fanart.tv/preview/movies/141052/moviebackground/justice-league-5976ba93eb5d3.jpg">https://assets.fanart.tv/fanart/movies/141052/moviebackground/justice-league-5976ba93eb5d3.jpg</thumb>
@@ -81,10 +92,9 @@
         <thumb preview="https://assets.fanart.tv/preview/movies/141052/moviebackground/justice-league-5a119394ea362.jpg">https://assets.fanart.tv/fanart/movies/141052/moviebackground/justice-league-5a119394ea362.jpg</thumb>
     </fanart>
     <mpaa>Australia:M</mpaa>
-    <playcount>0</playcount>
-    <lastplayed></lastplayed>
     <id>tt0974015</id>
-    <uniqueid type="imdb" default="true">tt0974015</uniqueid>
+    <uniqueid type="imdb">tt0974015</uniqueid>
+    <uniqueid type="tmdb">141052</uniqueid>
     <genre>Action</genre>
     <genre>Adventure</genre>
     <genre>Fantasy</genre>
@@ -92,20 +102,22 @@
     <country>USA</country>
     <country>Canada</country>
     <country>UK</country>
-    <set>
+    <set tmdbcolid="702342">
         <name>Justice League Collection</name>
         <overview>Based on the DC Comics superhero team</overview>
     </set>
     <credits>Jerry Siegel</credits>
     <credits>Joe Shuster</credits>
-    <director>Zack Snyder</director>
+    <director>Zack Snyder,</director>
+    <writer>Test</writer>
     <premiered>2017-11-15</premiered>
+    <enddate>2017-11-16</enddate>
     <year>2017</year>
     <status></status>
     <code></code>
     <aired></aired>
     <studio>DC Comics</studio>
-    <trailer></trailer>
+    <trailer>plugin://plugin.video.youtube/?action=play_video&amp;videoid=dQw4w9WgXcQ</trailer>
     <fileinfo>
         <streamdetails>
             <video>
@@ -115,6 +127,7 @@
                 <height>1080</height>
                 <durationinseconds>6268</durationinseconds>
                 <stereomode></stereomode>
+                <format3d>HSBS</format3d>
             </video>
             <audio>
                 <codec>truehd</codec>
@@ -221,6 +234,11 @@
         <order>14</order>
         <thumb>https://m.media-amazon.com/images/M/MV5BOTFjOTFhNTgtZjk3Ny00MTNjLWE3MWUtMWI3ZWM5NDljZjQwXkEyXkFqcGdeQXVyMjQwMDg0Ng@@._V1_SX1024_SY1024_.jpg</thumb>
     </actor>
+    <actor>
+        <name>Test Lyricist</name>
+        <type>Lyricist</type>
+        <order>15</order>
+    </actor>
     <resume>
         <position>0.000000</position>
         <total>0.000000</total>
diff --git a/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Radarr.nfo b/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Radarr.nfo
new file mode 100644
index 000000000..43da4881c
--- /dev/null
+++ b/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Radarr.nfo
@@ -0,0 +1,2 @@
+https://www.themoviedb.org/movie/583689
+https://www.imdb.com/title/tt4154796
diff --git a/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Rising.nfo b/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Rising.nfo
new file mode 100644
index 000000000..56250c09a
--- /dev/null
+++ b/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Rising.nfo
@@ -0,0 +1,20 @@
+<episodedetails>
+  <title>Rising (1)</title>
+  <season>1</season>
+  <episode>1</episode>
+  <aired>2004-07-16</aired>
+  <plot>A new Stargate team embarks on a dangerous mission to a distant galaxy, where they discover a mythical lost city -- and a deadly new enemy.</plot>
+  <thumb>https://artworks.thetvdb.com/banners/episodes/70851/25333.jpg</thumb>
+  <watched>false</watched>
+  <rating>8.0</rating>
+</episodedetails>
+<episodedetails>
+  <title>Rising (2)</title>
+  <season>1</season>
+  <episode>2</episode>
+  <aired>2004-07-16</aired>
+  <plot>Sheppard tries to convince Weir to mount a rescue mission to free Colonel Sumner, Teyla, and the others captured by the Wraith.</plot>
+  <thumb>https://artworks.thetvdb.com/banners/episodes/70851/25334.jpg</thumb>
+  <watched>false</watched>
+  <rating>7.9</rating>
+</episodedetails>
diff --git a/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Season 01.nfo b/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Season 01.nfo
new file mode 100644
index 000000000..91f0392f4
--- /dev/null
+++ b/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Season 01.nfo
@@ -0,0 +1,86 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes"?>
+<season>
+  <plot />
+  <outline />
+  <lockdata>false</lockdata>
+  <dateadded>2020-06-14 17:26:51</dateadded>
+  <title>Season 1</title>
+  <year>2019</year>
+  <tvdbid>359728</tvdbid>
+  <premiered>2019-11-08</premiered>
+  <releasedate>2019-11-08</releasedate>
+  <art>
+    <poster>/media/Serien/High School Musical The Musical The Series (2019)/Season 1/Season 1.jpeg</poster>
+  </art>
+  <actor>
+    <name>Olivia Rodrigo</name>
+    <role>Nini</role>
+    <type>Actor</type>
+    <sortorder>0</sortorder>
+    <thumb>/config/metadata/People/O/Olivia Rodrigo/poster.jpg</thumb>
+  </actor>
+  <actor>
+    <name>Kate Reinders</name>
+    <role>Miss Jenn</role>
+    <type>Actor</type>
+    <sortorder>1</sortorder>
+    <thumb>/config/metadata/People/K/Kate Reinders/poster.jpg</thumb>
+  </actor>
+  <actor>
+    <name>Sofia Wylie</name>
+    <role>Gina</role>
+    <type>Actor</type>
+    <sortorder>2</sortorder>
+    <thumb>/config/metadata/People/S/Sofia Wylie/poster.jpg</thumb>
+  </actor>
+  <actor>
+    <name>Matt Cornett</name>
+    <role>E.J.</role>
+    <type>Actor</type>
+    <sortorder>3</sortorder>
+    <thumb>/config/metadata/People/M/Matt Cornett/poster.jpg</thumb>
+  </actor>
+  <actor>
+    <name>Dara Reneé</name>
+    <role>Kourtney</role>
+    <type>Actor</type>
+    <sortorder>4</sortorder>
+    <thumb>/config/metadata/People/D/Dara Reneé/poster.jpg</thumb>
+  </actor>
+  <actor>
+    <name>Julia Lester</name>
+    <role>Ashlyn</role>
+    <type>Actor</type>
+    <sortorder>5</sortorder>
+    <thumb>/config/metadata/People/J/Julia Lester/poster.jpg</thumb>
+  </actor>
+  <actor>
+    <name>Joshua Bassett</name>
+    <role>Ricky</role>
+    <type>Actor</type>
+    <sortorder>6</sortorder>
+    <thumb>/config/metadata/People/J/Joshua Bassett/poster.jpg</thumb>
+  </actor>
+  <actor>
+    <name>Frankie A. Rodriguez</name>
+    <role>Carlos</role>
+    <type>Actor</type>
+    <sortorder>7</sortorder>
+    <thumb>/config/metadata/People/F/Frankie A. Rodriguez/poster.jpg</thumb>
+  </actor>
+  <actor>
+    <name>Larry Saperstein</name>
+    <role>Big Red</role>
+    <type>Actor</type>
+    <sortorder>8</sortorder>
+    <thumb>/config/metadata/People/L/Larry Saperstein/poster.jpg</thumb>
+  </actor>
+  <actor>
+    <name>Mark St. Cyr</name>
+    <role>Mr. Mazzara</role>
+    <type>Actor</type>
+    <sortorder>9</sortorder>
+    <thumb>/config/metadata/People/M/Mark St. Cyr/poster.jpg</thumb>
+  </actor>
+  <seasonnumber>1</seasonnumber>
+</season>
diff --git a/tests/Jellyfin.XbmcMetadata.Tests/Test Data/The Best of 1980-1990.nfo b/tests/Jellyfin.XbmcMetadata.Tests/Test Data/The Best of 1980-1990.nfo
new file mode 100644
index 000000000..4ab8400d3
--- /dev/null
+++ b/tests/Jellyfin.XbmcMetadata.Tests/Test Data/The Best of 1980-1990.nfo
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<album>
+    <title>The Best of 1980-1990</title>
+    <musicbrainzalbumid>59b5a40b-e2fd-3f18-a218-e8c9aae12ab5</musicbrainzalbumid>
+    <musicbrainzreleasegroupid>6c301dbd-6ccb-3403-a6c4-6a22240a0297</musicbrainzreleasegroupid>
+    <scrapedmbid>false</scrapedmbid>
+    <artistdesc>U2</artistdesc>
+    <genre>Pop</genre>
+    <style>Rock/Pop</style>
+    <mood>Political</mood>
+    <compilation>false</compilation>
+    <review>The Best of 1980-1990 is the first greatest hits compilation by Irish rock band U2, released in November 1998. It mostly contains the group&apos;s hit singles from the eighties but also mixes in some live staples as well as one new recording, Sweetest Thing. In April 1999, a companion video (featuring music videos and live footage) was released. The album was followed by another compilation, The Best of 1990-2000, in 2002.&#x0A;A limited edition version containing a special B-sides disc was released on the same date as the single-disc version. At the time of release, the official word was that the 2-disc album would be available the first week the album went on sale, then pulled from the stores. While this threat never materialized, it did result in the 2-disc version being in very high demand. Both versions charted in the Billboard 200.&#x0A;The boy on the cover is Peter Rowan, brother of Bono&apos;s friend Guggi (real name Derek Rowan) of the Virgin Prunes. He also appears on the covers of the early EP Three, two of the band&apos;s first three albums (Boy and War), and Early Demos.</review>
+    <type>album / compilation</type>
+    <releasedate></releasedate>
+    <label>Island</label>
+    <thumb preview="https://assets.fanart.tv/preview/music/a3cb23fc-acd3-4ce0-8f36-1e5aa6a18432/albumcover/the-best-of-1980-1990-4e43a22cab023.jpg">https://assets.fanart.tv/fanart/music/a3cb23fc-acd3-4ce0-8f36-1e5aa6a18432/albumcover/the-best-of-1980-1990-4e43a22cab023.jpg</thumb>
+    <thumb preview="https://assets.fanart.tv/preview/music/a3cb23fc-acd3-4ce0-8f36-1e5aa6a18432/albumcover/the-best-of-1980-1990-5bc4301068645.jpg">https://assets.fanart.tv/fanart/music/a3cb23fc-acd3-4ce0-8f36-1e5aa6a18432/albumcover/the-best-of-1980-1990-5bc4301068645.jpg</thumb>
+    <thumb preview="https://www.theaudiodb.com/images/media/album/thumb/the-best-of-1980-1990-4e43a22cab023.jpg/preview">https://www.theaudiodb.com/images/media/album/thumb/the-best-of-1980-1990-4e43a22cab023.jpg</thumb>
+    <path>C:\KODI\Test- Music\U2\Best Of 1980-1990, The\</path>
+    <rating max="10">-1.000000</rating>
+    <userrating max="10">-1</userrating>
+    <votes>-1</votes>
+    <year>1989</year>
+    <albumArtistCredits>
+        <artist>U2</artist>
+        <musicBrainzArtistID>a3cb23fc-acd3-4ce0-8f36-1e5aa6a18432</musicBrainzArtistID>
+    </albumArtistCredits>
+    <releasetype>album</releasetype>
+</album>
diff --git a/tests/Jellyfin.XbmcMetadata.Tests/Test Data/The Bone Orchard.nfo b/tests/Jellyfin.XbmcMetadata.Tests/Test Data/The Bone Orchard.nfo
new file mode 100644
index 000000000..cd275e4cf
--- /dev/null
+++ b/tests/Jellyfin.XbmcMetadata.Tests/Test Data/The Bone Orchard.nfo
@@ -0,0 +1,116 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<episodedetails>
+    <title>The Bone Orchard</title>
+    <showtitle>American Gods</showtitle>
+    <ratings>
+        <rating name="tmdb" max="10" default="true">
+            <value>7.532000</value>
+            <votes>31</votes>
+        </rating>
+    </ratings>
+    <userrating>0</userrating>
+    <top250>0</top250>
+    <season>1</season>
+    <episode>1</episode>
+    <displayseason>-1</displayseason>
+    <displayepisode>-1</displayepisode>
+    <episodenumberend>1</episodenumberend>
+    <airsbefore_episode>1</airsbefore_episode>
+    <airsafter_season>2</airsafter_season>
+    <airsbefore_season>3</airsbefore_season>
+    <outline></outline>
+    <plot>When Shadow Moon is released from prison early after the death of his wife, he meets Mr. Wednesday and is recruited as his bodyguard. Shadow discovers that this may be more than he bargained for.</plot>
+    <tagline></tagline>
+    <runtime>0</runtime>
+    <thumb>http://image.tmdb.org/t/p/original/uvry4weK00pFLn7fxQ9M4m3Da2A.jpg</thumb>
+    <mpaa>16</mpaa>
+    <playcount>0</playcount>
+    <lastplayed></lastplayed>
+    <id>1276153</id>
+    <uniqueid type="tmdb" default="true">1276153</uniqueid>
+    <imdbId>tt5017734</imdbId>
+    <genre>Drama</genre>
+    <genre>Mystery</genre>
+    <genre>Sci-Fi &amp; Fantasy</genre>
+    <credits>Bryan Fuller</credits>
+    <credits>Michael Green</credits>
+    <director>David Slade</director>
+    <premiered>2017-04-30</premiered>
+    <year>2017</year>
+    <status></status>
+    <code></code>
+    <aired>2017-04-30</aired>
+    <studio>Starz</studio>
+    <trailer></trailer>
+    <actor>
+        <name>Jonathan Tucker</name>
+        <role>&apos;Low Key&apos; Lyesmith</role>
+        <order>10</order>
+        <thumb>http://image.tmdb.org/t/p/original/jvJpYDbwmUTACw7Yn7PKOP6CdlJ.jpg</thumb>
+    </actor>
+    <actor>
+        <name>Demore Barnes</name>
+        <role>Mr. Ibis</role>
+        <order>11</order>
+        <thumb>http://image.tmdb.org/t/p/original/4rEVzSIFPgiN14xYQnjKcKQ7tYE.jpg</thumb>
+    </actor>
+    <actor>
+        <name>Betty Gilpin</name>
+        <role>Audrey</role>
+        <order>12</order>
+        <thumb>http://image.tmdb.org/t/p/original/xFeqyem5i4Kf0nFjBZ4Oi9NM26k.jpg</thumb>
+    </actor>
+    <actor>
+        <name>Beth Grant</name>
+        <role>Jack</role>
+        <order>13</order>
+        <thumb>http://image.tmdb.org/t/p/original/zAT9GvzJE0ytL3C36L461cgKI9p.jpg</thumb>
+    </actor>
+    <actor>
+        <name>Joel Murray</name>
+        <role>Paunch</role>
+        <order>14</order>
+        <thumb>http://image.tmdb.org/t/p/original/t5syYfCgxbTC7XPrNeXhhhQULUf.jpg</thumb>
+    </actor>
+    <actor>
+        <name>Ricky Whittle</name>
+        <role>Shadow Moon</role>
+        <order>0</order>
+        <thumb>http://image.tmdb.org/t/p/original/cjeDbVfBp6Qvb3C74Dfy7BKDTQN.jpg</thumb>
+    </actor>
+    <actor>
+        <name>Ian McShane</name>
+        <role>Mr. Wednesday</role>
+        <order>1</order>
+        <thumb>http://image.tmdb.org/t/p/original/pY9ud4BJwHekNiO4MMItPbgkdAy.jpg</thumb>
+    </actor>
+    <actor>
+        <name>Emily Browning</name>
+        <role>Laura Moon</role>
+        <order>2</order>
+        <thumb>http://image.tmdb.org/t/p/original/fa1Kyj02wxwcdS6EHb2i27TNXvU.jpg</thumb>
+    </actor>
+    <actor>
+        <name>Pablo Schreiber</name>
+        <role>Mad Sweeney</role>
+        <order>3</order>
+        <thumb>http://image.tmdb.org/t/p/original/uo8YljeePz3pbj7gvWXdB4gOOW4.jpg</thumb>
+    </actor>
+    <actor>
+        <name>Bruce Langley</name>
+        <role>Technical Boy</role>
+        <order>4</order>
+        <thumb>http://image.tmdb.org/t/p/original/f4EOWUmznLqboq8Ce7jnlkHVK3Y.jpg</thumb>
+    </actor>
+    <actor>
+        <name>Yetide Badaki</name>
+        <role>Bilquis</role>
+        <order>5</order>
+        <thumb>http://image.tmdb.org/t/p/original/qfzkREHuI1JvMxBteIAjKX8qMEr.jpg</thumb>
+    </actor>
+    <resume>
+        <position>0.000000</position>
+        <total>0.000000</total>
+    </resume>
+    <dateadded>2017-10-07 14:25:47</dateadded>
+</episodedetails>
diff --git a/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Tmdb.nfo b/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Tmdb.nfo
new file mode 100644
index 000000000..15af71852
--- /dev/null
+++ b/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Tmdb.nfo
@@ -0,0 +1 @@
+https://www.themoviedb.org/movie/30287-fallo
diff --git a/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Tvdb.nfo b/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Tvdb.nfo
new file mode 100644
index 000000000..9de69f8e1
--- /dev/null
+++ b/tests/Jellyfin.XbmcMetadata.Tests/Test Data/Tvdb.nfo
@@ -0,0 +1 @@
+https://www.thetvdb.com/?tab=series&id=121361