Exemplo n.º 1
0
 public RolesTest()
 {
     //Arrange
     controller = new RolesController(new InMemoryRolesAgent());
     //must set explicitly for tests to work
     controller.ObjectValidator = new InMemoryModelValidator();
 }
Exemplo n.º 2
0
        public void GetByWrongId(int id)
        {
            var controller = new RolesController(context);
            var response   = controller.Get(id) as ObjectResult;

            Assert.Null(response);
        }
Exemplo n.º 3
0
        public async Task UpdateRole_returns_error_string_when_role_has_invalid_id()
        {
            //Arrange
            var controller = new RolesController(_configuration, _contextAccessor);

            Role role = new Role
            {
                Id   = new Guid(),
                Name = "Some Role"
            };

            dynamic roleObj = new ExpandoObject();

            roleObj.Role = role;

            JObject data = JObject.FromObject(roleObj);

            //Act
            var result = await controller.UpdateRole(data);

            //Assert
            var messageResult = Assert.IsType <string>(result);              //Asserting that the return is a String

            Assert.Contains("The input data was inaccurate", messageResult); //Asserting that message is equal as mentioned
        }
        public void Roles()
        {
            var controller = new RolesController();
            var result     = controller.Index() as ViewResult;

            Assert.IsNotNull(result);
        }
Exemplo n.º 5
0
        private RolesController ConfigureController()
        {
            //Mocking the user claims
            var claims = new List <Claim> {
                new Claim("CreatedOn", DateTime.UtcNow.ToString()),
                new Claim("Email", "*****@*****.**"),
                new Claim("Initials", "JD"),
                new Claim("Name", "John Doe"),
                new Claim("Role", "Admin"),
                new Claim("UserId", Guid.NewGuid().ToString()),
                new Claim("Username", "SomeUserName"),
                new Claim("IsAuthenticated", "True")
            };
            var             userIdentity = new ClaimsIdentity(claims, "Auth");
            ClaimsPrincipal principal    = new ClaimsPrincipal(userIdentity);

            var controller = new RolesController(_bosAuthClient)
            {
                ControllerContext = new ControllerContext()
                {
                    HttpContext = new DefaultHttpContext()
                    {
                        User = principal
                    }
                }
            };

            return(controller);
        }
        public async Task Index()
        {
            var role = new Role()
            {
                Id            = Guid.NewGuid(),
                Name          = "role_1",
                Description   = "Role 1",
                ApplicationId = Guid.NewGuid()
            };

            var items = new List <Role>()
            {
                role
            };

            var service = new Mock <IRoleService>();

            service.Setup(c => c.GetRoles())
            .ReturnsAsync(items);

            var controller = new RolesController(service.Object);

            var result = await controller.Index();

            var okResult    = Assert.IsType <OkObjectResult>(result);
            var returnValue = Assert.IsType <List <Role> >(okResult.Value);

            Assert.Same(items, returnValue);
        }
Exemplo n.º 7
0
        public void Cannot_Delete_Invalid_Products()
        {
            //布置——创建模仿存储库
            Mock <IRoleInfoRepository> mock = new Mock <IRoleInfoRepository>();

            RoleInfo[] roles = new RoleInfo[] {
                new RoleInfo {
                    RoleID = Guid.NewGuid(), RoleName = "R1", RoleEN = "REN1"
                },
                new RoleInfo {
                    RoleID = Guid.NewGuid(), RoleName = "R1"
                },
                new RoleInfo {
                    RoleID = Guid.NewGuid(), RoleName = "R3", RoleEN = "REN3"
                }
            };

            //布置——创建控制器
            RolesController controller = new RolesController(mock.Object);

            //动作——用一个不存在的ID进行删除
            controller.Delete(Guid.NewGuid());

            //断言
            mock.Verify(m => m.DeleteRoleInfo(It.IsAny <RoleInfo>()), Times.Never());
        }
        public void Get_ShouldFail_GivenRoleDoesntExist()
        {
            // Given
            // RolesController over a mock service that would alway throw exceptions on GetAsync
            var accountManager       = Substitute.For <IRestrictedAccountManager>();
            var roleService          = Substitute.For <IRestrictedRoleService>();
            var claimsService        = Substitute.For <IClaimsService>();
            var authorizationService = Substitute.For <IAuthorizationService>();

            roleService.When(s => s.GetRoleByIdAsync(Arg.Any <Guid>()))
            .Do(v => throw new ItemNotFoundException(v[0].ToString(), "tenant"));
            var logger           = Substitute.For <Microsoft.Extensions.Logging.ILogger <RolesController> >();
            var tenantIdProvider = Substitute.For <ITenantIdProvider>();

            var roleController = new RolesController(
                accountManager, roleService, claimsService, authorizationService, tenantIdProvider, new AutoMapperConfig());

            var roleId = Guid.NewGuid();

            // When
            // Get is called on the controller
            AsyncTestDelegate action = async() => await roleController.GetRoleById(roleId);

            // Then
            // The controller should thrown ItemNotFoundException
            Assert.ThrowsAsync <ItemNotFoundException>(action);
        }
