Add resource permission management provider and tests

modules/permission-management/src/Volo.Abp.PermissionManagement.Domain/Volo/Abp/PermissionManagement/ResourcePermissionManager.cs

@@ -277,7 +277,7 @@ public class ResourcePermissionManager : IResourcePermissionManager, ISingletonD
         if (provider == null)
         {
             //TODO: BusinessException
-            throw new AbpException("Unknown permission management provider: " + providerName);
+            throw new AbpException("Unknown resource permission management provider: " + providerName);
         }
 
         await provider.SetAsync(permissionName, resourceName, resourceKey, providerKey, isGranted);

modules/permission-management/test/Volo.Abp.PermissionManagement.Application.Tests/Volo/Abp/PermissionManagement/AbpPermissionManagementApplicationTestModule.cs

@@ -22,6 +22,7 @@ public class AbpPermissionManagementApplicationTestModule : AbpModule
             options.ProviderPolicies[UserPermissionValueProvider.ProviderName] = UserPermissionValueProvider.ProviderName;
             options.ProviderPolicies["Test"] = "Test";
             options.ManagementProviders.Add<TestPermissionManagementProvider>();
+            options.ResourceManagementProviders.Add<TestResourcePermissionManagementProvider>();
         });
     }
 }

modules/permission-management/test/Volo.Abp.PermissionManagement.Domain.Tests/Volo/Abp/PermissionManagement/ResourcePermissionManagementProvider_Tests.cs

@@ -0,0 +1,90 @@
+using System;
+using System.Threading.Tasks;
+using Shouldly;
+using Volo.Abp.Authorization.Permissions;
+using Xunit;
+
+namespace Volo.Abp.PermissionManagement;
+
+public class ResourcePermissionManagementProvider_Tests : PermissionTestBase
+{
+    private readonly IResourcePermissionManagementProvider _resourcePermissionManagementProvider;
+    private readonly IResourcePermissionGrantRepository _resourcePermissionGrantRepository;
+
+    public ResourcePermissionManagementProvider_Tests()
+    {
+        _resourcePermissionManagementProvider = GetRequiredService<TestResourcePermissionManagementProvider>();
+        _resourcePermissionGrantRepository = GetRequiredService<IResourcePermissionGrantRepository>();
+    }
+
+    [Fact]
+    public async Task CheckAsync()
+    {
+        await _resourcePermissionGrantRepository.InsertAsync(
+            new ResourcePermissionGrant(
+                Guid.NewGuid(),
+                "MyPermission1",
+                TestEntityResource.ResourceName,
+                TestEntityResource.ResourceKey1,
+                "Test",
+                "Test"
+            )
+        );
+
+        var permissionValueProviderGrantInfo = await _resourcePermissionManagementProvider.CheckAsync(
+            "MyPermission1",
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1,
+            "Test",
+            "Test");
+
+        permissionValueProviderGrantInfo.IsGranted.ShouldBeTrue();
+        permissionValueProviderGrantInfo.ProviderKey.ShouldBe("Test");
+    }
+
+    [Fact]
+    public async Task Check_Should_Return_NonGranted_When_ProviderName_NotEquals_Name()
+    {
+        var permissionValueProviderGrantInfo = await _resourcePermissionManagementProvider.CheckAsync(
+            "MyPermission1",
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1,
+            "TestNotExist",
+            "Test");
+
+        permissionValueProviderGrantInfo.IsGranted.ShouldBeFalse();
+        permissionValueProviderGrantInfo.ProviderKey.ShouldBeNull();
+    }
+
+    [Fact]
+    public async Task SetAsync()
+    {
+        await _resourcePermissionGrantRepository.InsertAsync(
+            new ResourcePermissionGrant(
+                Guid.NewGuid(),
+                "MyPermission1",
+                TestEntityResource.ResourceName,
+                TestEntityResource.ResourceKey1,
+                "Test",
+                "Test"
+            )
+        );
+        (await _resourcePermissionGrantRepository.FindAsync("MyPermission1",
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1,
+            "Test",
+            "Test")).ShouldNotBeNull();
+
+        await _resourcePermissionManagementProvider.SetAsync("MyPermission1",
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1,
+            "Test",
+            false);
+
+        (await _resourcePermissionGrantRepository.FindAsync("MyPermission1",
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1,
+            "Test",
+            "Test")).ShouldBeNull();
+    }
+}

