Merge branch 'master' into feat/book-persons

3 files changed, 165 insertions, 18 deletions

diff --git a/tests/Jellyfin.Api.Tests/Controllers/UserControllerTests.cs b/tests/Jellyfin.Api.Tests/Controllers/UserControllerTests.cs
new file mode 100644
index 0000000000..3f965d0ff0
--- /dev/null
+++ b/tests/Jellyfin.Api.Tests/Controllers/UserControllerTests.cs
@@ -0,0 +1,120 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Threading.Tasks;
+using AutoFixture.Xunit2;
+using Jellyfin.Api.Controllers;
+using Jellyfin.Data.Entities;
+using MediaBrowser.Common.Net;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Devices;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Net;
+using MediaBrowser.Controller.Playlists;
+using MediaBrowser.Controller.QuickConnect;
+using MediaBrowser.Controller.Session;
+using MediaBrowser.Model.Users;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using Moq;
+using Nikse.SubtitleEdit.Core.Common;
+using Xunit;
+
+namespace Jellyfin.Api.Tests.Controllers;
+
+public class UserControllerTests
+{
+    private readonly UserController _subject;
+    private readonly Mock<IUserManager> _mockUserManager;
+    private readonly Mock<ISessionManager> _mockSessionManager;
+    private readonly Mock<INetworkManager> _mockNetworkManager;
+    private readonly Mock<IDeviceManager> _mockDeviceManager;
+    private readonly Mock<IAuthorizationContext> _mockAuthorizationContext;
+    private readonly Mock<IServerConfigurationManager> _mockServerConfigurationManager;
+    private readonly Mock<ILogger<UserController>> _mockLogger;
+    private readonly Mock<IQuickConnect> _mockQuickConnect;
+    private readonly Mock<IPlaylistManager> _mockPlaylistManager;
+
+    public UserControllerTests()
+    {
+        _mockUserManager = new Mock<IUserManager>();
+        _mockSessionManager = new Mock<ISessionManager>();
+        _mockNetworkManager = new Mock<INetworkManager>();
+        _mockDeviceManager = new Mock<IDeviceManager>();
+        _mockAuthorizationContext = new Mock<IAuthorizationContext>();
+        _mockServerConfigurationManager = new Mock<IServerConfigurationManager>();
+        _mockLogger = new Mock<ILogger<UserController>>();
+        _mockQuickConnect = new Mock<IQuickConnect>();
+        _mockPlaylistManager = new Mock<IPlaylistManager>();
+
+        _subject = new UserController(
+            _mockUserManager.Object,
+            _mockSessionManager.Object,
+            _mockNetworkManager.Object,
+            _mockDeviceManager.Object,
+            _mockAuthorizationContext.Object,
+            _mockServerConfigurationManager.Object,
+            _mockLogger.Object,
+            _mockQuickConnect.Object,
+            _mockPlaylistManager.Object);
+    }
+
+    [Theory]
+    [AutoData]
+    public async Task UpdateUserPolicy_WhenUserNotFound_ReturnsNotFound(Guid userId, UserPolicy userPolicy)
+    {
+        User? nullUser = null;
+        _mockUserManager.
+            Setup(m => m.GetUserById(userId))
+            .Returns(nullUser);
+
+        Assert.IsType<NotFoundResult>(await _subject.UpdateUserPolicy(userId, userPolicy));
+    }
+
+    [Theory]
+    [InlineAutoData(null)]
+    [InlineAutoData("")]
+    [InlineAutoData("   ")]
+    public void UpdateUserPolicy_WhenPasswordResetProviderIdNotSupplied_ReturnsBadRequest(string? passwordResetProviderId)
+    {
+        var userPolicy = new UserPolicy
+        {
+            PasswordResetProviderId = passwordResetProviderId,
+            AuthenticationProviderId = "AuthenticationProviderId"
+        };
+
+        Assert.Contains(
+            Validate(userPolicy), v =>
+                v.MemberNames.Contains("PasswordResetProviderId") &&
+                v.ErrorMessage != null &&
+                v.ErrorMessage.Contains("required", StringComparison.CurrentCultureIgnoreCase));
+    }
+
+    [Theory]
+    [InlineAutoData(null)]
+    [InlineAutoData("")]
+    [InlineAutoData("   ")]
+    public void UpdateUserPolicy_WhenAuthenticationProviderIdNotSupplied_ReturnsBadRequest(string? authenticationProviderId)
+    {
+        var userPolicy = new UserPolicy
+        {
+            AuthenticationProviderId = authenticationProviderId,
+            PasswordResetProviderId = "PasswordResetProviderId"
+        };
+
+        Assert.Contains(Validate(userPolicy), v =>
+            v.MemberNames.Contains("AuthenticationProviderId") &&
+            v.ErrorMessage != null &&
+            v.ErrorMessage.Contains("required", StringComparison.CurrentCultureIgnoreCase));
+    }
+
+    private IList<ValidationResult> Validate(object model)
+    {
+        var result = new List<ValidationResult>();
+        var context = new ValidationContext(model, null, null);
+        Validator.TryValidateObject(model, context, result, true);
+
+        return result;
+    }
+}
diff --git a/tests/Jellyfin.Api.Tests/Helpers/RequestHelpersTests.cs b/tests/Jellyfin.Api.Tests/Helpers/RequestHelpersTests.cs
index 2d7741d81a..a2d1b3607b 100644
--- a/tests/Jellyfin.Api.Tests/Helpers/RequestHelpersTests.cs
+++ b/tests/Jellyfin.Api.Tests/Helpers/RequestHelpersTests.cs
@@ -14,7 +14,7 @@ namespace Jellyfin.Api.Tests.Helpers
     {
         [Theory]
         [MemberData(nameof(GetOrderBy_Success_TestData))]
-        public static void GetOrderBy_Success(IReadOnlyList<string> sortBy, IReadOnlyList<SortOrder> requestedSortOrder, (string, SortOrder)[] expected)
+        public static void GetOrderBy_Success(IReadOnlyList<ItemSortBy> sortBy, IReadOnlyList<SortOrder> requestedSortOrder, (ItemSortBy, SortOrder)[] expected)
         {
             Assert.Equal(expected, RequestHelpers.GetOrderBy(sortBy, requestedSortOrder));
         }
@@ -95,42 +95,42 @@ namespace Jellyfin.Api.Tests.Helpers
             Assert.Throws<SecurityException>(() => RequestHelpers.GetUserId(principal, requestUserId));
         }
 