Exemplo n.º 9
0
        public void Cannot_Save_Invalid_Changes()
        {
            //布置——创建模仿存储库
            Mock <IRoleInfoRepository> mock = new Mock <IRoleInfoRepository>();

            //布置——创建控制器
            RolesController controller = new RolesController(mock.Object);

            //布置——创建一个产品
            RoleInfo role = new RoleInfo {
                RoleID = Guid.NewGuid(), RoleName = "测试顾问"
            };

            //布置——把一个错误添加到模型状态
            controller.ModelState.AddModelError("error", "error");

            //动作——试着保存这个产品
            ActionResult result = controller.Edit(role);

            //断言——检查,调用了存储库
            mock.Verify(m => m.SaveRoleInfo(It.IsAny <RoleInfo>()), Times.Never());

            //断言——检查方法的结果类型
            Assert.IsInstanceOfType(result, typeof(ViewResult));
        }
Exemplo n.º 10
0
        public void Can_Delete_Valid_Roles()
        {
            //布置——创建一个角色
            RoleInfo role = new RoleInfo {
                RoleID = Guid.NewGuid(), RoleName = "R1"
            };

            //布置——创建模仿存储库
            Mock <IRoleInfoRepository> mock = new Mock <IRoleInfoRepository>();

            RoleInfo[] roles = new RoleInfo[] {
                new RoleInfo {
                    RoleID = Guid.NewGuid(), RoleName = "R1", RoleEN = "REN1"
                },
                role,
                new RoleInfo {
                    RoleID = Guid.NewGuid(), RoleName = "R3", RoleEN = "REN3"
                }
            };
            mock.Setup(m => m.RolesInfo).Returns(roles.AsQueryable());

            //布置——创建控制器
            RolesController controller = new RolesController(mock.Object);

            //动作——删除产品
            controller.Delete(role.RoleID);

            //断言
            mock.Verify(m => m.DeleteRoleInfo(role));
        }
Exemplo n.º 11
0
        public async Task RoleClaimsを削除しShowRoleClaimsを表示()
        {
            // Arrange
            var roleName        = "Developer";
            var claimType       = "Receipt";
            var mockUserManager = this.GetMockUserManager();
            var mockRoleManager = this.GetMockRoleManager();

            mockRoleManager.Setup(r => r.FindByNameAsync(roleName))
            .Returns(Task.FromResult(new ApplicationRole()
            {
                Name = roleName
            }));
            var controller = new RolesController(mockUserManager.Object, mockRoleManager.Object);

            // Act
            var result = await controller.DeleteRoleClaims(roleName, claimType);

            // Assert
            mockRoleManager.Verify(r => r.RemoveClaimAsync(It.IsAny <ApplicationRole>(), It.IsAny <Claim>()), Times.Once);
            var redirectToActionResult = Assert.IsType <RedirectToActionResult>(result);

            Assert.Null(redirectToActionResult.ControllerName);
            Assert.Equal(nameof(controller.ShowRoleClaims), redirectToActionResult.ActionName);
        }
