Adding

2026-03-17 09:53:09 -05:00
parent cdcba54aa4
commit 1a0702a79a
590 changed files with 62058 additions and 0 deletions
@@ -0,0 +1,174 @@
+using LCU.API.Internal.Operations.IncentiveApi.Authorization;
+using LCU.API.Internal.Operations.IncentiveApiLib.Persistence;
+using LCU.API.Internal.Operations.IncentiveApiLib.Services;
+using LCU.Library.Internal.IncentiveApiModels.Entities;
+using Microsoft.AspNetCore.Authorization;
+using Moq;
+using NUnit.Framework;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace Application.UnitTests.Authorization
+{
+    public class WrappedPermissionAuthorizationHandler : PermissionAuthorizationHandler
+    {
+        public WrappedPermissionAuthorizationHandler(ICurrentUserService currentUserService, IUserService userService)
+            : base(currentUserService, userService)
+        {
+        }
+
+        public async Task WrappedHandleRequirementAsync(AuthorizationHandlerContext context, PermissionRequirement requirement)
+        {
+            await HandleRequirementAsync(context, requirement);
+        }
+    }
+
+    public class PermissionAuthorizationHandlerTest
+    {
+        private WrappedPermissionAuthorizationHandler _handler;
+        private Mock<ICurrentUserService> _mockCurrentUserService;
+        private Mock<IUserService> _mockUserService;
+
+        [SetUp]
+        public void Setup()
+        {
+            _mockUserService = new Mock<IUserService>();
+            _mockCurrentUserService = new Mock<ICurrentUserService>();
+            _handler = new WrappedPermissionAuthorizationHandler(_mockCurrentUserService.Object,
+                _mockUserService.Object);
+        }
+
+        [Test]
+        public async Task HandleAsync_MatchingPermission_ContextHasSucceeded()
+        {
+            var appUser = new ApplicationUser { Email = "[email protected]" };
+            var user = new AppUser {
+                Role = Role.OpsHelpDesk,
+                Departments = new List<UserDepartment>()
+                {
+                    new UserDepartment()
+                    {
+                        DepartmentId = 55,
+                        Role = Role.OpsHelpDesk
+                    }
+                }
+            };
+            _mockCurrentUserService.Setup(service => service.GetCurrentUser())
+                .Returns(appUser);
+
+            _mockUserService.Setup(service => service.UserHasAnyRequiredPermission(appUser.Email, It.IsAny<List<string>>()))
+                .ReturnsAsync(true);
+
+            var requirement = new PermissionRequirement("VIEW_DASHBOARD");
+            var requirements = new List<IAuthorizationRequirement> { requirement };
+
+            var _fakeContext = new AuthorizationHandlerContext(requirements, null, null);
+
+            await _handler.WrappedHandleRequirementAsync(_fakeContext, requirement);
+
+            Assert.True(_fakeContext.HasSucceeded);
+        }
+
+        [Test]
+        public async Task HandleAsync_MatchingAdditionalPermission_ContextHasSucceeded()
+        {
+            var appUser = new ApplicationUser { Email = "[email protected]" };
+            var user = new AppUser {
+                Role = Role.OpsHelpDesk,
+                AdditionalPermissions = new List<UserPermission>()
+                {
+                    new UserPermission()
+                    {
+                        Permission = Permission.ViewDashboard
+                    }
+                }
+            };
+            _mockCurrentUserService.Setup(service => service.GetCurrentUser())
+                .Returns(appUser);
+
+            _mockUserService.Setup(service => service.UserHasAnyRequiredPermission(appUser.Email, It.IsAny<List<string>>()))
+                .ReturnsAsync(true);
+
+            var requirement = new PermissionRequirement("VIEW_DASHBOARD");
+            var requirements = new List<IAuthorizationRequirement> { requirement };
+
+            var _fakeContext = new AuthorizationHandlerContext(requirements, null, null);
+
+            await _handler.WrappedHandleRequirementAsync(_fakeContext, requirement);
+
+            Assert.True(_fakeContext.HasSucceeded);
+        }
+
+        [Test]
+        public async Task HandleAsync_NoMatchingPermission_ContextHasFailed()
+        {
+            var appUser = new ApplicationUser { Email = "[email protected]" };
+            var user = new AppUser
+            {
+                Role = Role.OpsHelpDesk
+            };
+            _mockCurrentUserService.Setup(service => service.GetCurrentUser())
+                .Returns(appUser);
+
+            _mockUserService.Setup(service => service.GetUserByAdEmailAsync(appUser.Email))
+                .ReturnsAsync(user);
+
+            var requirement = new PermissionRequirement("NO_MATCH");
+            var requirements = new List<IAuthorizationRequirement> { requirement };
+            var _fakeContext = new AuthorizationHandlerContext(requirements, null, null);
+
+            await _handler.WrappedHandleRequirementAsync(_fakeContext, requirement);
+
+            Assert.True(_fakeContext.HasFailed);
+        }
+
+        [Test]
+        public async Task HandleAsync_NoApplicationUserEmail_ContextHasFailed()
+        {
+            var appUser = new ApplicationUser();
+            _mockCurrentUserService.Setup(service => service.GetCurrentUser())
+                .Returns(appUser);
+            var requirement = new PermissionRequirement("");
+            var requirements = new List<IAuthorizationRequirement> { requirement };
+            var _fakeContext = new AuthorizationHandlerContext(requirements, null, null);
+
+            await _handler.WrappedHandleRequirementAsync(_fakeContext, requirement);
+
+            Assert.True(_fakeContext.HasFailed);
+        }
+
+        [Test]
+        public async Task HandleAsync_NoUserFound_ContextHasFailed()
+        {
+            var appUser = new ApplicationUser { Email = "[email protected]" };
+            _mockCurrentUserService.Setup(service => service.GetCurrentUser())
+                .Returns(appUser);
+            _mockUserService.Setup(service => service.GetUserByAdEmailAsync(appUser.Email))
+                .ReturnsAsync((AppUser)null);
+            var requirement = new PermissionRequirement("");
+            var requirements = new List<IAuthorizationRequirement> { requirement };
+            var _fakeContext = new AuthorizationHandlerContext(requirements, null, null);
+
+            await _handler.WrappedHandleRequirementAsync(_fakeContext, requirement);
+
+            Assert.True(_fakeContext.HasFailed);
+        }
+
+        [Test]
+        public async Task HandleAsync_UserServiceException_ContextHasFailed()
+        {
+            var appUser = new ApplicationUser { Email = "[email protected]" };
+            _mockCurrentUserService.Setup(service => service.GetCurrentUser())
+                .Returns(appUser);
+            _mockUserService.Setup(service => service.GetUserByAdEmailAsync(appUser.Email))
+                .ThrowsAsync(new System.Exception("err"));
+            var requirement = new PermissionRequirement("");
+            var requirements = new List<IAuthorizationRequirement> { requirement };
+            var _fakeContext = new AuthorizationHandlerContext(requirements, null, null);
+
+            await _handler.WrappedHandleRequirementAsync(_fakeContext, requirement);
+
+            Assert.True(_fakeContext.HasFailed);
+        }
+    }
+}
@@ -0,0 +1,38 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.Extensions.Options;
+using NUnit.Framework;
+using System.Linq;
+using System.Threading.Tasks;
+using LCU.API.Internal.Operations.IncentiveApi.Authorization;
+
+namespace Application.UnitTests.Authorization
+{
+    public class PermissionPolicyProviderTest
+    {
+        private PermissionPolicyProvider _provider;
+
+        [SetUp]
+        public void Setup()
+        {
+            var options = Options.Create(new AuthorizationOptions());
+            _provider = new PermissionPolicyProvider(options);
+        }
+
+        [Test]
+        public async Task GetPolicyAsync_GivenPolicyName_ReturnsPermissionsPolicy()
+        {
+            var result = await _provider.GetPolicyAsync("Permission");
+
+            Assert.IsInstanceOf<PermissionRequirement>(result.Requirements.First());
+        }
+
+        [Test]
+        public async Task GetPolicyAsync_GivenParameters_PolicyWithPermissions()
+        {
+            var result = await _provider.GetPolicyAsync("Permissionp1,p2");
+
+            var requirement = result.Requirements.First() as PermissionRequirement;
+            Assert.AreEqual("p1,p2", requirement.Permissions);
+        }
+    }
+}