-        public static TheoryData<IReadOnlyList<string>, IReadOnlyList<SortOrder>, (string, SortOrder)[]> GetOrderBy_Success_TestData()
+        public static TheoryData<IReadOnlyList<ItemSortBy>, IReadOnlyList<SortOrder>, (ItemSortBy, SortOrder)[]> GetOrderBy_Success_TestData()
         {
-            var data = new TheoryData<IReadOnlyList<string>, IReadOnlyList<SortOrder>, (string, SortOrder)[]>();
+            var data = new TheoryData<IReadOnlyList<ItemSortBy>, IReadOnlyList<SortOrder>, (ItemSortBy, SortOrder)[]>();
 
             data.Add(
-                Array.Empty<string>(),
+                Array.Empty<ItemSortBy>(),
                 Array.Empty<SortOrder>(),
-                Array.Empty<(string, SortOrder)>());
+                Array.Empty<(ItemSortBy, SortOrder)>());
 
             data.Add(
-                new string[]
+                new[]
                 {
-                    "IsFavoriteOrLiked",
-                    "Random"
+                    ItemSortBy.IsFavoriteOrLiked,
+                    ItemSortBy.Random
                 },
                 Array.Empty<SortOrder>(),
-                new (string, SortOrder)[]
+                new (ItemSortBy, SortOrder)[]
                 {
-                    ("IsFavoriteOrLiked", SortOrder.Ascending),
-                    ("Random", SortOrder.Ascending),
+                    (ItemSortBy.IsFavoriteOrLiked, SortOrder.Ascending),
+                    (ItemSortBy.Random, SortOrder.Ascending),
                 });
 
             data.Add(
-                new string[]
+                new[]
                 {
-                    "SortName",
-                    "ProductionYear"
+                    ItemSortBy.SortName,
+                    ItemSortBy.ProductionYear
                 },
-                new SortOrder[]
+                new[]
                 {
                     SortOrder.Descending
                 },
-                new (string, SortOrder)[]
+                new (ItemSortBy, SortOrder)[]
                 {
-                    ("SortName", SortOrder.Descending),
-                    ("ProductionYear", SortOrder.Descending),
+                    (ItemSortBy.SortName, SortOrder.Descending),
+                    (ItemSortBy.ProductionYear, SortOrder.Descending),
                 });
 
             return data;
diff --git a/tests/Jellyfin.Api.Tests/Middleware/UrlDecodeQueryFeatureTests.cs b/tests/Jellyfin.Api.Tests/Middleware/UrlDecodeQueryFeatureTests.cs
new file mode 100644
index 0000000000..1ff7e7b7a4
--- /dev/null
+++ b/tests/Jellyfin.Api.Tests/Middleware/UrlDecodeQueryFeatureTests.cs
@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.Features;
+using Microsoft.Extensions.Primitives;
+using Xunit;
+
+namespace Jellyfin.Api.Middleware.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.True(StringValues.IsNullOrEmpty(v));
+        }
+    }
+}