Esempio n. 1
0
        public async Task Admin_ClientRolePermissionOperationsTest()
        {
            var roleId = 333;
            var ids    = new IdArrayRequest(new List <int> {
                1, 2, 3
            });

            var roleRepository     = container.Resolve <IRoleRepository>();
            var roleRepositoryMock = Mock.Get(roleRepository);

            var permissionRepository     = container.Resolve <IPermissionRepository>();
            var permissionRepositoryMock = Mock.Get(permissionRepository);

            permissionRepositoryMock
            .Setup(x => x.FindRolePermissionsByRoleIds(It.IsAny <List <int> >()))
            .ReturnsAsync(
                ids.Ids.Select(x =>
                               new Repository.Model.RolePermission
            {
                Id = x
            })
                .ToArray());

            using (var http = new HttpClient())
            {
                http.DefaultRequestHeaders.Authorization =
                    new AuthenticationHeaderValue("Bearer",
                                                  TestContainerBuilder.BuildToken(container, 1, TokenClaims.CLAIM_PERMISSIONS_ADMIN));
                var client = new Domain0Client(TEST_URL, http);

                await client.AddRolePermissionsAsync(roleId, ids);

                permissionRepositoryMock.Verify(t =>
                                                t.AddRolePermissions(
                                                    roleId,
                                                    It.Is <int[]>(rids => rids.SequenceEqual(ids.Ids))),
                                                Times.Once);

                var rolePermissions = await client.LoadRolePermissionsAsync(roleId);

                Assert.True(ids.Ids.SequenceEqual(rolePermissions.Select(x => x.Id.GetValueOrDefault())));
                permissionRepositoryMock.Verify(t => t.FindRolePermissionsByRoleIds(It.Is <List <int> >(roleIds => roleIds.Contains(roleId))), Times.Once);

                await client.RemoveRolePermissionsAsync(roleId, ids);

                permissionRepositoryMock.Verify(t => t.RemoveRolePermissions(
                                                    roleId,
                                                    It.Is <int[]>(rids => rids.SequenceEqual(ids.Ids))),
                                                Times.Once);
            }
        }
Esempio n. 2
0
        public async Task Admin_ClientUserPermissionOperationsTest()
        {
            var permissionId = 888;
            var userId       = 777;
            var ids          = new IdArrayRequest(new List <int> {
                1, 2, 3
            });

            var permissionRepository     = container.Resolve <IPermissionRepository>();
            var permissionRepositoryMock = Mock.Get(permissionRepository);

            permissionRepositoryMock
            .Setup(x => x.FindUserPermissionsByUserIds(It.IsAny <List <int> >()))
            .ReturnsAsync(new[] { new Repository.Model.UserPermission()
                                  {
                                      Id = permissionId
                                  } });

            using (var http = new HttpClient())
            {
                http.DefaultRequestHeaders.Authorization =
                    new AuthenticationHeaderValue("Bearer",
                                                  TestContainerBuilder.BuildToken(container, 1, TokenClaims.CLAIM_PERMISSIONS_ADMIN));
                var client = new Domain0Client(TEST_URL, http);

                await client.AddUserPermissionsAsync(userId, ids);

                permissionRepositoryMock.Verify(t => t.AddUserPermission(userId, It.IsAny <int[]>()), Times.Once);

                var permissions = await client.LoadPermissionsByUserFilterAsync(new UserPermissionFilter(new List <int> {
                    userId
                }));

                permissionRepositoryMock.Verify(t => t.FindUserPermissionsByUserIds(It.Is <List <int> >(userIds => userIds.Contains(userId))), Times.Once);
                Assert.Equal(permissionId, permissions.FirstOrDefault()?.Id);

                await client.RemoveUserPermissionsAsync(userId, ids);

                permissionRepositoryMock.Verify(t => t.RemoveUserPermissions(userId, It.IsAny <int[]>()), Times.Once);
            }
        }