modules/permission-management/test/Volo.Abp.PermissionManagement.Domain.Tests/Volo/Abp/PermissionManagement/ResourcePermissionManager_Tests.cs

@@ -0,0 +1,337 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Shouldly;
+using Volo.Abp.Authorization.Permissions;
+using Volo.Abp.Authorization.Permissions.Resources;
+using Xunit;
+
+namespace Volo.Abp.PermissionManagement;
+
+public class ResourcePermissionManager_Tests : PermissionTestBase
+{
+    private readonly IResourcePermissionManager _resourcePermissionManager;
+    private readonly IResourcePermissionGrantRepository _resourcePermissionGrantRepository;
+
+    public ResourcePermissionManager_Tests()
+    {
+        _resourcePermissionManager = GetRequiredService<IResourcePermissionManager>();
+        _resourcePermissionGrantRepository = GetRequiredService<IResourcePermissionGrantRepository>();
+    }
+
+    [Fact]
+    public async Task GetProviderKeyLookupServicesAsync()
+    {
+        var permissionProviderKeyLookupServices = await _resourcePermissionManager.GetProviderKeyLookupServicesAsync();
+
+        permissionProviderKeyLookupServices.ShouldNotBeNull();
+        permissionProviderKeyLookupServices.First().Name.ShouldBe("Test");
+    }
+
+    [Fact]
+    public async Task GetProviderKeyLookupServiceAsync()
+    {
+        var testProviderKeyLookupService = await _resourcePermissionManager.GetProviderKeyLookupServiceAsync("Test");
+        testProviderKeyLookupService.ShouldNotBeNull();
+        testProviderKeyLookupService.Name.ShouldBe("Test");
+
+        var exception = await Assert.ThrowsAsync<AbpException>(async () =>
+        {
+            await _resourcePermissionManager.GetProviderKeyLookupServiceAsync("UndefinedProvider");
+        });
+        exception.Message.ShouldBe("Unknown resource permission provider key lookup service: UndefinedProvider");
+    }
+
+    [Fact]
+    public async Task GetAvailablePermissionsAsync()
+    {
+        var availablePermissions = await _resourcePermissionManager.GetAvailablePermissionsAsync(TestEntityResource.ResourceName);
+
+        availablePermissions.ShouldNotBeNull();
+        availablePermissions.ShouldContain(p => p.Name == "MyResourcePermission1");
+        availablePermissions.ShouldContain(p => p.Name == "MyResourcePermission2");
+        availablePermissions.ShouldContain(p => p.Name == "MyResourcePermission3");
+        availablePermissions.ShouldContain(p => p.Name == "MyResourcePermission4");
+        availablePermissions.ShouldContain(p => p.Name == "MyResourcePermission6");
+        availablePermissions.ShouldContain(p => p.Name == "MyResourcePermission7");
+
+        availablePermissions.ShouldNotContain(p => p.Name == "MyResourcePermission5");
+        availablePermissions.ShouldNotContain(p => p.Name == "MyResourceDisabledPermission1");
+        availablePermissions.ShouldNotContain(p => p.Name == "MyResourceDisabledPermission2");
+    }
+
+    [Fact]
+    public async Task GetAsync()
+    {
+        await _resourcePermissionGrantRepository.InsertAsync(new ResourcePermissionGrant(
+            Guid.NewGuid(),
+            "MyResourcePermission1",
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1,
+            "Test",
+            "Test")
+        );
+
+        var grantedProviders = await _resourcePermissionManager.GetAsync(
+            "MyResourcePermission1",
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1,
+            "Test",
+            "Test");
+
+        grantedProviders.ShouldNotBeNull();
+        grantedProviders.IsGranted.ShouldBeTrue();
+        grantedProviders.Name.ShouldBe("MyResourcePermission1");
+        grantedProviders.Providers.ShouldContain(x => x.Key == "Test");
+    }
+
+    [Fact]
+    public async Task Multiple_GetAsync()
+    {
+        await _resourcePermissionGrantRepository.InsertAsync(new ResourcePermissionGrant(
+            Guid.NewGuid(),
+            "MyResourcePermission1",
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1,
+            "Test",
+            "Test")
+        );
+        await _resourcePermissionGrantRepository.InsertAsync(new ResourcePermissionGrant(
+            Guid.NewGuid(),
+            "MyResourcePermission2",
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1,
+            "Test",
+            "Test")
+        );
+
+        var grantedProviders = await _resourcePermissionManager.GetAsync(
+            new[] { "MyResourcePermission1", "MyResourcePermission2" },
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1,
+            "Test",
+            "Test");
+
+        grantedProviders.Result.Count.ShouldBe(2);
+        grantedProviders.Result.First().IsGranted.ShouldBeTrue();
+        grantedProviders.Result.First().Name.ShouldBe("MyResourcePermission1");
+        grantedProviders.Result.First().Providers.ShouldContain(x => x.Key == "Test");
+
+        grantedProviders.Result.Last().IsGranted.ShouldBeTrue();
+        grantedProviders.Result.Last().Name.ShouldBe("MyResourcePermission2");
+        grantedProviders.Result.Last().Providers.ShouldContain(x => x.Key == "Test");
+    }
+
+    [Fact]
+    public async Task Get_Should_Return_Not_Granted_When_Permission_Undefined()
+    {
+        var result = await _resourcePermissionManager.GetAsync(
+            "MyResourcePermission1NotExist",
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1,"Test", "Test");
+        result.Name.ShouldBe("MyResourcePermission1NotExist");
+        result.Providers.ShouldBeEmpty();
+        result.IsGranted.ShouldBeFalse();
+    }
+
+    [Fact]
+    public async Task GetAllAsync()
+    {
+        await _resourcePermissionGrantRepository.InsertAsync(new ResourcePermissionGrant(
+            Guid.NewGuid(),
+            "MyResourcePermission1",
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1,
+            "Test",
+            "Test")
+        );
+
+        await _resourcePermissionGrantRepository.InsertAsync(new ResourcePermissionGrant(
+            Guid.NewGuid(),
+            "MyResourcePermission2",
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1,
+            "Test",
+            "Test")
+        );
+
+        var permissionWithGrantedProviders = await _resourcePermissionManager.GetAllAsync(
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1,
+            "Test",
+            "Test");
+
+        permissionWithGrantedProviders.ShouldNotBeNull();
+        permissionWithGrantedProviders.ShouldContain(x =>
+            x.IsGranted && x.Name == "MyResourcePermission1" && x.Providers.Any(p => p.Key == "Test"));
+        permissionWithGrantedProviders.ShouldContain(x =>
+            x.IsGranted && x.Name == "MyResourcePermission2" && x.Providers.Any(p => p.Key == "Test"));
+
+
+        permissionWithGrantedProviders = await _resourcePermissionManager.GetAllAsync(
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1);
+
+        permissionWithGrantedProviders.ShouldNotBeNull();
+        permissionWithGrantedProviders.ShouldContain(x => x.IsGranted && x.Name == "MyResourcePermission1" && x.Providers.Any(p => p.Key == "Test"));
+        permissionWithGrantedProviders.ShouldContain(x => x.IsGranted && x.Name == "MyResourcePermission2" && x.Providers.Any(p => p.Key == "Test"));
+
+        permissionWithGrantedProviders.ShouldNotContain(x => x.Name == "MyResourcePermission5"); // Not available permission
+
+        permissionWithGrantedProviders.ShouldContain(x => !x.IsGranted && x.Name == "MyResourcePermission3" && x.Providers.Count == 0);
+        permissionWithGrantedProviders.ShouldContain(x => !x.IsGranted && x.Name == "MyResourcePermission4" && x.Providers.Count == 0);
+        permissionWithGrantedProviders.ShouldContain(x => !x.IsGranted && x.Name == "MyResourcePermission6" && x.Providers.Count == 0);
+        permissionWithGrantedProviders.ShouldContain(x => !x.IsGranted && x.Name == "MyResourcePermission7" && x.Providers.Count == 0);
+        permissionWithGrantedProviders.ShouldContain(x => !x.IsGranted && x.Name == "MyResourcePermission8" && x.Providers.Count == 0);
+    }
+
+    [Fact]
+    public async Task GetAllGroupAsync()
+    {
+        var group = await _resourcePermissionManager.GetAllGroupAsync(
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1);
+
+        group.ShouldNotBeNull();
+        group.Count.ShouldBe(1);
+        group.First().ProviderName.ShouldBe(UserResourcePermissionValueProvider.ProviderName);
+        group.First().ProviderKey.ShouldBe(PermissionTestDataBuilder.User1Id.ToString());
+        group.First().Permissions.Count.ShouldBe(1);
+        group.First().Permissions.ShouldContain(x => x == "MyResourcePermission1");
+
+        group = await _resourcePermissionManager.GetAllGroupAsync(
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey3);
+
+        group.ShouldNotBeNull();
+        group.Count.ShouldBe(1);
+        group.First().ProviderName.ShouldBe(UserResourcePermissionValueProvider.ProviderName);
+        group.First().ProviderKey.ShouldBe(PermissionTestDataBuilder.User1Id.ToString());
+        group.First().Permissions.Count.ShouldBe(2);
+        group.First().Permissions.ShouldContain(x => x == "MyResourcePermission3");
+        group.First().Permissions.ShouldContain(x => x == "MyResourcePermission6");
+    }
+
+    [Fact]
+    public async Task Set_Should_Silently_Ignore_When_Permission_Undefined()
+    {
+        await _resourcePermissionManager.SetAsync(
+            "MyResourcePermission1NotExist",
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1,
+            "Test",
+            "Test",
+            true);
+    }
+
+    [Fact]
+    public async Task Set_Should_Throw_Exception_If_Provider_Not_Found()
+    {
+       var exception =  await Assert.ThrowsAsync<AbpException>(async () =>
+        {
+            await _resourcePermissionManager.SetAsync(
+                "MyResourcePermission1",
+                TestEntityResource.ResourceName,
+                TestEntityResource.ResourceKey1,
+                "UndefinedProvider",
+                "Test",
+                true);
+        });
+
+        exception.Message.ShouldBe("Unknown resource permission management provider: UndefinedProvider");
+    }
+
+    [Fact]
+    public async Task UpdateProviderKey()
+    {
+        await _resourcePermissionGrantRepository.InsertAsync(new ResourcePermissionGrant(
+            Guid.NewGuid(),
+            "MyResourcePermission1",
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1,
+            "Test",
+            "Test")
+        );
+        var permissionGrant = await _resourcePermissionGrantRepository.FindAsync(
+            "MyResourcePermission1",
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1,
+            "Test",
+            "Test");
+        permissionGrant.ProviderKey.ShouldBe("Test");
+
+        await _resourcePermissionManager.UpdateProviderKeyAsync(permissionGrant, "NewProviderKey");
+        (await _resourcePermissionGrantRepository.FindAsync(
+            "MyResourcePermission1",
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1,
+            "Test",
+            "NewProviderKey")).ShouldNotBeNull();
+    }
+
+    [Fact]
+    public async Task DeleteAsync()
+    {
+        await _resourcePermissionGrantRepository.InsertAsync(new ResourcePermissionGrant(
+            Guid.NewGuid(),
+            "MyResourcePermission1",
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1,
+            "Test",
+            "Test")
+        );
+        var permissionGrant = await _resourcePermissionGrantRepository.FindAsync("MyResourcePermission1",
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1,
+            "Test",
+            "Test");
+        permissionGrant.ProviderKey.ShouldBe("Test");
+
+        await _resourcePermissionManager.DeleteAsync(
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1,
+            "Test",
+            "Test");
+
+        (await _resourcePermissionGrantRepository.FindAsync(
+            "MyResourcePermission1",
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1,
+            "Test",
+            "Test")).ShouldBeNull();
+    }
+
+    [Fact]
+    public async Task DeleteByProviderAsync()
+    {
+        await _resourcePermissionGrantRepository.InsertAsync(new ResourcePermissionGrant(
+            Guid.NewGuid(),
+            "MyResourcePermission1",
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1,
+            "Test",
+            "Test")
+        );
+
+        var permissionGrant = await _resourcePermissionGrantRepository.FindAsync("MyResourcePermission1",
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1,
+            "Test",
+            "Test");
+
+        permissionGrant.ProviderKey.ShouldBe("Test");
+
+        await _resourcePermissionManager.DeleteAsync(
+            "Test",
+            "Test");
+
+        (await _resourcePermissionGrantRepository.FindAsync(
+            "MyResourcePermission1",
+            TestEntityResource.ResourceName,
+            TestEntityResource.ResourceKey1,
+            "Test",
+            "Test")).ShouldBeNull();
+    }
+}