Exemplo n.º 12
0
        public void Cannot_Edit_Nonexistent_Product()
        {
            //布置
            //——创建模仿存储库
            RoleInfo[] roles = new RoleInfo[] {
                new RoleInfo {
                    RoleID = Guid.NewGuid(), RoleName = "R1", RoleEN = "REN1"
                },
                new RoleInfo {
                    RoleID = Guid.NewGuid(), RoleName = "R2", RoleEN = "REN2"
                },
                new RoleInfo {
                    RoleID = Guid.NewGuid(), RoleName = "R3", RoleEN = "REN3"
                }
            };

            Mock <IRoleInfoRepository> mock = new Mock <IRoleInfoRepository>();

            mock.Setup(m => m.RolesInfo).Returns(roles.AsQueryable());

            //布置——创建控制器
            RolesController controller = new RolesController(mock.Object);

            //动作
            RoleInfo r1 = controller.Edit(Guid.NewGuid()).Model as RoleInfo;

            //断言
            Assert.IsNull(r1);
        }
Exemplo n.º 13
0
        public void 未登録Roleがある場合メッセージを表示()
        {
            // Arrange
            var mockUserManager = this.GetMockUserManager();
            var mockRoleManager = this.GetMockRoleManager();

            mockRoleManager.Setup(r => r.Roles)
            .Returns(new List <ApplicationRole>()
            {
                new ApplicationRole()
                {
                    Name = "Administrator"
                },
            }
                     .AsQueryable());
            var controller = new RolesController(mockUserManager.Object, mockRoleManager.Object);

            // Act
            var result = controller.Index();

            // Assert
            var viewResult = Assert.IsType <ViewResult>(result);
            var model      = Assert.IsAssignableFrom <IndexViewModel>(viewResult.ViewData.Model);

            Assert.True(model.HasUnregistered);
        }
Exemplo n.º 14
0
        public async Task RoleCliamsが存在する時RoleClaimsを一覧表示()
        {
            var roleName = "Developer";
            var role     = new ApplicationRole()
            {
                Name = "Developer"
            };
            var           receiptClaim          = new Claim("Receipt", "");
            var           createTournamentClaim = new Claim("CreateTournament", "");
            IList <Claim> claims = new List <Claim>()
            {
                receiptClaim, createTournamentClaim
            };
            var mockUserManager = this.GetMockUserManager();
            var mockRoleManager = this.GetMockRoleManager();

            mockRoleManager.Setup(r => r.FindByNameAsync(roleName))
            .Returns(Task.FromResult(role));
            mockRoleManager.Setup(r => r.GetClaimsAsync(role))
            .Returns(Task.FromResult(claims));
            var controller = new RolesController(mockUserManager.Object, mockRoleManager.Object);

            // Act
            var result = await controller.ShowRoleClaims(roleName);

            // Assert
            var viewResult = Assert.IsType <ViewResult>(result);
            var model      = Assert.IsAssignableFrom <ShowRoleClaimsViewModel>(viewResult.ViewData.Model);

            Assert.Equal(claims, model.RoleClaims);
            Assert.Equal(roleName, model.RoleName);
        }
