public void GetAllResourceInstancess_LoadNameAndDescriptionFromResourceDetailProvider()
        {
            var resourceId     = 5;
            var resourceType   = typeof(FirstResource);
            var providerResult = new FirstResource(resourceId, "NAME", "DESCRIPTION");
            var queryResult    = new List <IResourceInstance> {
                providerResult
            };
            var tokenSource = new CancellationTokenSource();

            var resourceRegistry = new ResourceRegistry();

            resourceRegistry.Register(resourceType.Assembly);

            var resourceInstanceProvider = new Mock <IResourceInstanceProvider>();

            resourceInstanceProvider
            .Setup(q => q.GetInstancesAsync(resourceType, 1, 10, tokenSource.Token))
            .Returns(Task.FromResult(queryResult));

            //Act
            var manager       = CreateManager(resourceRegistry, null, null, resourceInstanceProvider);
            var resources     = manager.GetAllResourceInstancesAsync(resourceType.FullName, 1, 10, tokenSource.Token).Result;
            var firstResource = resources.First();

            //Assert
            Assert.AreEqual(resourceId, firstResource.Identifier);
            Assert.AreEqual(providerResult.Name, firstResource.Name);
            Assert.AreEqual(providerResult.Description, firstResource.Description);
        }
        public void ResourceInstancePermission_ShouldPass()
        {
            const int roleId     = 1;
            const int resourceId = 1;
            var       permission = FirstPermissions.Edit;

            //Init
            var permissionStore = new Mock <IPermissionStore <int> >();
            var registry        = GetRegistry();
            var convertor       = new DefaultNamingConvertor(registry);
            var auth            = CreateManager(registry, convertor, permissionStore);

            var resource    = new FirstResource(resourceId);
            var tokenSource = new CancellationTokenSource();

            //Pre-Condition
            permissionStore
            .Setup(p => p.IsAllowedAsync(new[] { roleId }, convertor.GetResourceUniqueName(resource.GetType()), resourceId,
                                         convertor.GetPermissionUniqueIdentifier(permission), tokenSource.Token))
            .Returns(Task.FromResult((bool?)true));

            //Act
            Assert.IsTrue(auth.IsAllowedAsync(new[] { roleId }, resource, permission, tokenSource.Token).Result);

            //Assertion
            permissionStore.VerifyAll();
        }
        public async Task Constructor_UseCustomNamingConvertor()
        {
            const int roleId     = 1;
            const int resourceId = 2;
            var       permission = FirstPermissions.Edit;

            //Init
            var registry        = GetRegistry();
            var convertor       = new ConstantNamingConvertor();
            var permissionStore = new Mock <IPermissionStore <int> >();
            var resourceInstanceQueryFactory = new Mock <IResourceInstanceProvider>();
            var manager     = new PermissionManager <int>(permissionStore.Object, registry, resourceInstanceQueryFactory.Object, convertor);
            var resource    = new FirstResource(resourceId);
            var tokenSource = new CancellationTokenSource();

            //Pre-Condition
            permissionStore.Setup(p => p.IsAllowedAsync(new[] { roleId }, ConstantNamingConvertor.RESOURCE, resourceId, ConstantNamingConvertor.PERMISSION, tokenSource.Token))
            .Returns(Task.FromResult((bool?)true));

            //Act
            await manager.IsAllowedAsync(new[] { roleId }, resource, permission, tokenSource.Token);

            //Assertion
            permissionStore.VerifyAll();
        }
Ejemplo n.º 4
0
        public async Task CheckPermission_WithResource_AtLeastOneRoleMustHavePermission()
        {
            var sequence = new List <(bool expected, bool role1, bool role2)>
            {
                (false, false, false),
                (true, true, false),
                (true, false, true),
                (true, true, true),
            };
            var resource    = new FirstResource(1);
            var tokenSource = new CancellationTokenSource();

            foreach (var valueTuple in sequence)
            {
                var authorizatorMock = new Mock <IPermissionManager <int> >();
                authorizatorMock.Setup(a => a.IsAllowedAsync(TwoRolesIds, resource, FirstPermissions.Edit, tokenSource.Token))
                .Returns(Task.FromResult(valueTuple.role1 | valueTuple.role2));
                var resourceInstanceQueryFactory = new Mock <IResourceInstanceProvider>();
                var user = new User <int>(authorizatorMock.Object, GetClaimsPrincipalProvider("1", TwoRoles), resourceInstanceQueryFactory.Object, GetRoleStore());

                //Act
                if (valueTuple.expected)
                {
                    //Shouldn't throw an exception
                    await user.CheckPermissionAsync(resource, FirstPermissions.Edit, tokenSource.Token);
                }
                else
                {
                    //Should thrown an exception
                    try
                    {
                        await user.CheckPermissionAsync(resource, FirstPermissions.Edit, tokenSource.Token);

                        Assert.Fail();
                    }
                    catch (AuthorizationException) { }
                }
            }
        }
Ejemplo n.º 5
0
        public void IsAllowed_WithResource_AtLeastOneRoleMustHavePermission()
        {
            var sequence = new List <(bool expected, bool role1, bool role2)>
            {
                (false, false, false),
                (true, true, false),
                (true, false, true),
                (true, true, true),
            };
            var resource    = new FirstResource(1);
            var tokenSource = new CancellationTokenSource();

            foreach (var valueTuple in sequence)
            {
                var authorizatorMock = new Mock <IPermissionManager <int> >();
                authorizatorMock.Setup(a => a.IsAllowedAsync(TwoRolesIds, resource, FirstPermissions.Edit, tokenSource.Token))
                .Returns(Task.FromResult(valueTuple.role1 | valueTuple.role2));
                var resourceInstanceQueryFactory = new Mock <IResourceInstanceProvider>();
                var user = new User <int>(authorizatorMock.Object, GetClaimsPrincipalProvider("1", TwoRoles), resourceInstanceQueryFactory.Object, GetRoleStore());

                //Act
                Assert.AreEqual(valueTuple.expected, user.IsAllowedAsync(resource, FirstPermissions.Edit, tokenSource.Token).Result);
            }
        }