modules/permission-management/test/Volo.Abp.PermissionManagement.Domain.Tests/Volo/Abp/PermissionManagement/ResourcePermissionStore_Tests.cs

@@ -90,9 +90,11 @@ public class ResourcePermissionStore_Tests : PermissionTestBase
             TestEntityResource.ResourceName,
             TestEntityResource.ResourceKey3);
 
-        grantedPermissions.Length.ShouldBe(2);
+        grantedPermissions.Length.ShouldBe(3);
         grantedPermissions.ShouldContain("MyResourcePermission3");
         grantedPermissions.ShouldContain("MyResourcePermission5");
+        grantedPermissions.ShouldContain("MyResourcePermission6");
+
     }
 
 

modules/permission-management/test/Volo.Abp.PermissionManagement.TestBase/Volo/Abp/PermissionManagement/AbpPermissionManagementTestBaseModule.cs

@@ -18,6 +18,8 @@ public class AbpPermissionManagementTestBaseModule : AbpModule
         context.Services.Configure<PermissionManagementOptions>(options =>
         {
             options.ManagementProviders.Add<TestPermissionManagementProvider>();
+            options.ResourceManagementProviders.Add<TestResourcePermissionManagementProvider>();
+            options.ResourcePermissionProviderKeyLookupServices.Add<TestResourcePermissionProviderKeyLookupService>();
         });
     }
 