Exemplo n.º 15
0
        public async Task 未登録Roleがある時Roleを削除しIndexを表示()
        {
            // Arrange
            var deleteRoleNames = new List <string>()
            {
                "customer", "browser"
            };
            var mockUserManager = this.GetMockUserManager();
            var mockRoleManager = this.GetMockRoleManager();

            mockRoleManager.Setup(r => r.FindByNameAsync("customer"))
            .Returns(Task.FromResult(new ApplicationRole()
            {
                Name = "customer"
            }));
            mockRoleManager.Setup(r => r.FindByNameAsync("browser"))
            .Returns(Task.FromResult(new ApplicationRole()
            {
                Name = "browser"
            }));
            var controller = new RolesController(mockUserManager.Object, mockRoleManager.Object);

            // Act
            var result = await controller.DeleteRoles(deleteRoleNames);

            // Assert
            mockRoleManager.Verify(r => r.DeleteAsync(It.IsAny <ApplicationRole>()), Times.Exactly(2));
            var redirectToActionResult = Assert.IsType <RedirectToActionResult>(result);

            Assert.Null(redirectToActionResult.ControllerName);
            Assert.Equal(nameof(controller.Index), redirectToActionResult.ActionName);
        }
        public void GetByIdAsync_Return_Role()
        {
            //Arrange
            int expectedStatusCode = 200;

            RoleDomainModel roleDomainModel = new RoleDomainModel
            {
                Id    = 123,
                Name  = "admin",
                Users = new List <UserDomainModel>()
            };

            Task <RoleDomainModel> responseTask = Task.FromResult(roleDomainModel);

            _roleService = new Mock <IRoleService>();
            _roleService.Setup(x => x.GetByIdAsync(It.IsAny <int>())).Returns(responseTask);
            RolesController rolesController = new RolesController(_roleService.Object);

            //Act
            var             result     = rolesController.GetByIdAsync(roleDomainModel.Id).ConfigureAwait(false).GetAwaiter().GetResult().Result;
            var             resultList = ((OkObjectResult)result).Value;
            RoleDomainModel roleResult = (RoleDomainModel)resultList;

            //Assert
            Assert.IsNotNull(roleResult);
            Assert.IsInstanceOfType(result, typeof(OkObjectResult));
            Assert.AreEqual(expectedStatusCode, ((OkObjectResult)result).StatusCode);
        }
        public void Get_All_Async_Return_Roles_List()
        {
            //Arrange
            RoleDomainModel roleDomainModel = new RoleDomainModel
            {
                Id    = 123,
                Name  = "admin",
                Users = new List <UserDomainModel>()
            };
            int expectedStatusCode  = 200;
            int expectedResultCount = 1;

            List <RoleDomainModel> roleDomainModels = new List <RoleDomainModel>();

            roleDomainModels.Add(roleDomainModel);

            IEnumerable <RoleDomainModel>         rolesIEn     = roleDomainModels;
            Task <IEnumerable <RoleDomainModel> > responseTask = Task.FromResult(rolesIEn);

            _roleService = new Mock <IRoleService>();
            _roleService.Setup(x => x.GetAllAsync()).Returns(responseTask);
            RolesController rolesController = new RolesController(_roleService.Object);

            //Act
            var result     = rolesController.GetAsync().ConfigureAwait(false).GetAwaiter().GetResult().Result;
            var resultList = ((OkObjectResult)result).Value;
            List <RoleDomainModel> roleDomainModelsResult = (List <RoleDomainModel>)resultList;

            //Assert
            Assert.IsNotNull(roleDomainModelsResult);
            Assert.AreEqual(expectedResultCount, roleDomainModelsResult.Count);
            Assert.AreEqual(roleDomainModel.Id, roleDomainModelsResult[0].Id);
            Assert.IsInstanceOfType(result, typeof(OkObjectResult));
            Assert.AreEqual(expectedStatusCode, ((OkObjectResult)result).StatusCode);
        }
Exemplo n.º 18
0
        public void ControllerPostEmployeeWithValidData()
        {
            var Rolecontroller = new RolesController();

            Rolecontroller.Post(new Role()
            {
                Id   = "T",
                Name = "Test"
            });

            var controller = new EmployeesController();

            var response = controller.Post(new Employee()
            {
                FirstName = "Post",
                LastName  = "Test",
                Position  = new Role {
                    Id = "SD"
                }
            });
            //var response = controller.Get("G");
            var result = (OkNegotiatedContentResult <EmployeeModel>)response;

            Assert.IsNotNull(result);
            Assert.IsNotNull(result.Content);
        }
