Merge branch 'master' into issue15137

7 files changed, 387 insertions, 23 deletions

diff --git a/tests/Jellyfin.Server.Implementations.Tests/Cryptography/CryptographyProviderTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Cryptography/CryptographyProviderTests.cs
new file mode 100644
index 000000000..052bdf740
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Cryptography/CryptographyProviderTests.cs
@@ -0,0 +1,102 @@
+using System;
+using Emby.Server.Implementations.Cryptography;
+using MediaBrowser.Model.Cryptography;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.Cryptography;
+
+public class CryptographyProviderTests
+{
+    private readonly CryptographyProvider _sut = new();
+
+    [Fact]
+    public void CreatePasswordHash_WithPassword_ReturnsHashWithIterations()
+    {
+        var hash = _sut.CreatePasswordHash("testpassword");
+
+        Assert.Equal("PBKDF2-SHA512", hash.Id);
+        Assert.True(hash.Parameters.ContainsKey("iterations"));
+        Assert.NotEmpty(hash.Salt.ToArray());
+        Assert.NotEmpty(hash.Hash.ToArray());
+    }
+
+    [Fact]
+    public void Verify_WithValidPassword_ReturnsTrue()
+    {
+        const string password = "testpassword";
+        var hash = _sut.CreatePasswordHash(password);
+
+        Assert.True(_sut.Verify(hash, password));
+    }
+
+    [Fact]
+    public void Verify_WithWrongPassword_ReturnsFalse()
+    {
+        var hash = _sut.CreatePasswordHash("correctpassword");
+
+        Assert.False(_sut.Verify(hash, "wrongpassword"));
+    }
+
+    [Fact]
+    public void Verify_PBKDF2_MissingIterations_ThrowsFormatException()
+    {
+        var hash = PasswordHash.Parse("$PBKDF2$69F420$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D");
+
+        var exception = Assert.Throws<FormatException>(() => _sut.Verify(hash, "password"));
+        Assert.Contains("missing required 'iterations' parameter", exception.Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void Verify_PBKDF2SHA512_MissingIterations_ThrowsFormatException()
+    {
+        var hash = PasswordHash.Parse("$PBKDF2-SHA512$69F420$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D");
+
+        var exception = Assert.Throws<FormatException>(() => _sut.Verify(hash, "password"));
+        Assert.Contains("missing required 'iterations' parameter", exception.Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void Verify_PBKDF2_InvalidIterationsFormat_ThrowsFormatException()
+    {
+        var hash = PasswordHash.Parse("$PBKDF2$iterations=abc$69F420$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D");
+
+        var exception = Assert.Throws<FormatException>(() => _sut.Verify(hash, "password"));
+        Assert.Contains("invalid 'iterations' parameter", exception.Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void Verify_PBKDF2SHA512_InvalidIterationsFormat_ThrowsFormatException()
+    {
+        var hash = PasswordHash.Parse("$PBKDF2-SHA512$iterations=notanumber$69F420$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D");
+
+        var exception = Assert.Throws<FormatException>(() => _sut.Verify(hash, "password"));
+        Assert.Contains("invalid 'iterations' parameter", exception.Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void Verify_UnsupportedHashId_ThrowsNotSupportedException()
+    {
+        var hash = PasswordHash.Parse("$UNKNOWN$69F420$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D");
+
+        Assert.Throws<NotSupportedException>(() => _sut.Verify(hash, "password"));
+    }
+
+    [Fact]
+    public void GenerateSalt_ReturnsNonEmptyArray()
+    {
+        var salt = _sut.GenerateSalt();
+
+        Assert.NotEmpty(salt);
+    }
+
+    [Theory]
+    [InlineData(16)]
+    [InlineData(32)]
+    [InlineData(64)]
+    public void GenerateSalt_WithLength_ReturnsArrayOfSpecifiedLength(int length)
+    {
+        var salt = _sut.GenerateSalt(length);
+
+        Assert.Equal(length, salt.Length);
+    }
+}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Data/SearchPunctuationTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Data/SearchPunctuationTests.cs
new file mode 100644
index 000000000..8fbccd801
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Data/SearchPunctuationTests.cs
@@ -0,0 +1,109 @@
+using System;
+using AutoFixture;
+using AutoFixture.AutoMoq;
+using Jellyfin.Server.Implementations.Item;
+using MediaBrowser.Controller.Entities.TV;
+using Microsoft.Extensions.Configuration;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.Data
+{
+    public class SearchPunctuationTests
+    {
+        private readonly IFixture _fixture;
+        private readonly BaseItemRepository _repo;
+
+        public SearchPunctuationTests()
+        {
+            var appHost = new Mock<MediaBrowser.Controller.IServerApplicationHost>();
+            appHost.Setup(x => x.ExpandVirtualPath(It.IsAny<string>()))
+                .Returns((string x) => x);
+            appHost.Setup(x => x.ReverseVirtualPath(It.IsAny<string>()))
+                .Returns((string x) => x);
+
+            var configSection = new Mock<IConfigurationSection>();
+            configSection
+                .SetupGet(x => x[It.Is<string>(s => s == MediaBrowser.Controller.Extensions.ConfigurationExtensions.SqliteCacheSizeKey)])
+                .Returns("0");
+            var config = new Mock<IConfiguration>();
+            config
+                .Setup(x => x.GetSection(It.Is<string>(s => s == MediaBrowser.Controller.Extensions.ConfigurationExtensions.SqliteCacheSizeKey)))
+                .Returns(configSection.Object);
+
+            _fixture = new Fixture().Customize(new AutoMoqCustomization { ConfigureMembers = true });
+            _fixture.Inject(appHost.Object);
+            _fixture.Inject(config.Object);
+
+            _repo = _fixture.Create<BaseItemRepository>();
+        }
+
+        [Fact]
+        public void CleanName_keeps_punctuation_and_search_without_punctuation_passes()
+        {
+            var series = new Series
+            {
+                Id = Guid.NewGuid(),
+                Name = "Mr. Robot"
+            };
+
+            series.SortName = "Mr. Robot";
+
+            var entity = _repo.Map(series);
+            Assert.Equal("mr robot", entity.CleanName);
+
+            var searchTerm = "Mr Robot".ToLowerInvariant();
+
+            Assert.Contains(searchTerm, entity.CleanName ?? string.Empty, StringComparison.OrdinalIgnoreCase);
+        }
+
+        [Theory]
+        [InlineData("Spider-Man: Homecoming", "spider man homecoming")]
+        [InlineData("Beyoncé — Live!", "beyonce live")]
+        [InlineData("Hello, World!", "hello world")]
+        [InlineData("(The) Good, the Bad & the Ugly", "the good the bad the ugly")]
+        [InlineData("Wall-E", "wall e")]
+        [InlineData("No. 1: The Beginning", "no 1 the beginning")]
+        [InlineData("Café-au-lait", "cafe au lait")]
+        public void CleanName_normalizes_various_punctuation(string title, string expectedClean)
+        {
+            var series = new Series
+            {
+                Id = Guid.NewGuid(),
+                Name = title
+            };
+
+            series.SortName = title;
+
+            var entity = _repo.Map(series);
+
+            Assert.Equal(expectedClean, entity.CleanName);
+
+            // Ensure a search term without punctuation would match
+            var searchTerm = expectedClean;
+            Assert.Contains(searchTerm, entity.CleanName ?? string.Empty, StringComparison.OrdinalIgnoreCase);
+        }
+
+        [Theory]
+        [InlineData("Face/Off", "face off")]
+        [InlineData("V/H/S", "v h s")]
+        public void CleanName_normalizes_titles_withslashes(string title, string expectedClean)
+        {
+            var series = new Series
+            {
+                Id = Guid.NewGuid(),
+                Name = title
+            };
+
+            series.SortName = title;
+
+            var entity = _repo.Map(series);
+
+            Assert.Equal(expectedClean, entity.CleanName);
+
+            // Ensure a search term without punctuation would match
+            var searchTerm = expectedClean;
+            Assert.Contains(searchTerm, entity.CleanName ?? string.Empty, StringComparison.OrdinalIgnoreCase);
+        }
+    }
+}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Item/BaseItemRepositoryTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Item/BaseItemRepositoryTests.cs
new file mode 100644
index 000000000..c450cbb0e
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Item/BaseItemRepositoryTests.cs
@@ -0,0 +1,72 @@
+using System;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Server.Implementations.Item;
+using MediaBrowser.Controller;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.Item;
+
+public class BaseItemRepositoryTests
+{
+    [Fact]
+    public void DeserializeBaseItem_WithUnknownType_ReturnsNull()
+    {
+        // Arrange
+        var entity = new BaseItemEntity
+        {
+            Id = Guid.NewGuid(),
+            Type = "NonExistent.Plugin.CustomItemType"
+        };
+
+        // Act
+        var result = BaseItemRepository.DeserializeBaseItem(entity, NullLogger.Instance, null, false);
+
+        // Assert
+        Assert.Null(result);
+    }
+
+    [Fact]
+    public void DeserializeBaseItem_WithUnknownType_LogsWarning()
+    {
+        // Arrange
+        var entity = new BaseItemEntity
+        {
+            Id = Guid.NewGuid(),
+            Type = "NonExistent.Plugin.CustomItemType"
+        };
+        var loggerMock = new Mock<ILogger>();
+
+        // Act
+        BaseItemRepository.DeserializeBaseItem(entity, loggerMock.Object, null, false);
+
+        // Assert
+        loggerMock.Verify(
+            x => x.Log(
+                LogLevel.Warning,
+                It.IsAny<EventId>(),
+                It.Is<It.IsAnyType>((v, t) => v.ToString()!.Contains("unknown type", StringComparison.OrdinalIgnoreCase)),
+                It.IsAny<Exception?>(),
+                It.IsAny<Func<It.IsAnyType, Exception?, string>>()),
+            Times.Once);
+    }
+
+    [Fact]
+    public void DeserializeBaseItem_WithKnownType_ReturnsItem()
+    {
+        // Arrange
+        var entity = new BaseItemEntity
+        {
+            Id = Guid.NewGuid(),
+            Type = "MediaBrowser.Controller.Entities.Movies.Movie"
+        };
+
+        // Act
+        var result = BaseItemRepository.DeserializeBaseItem(entity, NullLogger.Instance, null, false);
+
+        // Assert
+        Assert.NotNull(result);
+    }
+}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Item/OrderMapperTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Item/OrderMapperTests.cs
index caf2b06b7..8ac3e5e31 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Item/OrderMapperTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Item/OrderMapperTests.cs
@@ -12,7 +12,7 @@ public class OrderMapperTests
     [Fact]
     public void ShouldReturnMappedOrderForSortingByPremierDate()
     {
-        var orderFunc = OrderMapper.MapOrderByField(ItemSortBy.PremiereDate, new InternalItemsQuery()).Compile();
+        var orderFunc = OrderMapper.MapOrderByField(ItemSortBy.PremiereDate, new InternalItemsQuery(), null!).Compile();
 
         var expectedDate = new DateTime(1, 2, 3);
         var expectedProductionYearDate = new DateTime(4, 1, 1);
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/DotIgnoreIgnoreRuleTest.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/DotIgnoreIgnoreRuleTest.cs
index d677c9f09..a7bbef7ed 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Library/DotIgnoreIgnoreRuleTest.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/DotIgnoreIgnoreRuleTest.cs
@@ -1,30 +1,81 @@
+using Emby.Server.Implementations.Library;
 using Xunit;
 
 namespace Jellyfin.Server.Implementations.Tests.Library;
 
 public class DotIgnoreIgnoreRuleTest
 {
-    [Fact]
-    public void Test()
+    private static readonly string[] _rule1 = ["SPs"];
+    private static readonly string[] _rule2 = ["SPs", "!thebestshot.mkv"];
+    private static readonly string[] _rule3 = ["*.txt", @"{\colortbl;\red255\green255\blue255;}", "videos/", @"\invalid\escape\sequence", "*.mkv"];
+    private static readonly string[] _rule4 = [@"{\colortbl;\red255\green255\blue255;}", @"\invalid\escape\sequence"];
+
+    public static TheoryData<string[], string, bool, bool> CheckIgnoreRulesTestData =>
+        new()
+        {
+            // Basic pattern matching
+            { _rule1, "f:/cd/sps/ffffff.mkv", false, true },
+            { _rule1, "cd/sps/ffffff.mkv", false, true },
+            { _rule1, "/cd/sps/ffffff.mkv", false, true },
+
+            // Negate pattern
+            { _rule2, "f:/cd/sps/ffffff.mkv", false, true },
+            { _rule2, "cd/sps/ffffff.mkv", false, true },
+            { _rule2, "/cd/sps/ffffff.mkv", false, true },
+            { _rule2, "f:/cd/sps/thebestshot.mkv", false, false },
+            { _rule2, "cd/sps/thebestshot.mkv", false, false },
+            { _rule2, "/cd/sps/thebestshot.mkv", false, false },
+
+            // Mixed valid and invalid patterns - skips invalid, applies valid
+            { _rule3, "test.txt", false, true },
+            { _rule3, "videos/movie.mp4", false, true },
+            { _rule3, "movie.mkv", false, true },
+            { _rule3, "test.mp3", false, false },
+
+            // Only invalid patterns - falls back to ignore all
+            { _rule4, "any-file.txt", false, true },
+            { _rule4, "any/path/to/file.mkv", false, true },
+        };
+
+    public static TheoryData<string[], string, bool, bool> WindowsPathNormalizationTestData =>
+        new()
+        {
+            // Windows paths with backslashes - should match when normalizePath is true
+            { _rule1, @"C:\cd\sps\ffffff.mkv", false, true },
+            { _rule1, @"D:\media\sps\movie.mkv", false, true },
+            { _rule1, @"\\server\share\sps\file.mkv", false, true },
+
+            // Negate pattern with Windows paths
+            { _rule2, @"C:\cd\sps\ffffff.mkv", false, true },
+            { _rule2, @"C:\cd\sps\thebestshot.mkv", false, false },
+
+            // Directory matching with Windows paths
+            { _rule3, @"C:\videos\movie.mp4", false, true },
+            { _rule3, @"D:\documents\test.txt", false, true },
+            { _rule3, @"E:\music\song.mp3", false, false },
+        };
+
+    [Theory]
+    [MemberData(nameof(CheckIgnoreRulesTestData))]
+    public void CheckIgnoreRules_ReturnsExpectedResult(string[] rules, string path, bool isDirectory, bool expectedIgnored)
+    {
+        Assert.Equal(expectedIgnored, DotIgnoreIgnoreRule.CheckIgnoreRules(path, rules, isDirectory));
+    }
+
+    [Theory]
+    [MemberData(nameof(WindowsPathNormalizationTestData))]
+    public void CheckIgnoreRules_WithWindowsPaths_NormalizesBackslashes(string[] rules, string path, bool isDirectory, bool expectedIgnored)
     {
-        var ignore = new Ignore.Ignore();
-        ignore.Add("SPs");
-        Assert.True(ignore.IsIgnored("f:/cd/sps/ffffff.mkv"));
-        Assert.True(ignore.IsIgnored("cd/sps/ffffff.mkv"));
-        Assert.True(ignore.IsIgnored("/cd/sps/ffffff.mkv"));
+        // With normalizePath=true, backslashes should be converted to forward slashes
+        Assert.Equal(expectedIgnored, DotIgnoreIgnoreRule.CheckIgnoreRules(path, rules, isDirectory, normalizePath: true));
     }
 
-    [Fact]
-    public void TestNegatePattern()
+    [Theory]
+    [InlineData(@"C:\cd\sps\ffffff.mkv")]
+    [InlineData(@"D:\media\sps\movie.mkv")]
+    public void CheckIgnoreRules_WithWindowsPaths_WithoutNormalization_DoesNotMatch(string path)
     {
-        var ignore = new Ignore.Ignore();
-        ignore.Add("SPs");
-        ignore.Add("!thebestshot.mkv");
-        Assert.True(ignore.IsIgnored("f:/cd/sps/ffffff.mkv"));
-        Assert.True(ignore.IsIgnored("cd/sps/ffffff.mkv"));
-        Assert.True(ignore.IsIgnored("/cd/sps/ffffff.mkv"));
-        Assert.True(!ignore.IsIgnored("f:/cd/sps/thebestshot.mkv"));
-        Assert.True(!ignore.IsIgnored("cd/sps/thebestshot.mkv"));
-        Assert.True(!ignore.IsIgnored("/cd/sps/thebestshot.mkv"));
+        // Without normalization, Windows paths with backslashes won't match patterns expecting forward slashes
+        Assert.False(DotIgnoreIgnoreRule.CheckIgnoreRules(path, _rule1, isDirectory: false, normalizePath: false));
     }
 }
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/PathExtensionsTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/PathExtensionsTests.cs
index 940e3c2b1..650d67b19 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Library/PathExtensionsTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/PathExtensionsTests.cs
@@ -11,21 +11,29 @@ namespace Jellyfin.Server.Implementations.Tests.Library
         [InlineData("Superman: Red Son [imdbid=tt10985510]", "imdbid", "tt10985510")]
         [InlineData("Superman: Red Son [imdbid-tt10985510]", "imdbid", "tt10985510")]
         [InlineData("Superman: Red Son - tt10985510", "imdbid", "tt10985510")]
+        [InlineData("Superman: Red Son {imdbid=tt10985510}", "imdbid", "tt10985510")]
+        [InlineData("Superman: Red Son (imdbid-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 [imdbid1-tt11111111][imdbid=tt10985510]", "imdbid", "tt10985510")]
+        [InlineData("Superman: Red Son {imdbid1=tt11111111}(imdbid=tt10985510)", "imdbid", "tt10985510")]
+        [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]", "imdbid", "tt10985510")]
-        [InlineData("Superman: Red Son [tmdbid-618355][imdbid-tt10985510]", "tmdbid", "618355")]
+        [InlineData("Superman: Red Son [tmdbid-618355]{imdbid-tt10985510}", "imdbid", "tt10985510")]
+        [InlineData("Superman: Red Son (tmdbid-618355)[imdbid-tt10985510]", "tmdbid", "618355")]
         [InlineData("Superman: Red Son [providera-id=1]", "providera-id", "1")]
         [InlineData("Superman: Red Son [providerb-id=2]", "providerb-id", "2")]
         [InlineData("Superman: Red Son [providera id=4]", "providera id", "4")]
         [InlineData("Superman: Red Son [providerb id=5]", "providerb id", "5")]
         [InlineData("Superman: Red Son [tmdbid=3]", "tmdbid", "3")]
         [InlineData("Superman: Red Son [tvdbid-6]", "tvdbid", "6")]
+        [InlineData("Superman: Red Son {tmdbid=3}", "tmdbid", "3")]
+        [InlineData("Superman: Red Son (tvdbid-6)", "tvdbid", "6")]
         [InlineData("[tmdbid=618355]", "tmdbid", "618355")]
+        [InlineData("{tmdbid=618355}", "tmdbid", "618355")]
+        [InlineData("(tmdbid=618355)", "tmdbid", "618355")]
         [InlineData("[tmdbid-618355]", "tmdbid", "618355")]
+        [InlineData("{tmdbid-618355)", "tmdbid", null)]
+        [InlineData("[tmdbid-618355}", "tmdbid", null)]
         [InlineData("tmdbid=111111][tmdbid=618355]", "tmdbid", "618355")]
         [InlineData("[tmdbid=618355]tmdbid=111111]", "tmdbid", "618355")]
         [InlineData("tmdbid=618355]", "tmdbid", null)]
@@ -36,6 +44,9 @@ namespace Jellyfin.Server.Implementations.Tests.Library
         [InlineData("[tmdbid=][imdbid=tt10985510]", "tmdbid", null)]
         [InlineData("[tmdbid-][imdbid-tt10985510]", "tmdbid", null)]
         [InlineData("Superman: Red Son [tmdbid-618355][tmdbid=1234567]", "tmdbid", "618355")]
+        [InlineData("{tmdbid=}{imdbid=tt10985510}", "tmdbid", null)]
+        [InlineData("(tmdbid-)(imdbid-tt10985510)", "tmdbid", null)]
+        [InlineData("Superman: Red Son {tmdbid-618355}{tmdbid=1234567}", "tmdbid", "618355")]
         public void GetAttributeValue_ValidArgs_Correct(string input, string attribute, string? expectedResult)
         {
             Assert.Equal(expectedResult, PathExtensions.GetAttributeValue(input, attribute));
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Localization/LocalizationManagerTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Localization/LocalizationManagerTests.cs
index 6d6bba4fc..e60522bf7 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Localization/LocalizationManagerTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Localization/LocalizationManagerTests.cs
@@ -204,6 +204,25 @@ namespace Jellyfin.Server.Implementations.Tests.Localization
         }
 
         [Theory]
+        [InlineData("TV-MA", "DE", 17, 1)] // US-only rating, DE country code
+        [InlineData("PG-13", "FR", 13, 0)] // US-only rating, FR country code
+        [InlineData("R", "JP", 17, 0)] // US-only rating, JP country code
+        public async Task GetRatingScore_FallbackPrioritizesUS_Success(string rating, string countryCode, int expectedScore, int? expectedSubScore)
+        {
+            var localizationManager = Setup(new ServerConfiguration()
+            {
+                MetadataCountryCode = countryCode
+            });
+            await localizationManager.LoadAll();
+
+            var score = localizationManager.GetRatingScore(rating);
+
+            Assert.NotNull(score);
+            Assert.Equal(expectedScore, score.Score);
+            Assert.Equal(expectedSubScore, score.SubScore);
+        }
+
+        [Theory]
         [InlineData("Default", "Default")]
         [InlineData("HeaderLiveTV", "Live TV")]
         public void GetLocalizedString_Valid_Success(string key, string expected)