modules/permission-management/test/Volo.Abp.PermissionManagement.TestBase/Volo/Abp/PermissionManagement/PermissionTestDataBuilder.cs

@@ -107,6 +107,17 @@ public class PermissionTestDataBuilder : ITransientDependency
             )
         );
 
+        await _resourcePermissionGrantRepository.InsertAsync(
+            new ResourcePermissionGrant(
+                _guidGenerator.Create(),
+                "MyResourcePermission6",
+                TestEntityResource.ResourceName,
+                TestEntityResource.ResourceKey3,
+                UserPermissionValueProvider.ProviderName,
+                User1Id.ToString()
+            )
+        );
+
         await _resourcePermissionGrantRepository.InsertAsync(
             new ResourcePermissionGrant(
                 _guidGenerator.Create(),

modules/permission-management/test/Volo.Abp.PermissionManagement.TestBase/Volo/Abp/PermissionManagement/TestResourcePermissionManagementProvider.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Volo.Abp.Guids;
+using Volo.Abp.MultiTenancy;
+
+namespace Volo.Abp.PermissionManagement;
+
+public class TestResourcePermissionManagementProvider : ResourcePermissionManagementProvider
+{
+    public override string Name => "Test";
+
+    public TestResourcePermissionManagementProvider(
+        IResourcePermissionGrantRepository resourcePermissionGrantRepository,
+        IGuidGenerator guidGenerator,
+        ICurrentTenant currentTenant)
+        : base(
+            resourcePermissionGrantRepository,
+            guidGenerator,
+            currentTenant)
+    {
+
+    }
+}

modules/permission-management/test/Volo.Abp.PermissionManagement.TestBase/Volo/Abp/PermissionManagement/TestResourcePermissionProviderKeyLookupService.cs

@@ -0,0 +1,24 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Volo.Abp.DependencyInjection;
+using Volo.Abp.Localization;
+
+namespace Volo.Abp.PermissionManagement;
+
+public class TestResourcePermissionProviderKeyLookupService : IResourcePermissionProviderKeyLookupService, ITransientDependency
+{
+    public string Name => "Test";
+
+    public ILocalizableString DisplayName => new LocalizableString("Test", "TestResource");
+
+    public Task<List<ResourcePermissionProviderKeyInfo>> SearchAsync(string filter = null, CancellationToken cancellationToken = default)
+    {
+        throw new System.NotImplementedException();
+    }
+
+    public Task<List<ResourcePermissionProviderKeyInfo>> SearchAsync(string[] keys, CancellationToken cancellationToken = default)
+    {
+        throw new System.NotImplementedException();
+    }
+}