Exemplo n.º 19
0
        public async Task PutRole_ValidInput_Failed()
        {
            _mockRoleManager.Setup(x => x.FindByIdAsync(It.IsAny <string>()))
            .ReturnsAsync(new IdentityRole()
            {
                Id   = "test",
                Name = "test"
            });

            _mockRoleManager.Setup(x => x.UpdateAsync(It.IsAny <IdentityRole>()))
            .ReturnsAsync(IdentityResult.Failed(
                              new IdentityError[] { })
                          );

            var rolesController = new RolesController(_mockRoleManager.Object, _context);

            var result = await rolesController.PutRole("test", new RoleCreateRequest()
            {
                Id   = "test",
                Name = "test"
            });

            Assert.NotNull(result);
            Assert.IsType <BadRequestObjectResult>(result);
        }
        public void GetByIdAsync_Return_NotFound()
        {
            //Arrange
            int    expectedStatusCode = 404;
            string expectedMessage    = Messages.ROLE_DOES_NOT_EXIST;

            RoleDomainModel roleDomainModel = null;

            Task <RoleDomainModel> responseTask = Task.FromResult(roleDomainModel);

            _roleService = new Mock <IRoleService>();
            _roleService.Setup(x => x.GetByIdAsync(It.IsAny <int>())).Returns(responseTask);
            RolesController rolesController = new RolesController(_roleService.Object);

            //Act
            var    result     = rolesController.GetByIdAsync(123).ConfigureAwait(false).GetAwaiter().GetResult().Result;
            var    resultList = ((NotFoundObjectResult)result).Value;
            string roleResult = (string)resultList;

            //Assert
            Assert.IsNotNull(roleResult);
            Assert.IsInstanceOfType(result, typeof(NotFoundObjectResult));
            Assert.AreEqual(expectedStatusCode, ((NotFoundObjectResult)result).StatusCode);
            Assert.AreEqual(expectedMessage, roleResult);
        }
        public void TestMethodGetRoles()
        {
            RolesController rolesController = new RolesController();
            var             result          = rolesController.Get();

            Assert.AreNotEqual(null, result);
        }
Exemplo n.º 22
0
        public async Task Verificar_PostRol()
        {
            Rol nuevo = new Rol {
                Id = 3, Nombre = "Anciano"
            };
            RolCreateDTO nuevoCreate = new RolCreateDTO {
                Nombre = "Anciano"
            };
            var mockMapper = new MapperConfiguration(cfg =>
            {
                cfg.AddProfile(new MappingProfile());
            });
            var mapper     = mockMapper.CreateMapper();
            var repository = new Mock <IRolRepository>();

            repository.Setup(x => x.Save(It.IsAny <Rol>())).ReturnsAsync(nuevo).Verifiable();
            var controller = new RolesController(repository.Object, mapper);

            //act
            var actionResult = await controller.Post(nuevoCreate);

            var result = actionResult.Result as CreatedAtRouteResult;
            var dto    = result.Value as RolDTO;

            Assert.Equal(3, dto.Id);
        }
Exemplo n.º 23
0
        public async Task AddRole_returns_error_string_when_role_has_special_characters()
        {
            //Arrange
            var controller = new RolesController(_configuration, _contextAccessor);

            Role role = new Role
            {
                Id   = new Guid(),
                Name = "Admin!@#$"
            };

            dynamic roleObj = new ExpandoObject();

            roleObj.Role = role;

            JObject data = JObject.FromObject(roleObj);

            //Act
            var result = await controller.AddRole(data);

            //Assert
            var messageResult = Assert.IsType <string>(result);                          //Asserting that the return is a String

            Assert.Contains("Name cannot be contain special characters", messageResult); //Asserting that message is equal as mentioned
        }
Exemplo n.º 24
0
        public async Task Get()
        {
            var role = new RoleEdit()
            {
                Id            = Guid.NewGuid(),
                Name          = "role_1",
                Description   = "Role 1",
                ApplicationId = Guid.NewGuid(),
                UseCaseIds    = new List <string>()
                {
                    "uc1"
                }
            };

            var service = new Mock <IRoleService>();

            service.Setup(c => c.GetRole(It.Is <Guid>(m => m == role.Id.Value)))
            .ReturnsAsync(role);

            var controller = new RolesController(service.Object);

            var result = await controller.Get(role.Id.Value);

            var okResult    = Assert.IsType <OkObjectResult>(result);
            var returnValue = Assert.IsType <RoleEdit>(okResult.Value);

            Assert.Same(role, returnValue);
        }
Exemplo n.º 25
0
        public async Task AddRole_returns_error_string_when_role_has_same_name()
        {
            //Arrange
            var controller = new RolesController(_bosAuthClient);

            Role role = new Role
            {
                Id   = new Guid(),
                Name = "Admin"
            };

            dynamic roleObj = new ExpandoObject();

            roleObj.Role = role;

            JObject data = JObject.FromObject(roleObj);

            //Act
            var result = await controller.AddRole(data);

            //Assert
            var messageResult = Assert.IsType <string>(result);                     //Asserting that the return is a String

            Assert.Contains("A role with that name already exists", messageResult); //Asserting that message is equal as mentioned
        }
Exemplo n.º 26
0
        public async Task GetById_ThrowException_Failed()
        {
            _mockRoleManager.Setup(x => x.FindByIdAsync(It.IsAny <string>())).Throws <Exception>();

            var rolesController = new RolesController(_mockRoleManager.Object, _mapper, _context, _localizer);

            await Assert.ThrowsAnyAsync <Exception>(async() => await rolesController.GetById("test1"));
        }
Exemplo n.º 27
0
        public void RolesTest()
        {
            var controller = new RolesController();
            //Returns roles array
            var result = controller.Get();

            Assert.IsNotNull(result);
        }
Exemplo n.º 28
0
        public void ControllerGetCustomerInvalidId()
        {
            var controller = new RolesController();
            var response   = controller.GetById("ohoho");
            var result     = (NotFoundResult)response;

            Assert.IsNotNull(result);
        }
Exemplo n.º 29
0
        public async Task GetRolesPaging_ThrowException_Failed()
        {
            _mockRoleManager.Setup(x => x.Roles).Throws <Exception>();

            var rolesController = new RolesController(_mockRoleManager.Object, _mapper, _context, _localizer);

            await Assert.ThrowsAnyAsync <Exception>(async() => await rolesController.GetRolesPaging(null, 1, 1));
        }
Exemplo n.º 30
0
        public void ControllerDeleteRoleWithValidID()
        {
            var controller = new RolesController();
            var response   = controller.Delete("SD");
            var result     = (OkResult)response;

            Assert.IsNotNull(result);
        }
Exemplo n.º 31
0
        public RolesControllerTests()
        {
            validator = Substitute.For<IRoleValidator>();
            service = Substitute.For<IRoleService>();
            role = new RoleView();

            controller = Substitute.ForPartsOf<RolesController>(validator, service);
            controller.ControllerContext = new ControllerContext();
            controller.ControllerContext.RouteData = new RouteData();
        }
Exemplo n.º 32
0
        public void Init()
        {
            _ctrl = new RolesController(new FakeRolesRepository());

            var config = new HttpConfiguration();
            var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/be/api");
            var route = config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}");
            var routeData = new HttpRouteData(route, new HttpRouteValueDictionary { { "controller", "roles" } });

            _ctrl.ControllerContext = new HttpControllerContext(config, routeData, request);
            _ctrl.Request = request;
            _ctrl.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config;
        }
Exemplo n.º 33
0
        public static void Populate(this DropDownList ddl, DropDownType type, string defaultSelectionValue = null, bool retainFirst = false)
        {
            switch (type)
            {
                case DropDownType.Role:
                    using (RolesController rc = new RolesController())
                    {
                        var roles = rc.Get().Select(i => new { Label = i.RoleName, Value = i.RoleID }).OrderBy(i => i.Label).ToList();
                        ddl.DataSource = roles;
                    }
                    break;

                case DropDownType.ScopeType:
                    using (ScopesController sc = new ScopesController())
                    {
                        var scopes = sc.Get().Select(i => new { Label = i.ScopeName, Value = i.ScopeID }).OrderBy(i => i.Label).ToList();
                        ddl.DataSource = scopes;
                    }
                    break;

                case DropDownType.Permission:
                    using (PermissionsController pc = new PermissionsController())
                    {
                        var permissions = pc.Get().Select(i => new { Label = i.PermissionName, Value = i.PermissionID }).OrderBy(i => i.Label).ToList();
                        ddl.DataSource = permissions;
                    }
                    break;

                default: break;
            }

            Reset(ddl, retainFirst);
            ddl.DataValueField = "Value";
            ddl.DataTextField = "Label";
            ddl.DataBind();

            SelectDefault(ddl, defaultSelectionValue);
        }
 public void SetUp()
 {
     rolesController = new RolesController();
     userId = 2;
 }