public void Create_ShouldThrowDomainValidationException_WhenCommandIsInvalid(CreateRoleCommand command, ValidationError[] errors) { var ex = Assert.Throws <DomainValidationException>(() => Role.Create(command)); Assert.Equal(errors.Length, ex.ValidationErrors.Count()); Assert.Contains(errors, item => ex.ValidationErrors.Any(err => err.Code == item.Code && err.Member == item.Member)); }
public async Task CreateRoleAsync_Should_Return_CreatedAtRouteResult_With_GetRoleResponse() { var createRoleRequest = new CreateRoleRequest { Name = DefaultRoleEnumeration.Administrator.DisplayName }; var createRoleCommand = new CreateRoleCommand(Guid.NewGuid(), createRoleRequest.Name); var roleOutputQuery = new RoleOutputQuery(createRoleCommand.RoleId, Array.Empty <byte>(), createRoleCommand.Name); var getRoleResponse = new GetRoleResponse(roleOutputQuery.Id, roleOutputQuery.RowVersion, roleOutputQuery.Name); _mapperMock.Setup(x => x.Map <CreateRoleRequest, CreateRoleCommand>(It.IsAny <CreateRoleRequest>())).Returns(createRoleCommand); _communicationBusMock.Setup(x => x.SendCommandAsync(It.IsAny <CreateRoleCommand>(), It.IsAny <CancellationToken>())) .Returns(Task.CompletedTask); _getRoleQueryHandlerMock .Setup(x => x.HandleAsync(It.IsAny <GetRoleInputQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(roleOutputQuery); _mapperMock.Setup(x => x.Map <RoleOutputQuery, GetRoleResponse>(It.IsAny <RoleOutputQuery>())).Returns(getRoleResponse); var result = await _controller.CreateRoleAsync(createRoleRequest); var createdAtRouteResult = result.As <CreatedAtRouteResult>(); createdAtRouteResult.Value.Should().BeEquivalentTo(getRoleResponse); createdAtRouteResult.RouteName.Should().BeEquivalentTo("GetRole"); createdAtRouteResult.RouteValues.Should().BeEquivalentTo(new Microsoft.AspNetCore.Routing.RouteValueDictionary(new { id = roleOutputQuery.Id })); }
public async Task <IActionResult> CreateRoleAsync(RoleCreatingRequest request) { var command = new CreateRoleCommand(request.Name, request.Description, request.PermissionIds); var result = await _commandBus.PublishAsync(command).ConfigureAwait(false); return(GenerateActionResult(result)); }
public async Task ShouldCreateNewWithPermissions() { // Arrange Guid expectedId = Guid.NewGuid(); ICollection <Guid> expectedPermissionIds = new List <Guid> { Guid.NewGuid(), Guid.NewGuid() }; var repository = new Mock <IRoleRepository>(); CreateRoleCommand cmd = new CreateRoleCommand(expectedId, "Name", "Code", expectedPermissionIds); RoleCommandHandler actual = new RoleCommandHandler(repository.Object); // Act await actual.HandleAsync(cmd); // Assert repository.Verify(e => e.Add(It.Is <Role>(a => a.Id == expectedId && a.RolePermissions != null && a.RolePermissions.Count == expectedPermissionIds.Count) ), Times.Once ); }
public void Validate_GivenAllPropertiesAreValid_ExpectValidationSuccess() { var cmd = new CreateRoleCommand("name", new List <Guid>()); var validator = new CreateRoleCommandValidator(); var result = validator.Validate(cmd); Assert.True(result.IsValid); }
public static Domain.User.Role ToRole(this CreateRoleCommand res) => new Domain.User.Role { Name = res.Name, ConfigSystem = res.ConfigSystem, CreateDocuments = res.CreateDocuments, DeleteDocuments = res.DeleteDocuments, };
public void Constructor_GiveValidArguments_PropertiesAreSet() { var command = new CreateRoleCommand("name", new List <Guid> { TestVariables.ResourceId }); Assert.Equal("name", command.Name); Assert.Single(command.Resources); }
public async Task <ActionResult> Create(CreateRoleCommand command) { if (await Mediator.Send(command) == null) { return(BadRequest()); } return(RedirectToAction("Index")); }
public IRole CreateRole(string name, string description, string externalGroupName) { userContext.CheckPermission(Permissions.RoleMaintenance); Guid id = Guid.NewGuid(); var command = new CreateRoleCommand(id, name, description, externalGroupName); commandBus.Value.Send(Envelope.Create(command)); return(GetRole(id)); }
public async Task <CreateRoleCommandResponse> Post(string name, string description) { var createRoleCommand = new CreateRoleCommand { Name = name, Description = description }; var result = await _mediator.Send(createRoleCommand); return(result); }
public async Task <IActionResult> CreateRole(CreateRoleCommand command) { if (!ModelState.IsValid) { return(View(command)); } await Mediator.Send(command); return(RedirectToAction(nameof(GetRoleList))); }
public async Task <IActionResult> Get([FromForm] CreateRoleCommand command) { var result = await _handler.Handler(command); if (result.Succeeded) { result.Message = _localizer.GetString("ROLE_CREATED_SUCCESS").Value; return(Ok(result)); } result.Message = _localizer.GetString("ROLE_CREATED_FAILED").Value; return(NotFound(result)); }
public void Validate_GivenNameIsNull_ExpectValidationFailure() { var cmd = new CreateRoleCommand(null, new List <Guid>()); var validator = new CreateRoleCommandValidator(); var result = validator.Validate(cmd); Assert.False(result.IsValid); Assert.Contains( result.Errors, failure => failure.ErrorCode.Equals(ValidationCodes.FieldIsRequired) && failure.PropertyName == "Name"); }
public async Task CreateRoleHandler_FluentValidationHandler_ThrowsValidationException() { //Setup var command = new CreateRoleCommand(new CreateRoleDto { ApplicationId = Guid.NewGuid() }); var validator = new CreateRoleCommandValidator(); //Action var result = await validator.ValidateAsync(command); //Assert Assert.Contains(result.Errors, o => o.ErrorMessage == "RoleName cannot be empty"); }
public async Task <RoleEditViewModel> CreateAsync([FromForm] RoleEditViewModel model) { var command = new CreateRoleCommand(model.Name, model.Desc, model.UserIds); await _bus.SendCommand(command); if (_notifications.HasNotifications()) { var errorMessage = _notifications.GetNotificationMessage(); throw new GirvsException(StatusCodes.Status400BadRequest, errorMessage); } model.Id = command.Id; return(model); }
public override async Task <GuidRequired> CreateRole(CreateRoleRequest request, ServerCallContext context) { var command = new CreateRoleCommand { Name = request.Name, IsEnabled = request.IsEnabled, PermissionIds = request.PermissionIds .Select(x => (Guid)x) .ToList(), }; var result = await _authorizationApp.CreateRoleAsync(command); return(result); }
public async Task <Result <CreateRoleCommandResult, ErrorData> > Handle( CreateRoleCommand request, CancellationToken cancellationToken) { var result = await this.Process(request, cancellationToken); var dbResult = await this._roleRepository.UnitOfWork.SaveEntitiesAsync(cancellationToken); if (!dbResult) { return(Result.Fail <CreateRoleCommandResult, ErrorData>(new ErrorData( ErrorCodes.SavingChanges, "Failed To Save Database"))); } return(result); }
public static Role Create(CreateRoleCommand command) { command.Validate(true); var role = new Role { Name = command.Name, }; role.AddEvent(new RoleCreatedEvent(role) { Name = role.Name }); return(role); }
public async Task <ActionResult <BaseCommandResponse> > CreateRoleAysnc([FromBody] CreateRoleCommand request) { try { request.SetUser(User.GetUserId()); var response = await _mediator.Send(request); return(Ok(response)); } catch (Exception ex) { _logger.Error(ex, $"Operation failed into controller {Routes.Create_Role} with message: {ex.Message}"); return(BadRequest(ex.Message)); } }
private async Task <Result <CreateRoleCommandResult, ErrorData> > Process( CreateRoleCommand request, CancellationToken cancellationToken) { var presenceResult = await this._roleQueries.CheckForPresenceOfRoleByName(request.Name, cancellationToken); if (presenceResult.IsPresent) { return(Result.Fail <CreateRoleCommandResult, ErrorData>(new ErrorData(ErrorCodes.RoleAlreadyExists))); } var role = this._roleRepository.Add(new Role(Guid.NewGuid(), request.Name)); role.SetResources(request.Resources); return(Result.Ok <CreateRoleCommandResult, ErrorData>(new CreateRoleCommandResult(role.Id))); }
public async Task <Guid> CreateRoleAsync(CreateRoleCommand command) { var role = new Role(command.Name, command.IsEnabled); var permissionIdsToAssign = command.PermissionIds; var permissionsToAssign = await _permissionRepository.GetPermissionsAsync(x => permissionIdsToAssign.Contains(x.Id)); foreach (var permission in permissionsToAssign) { role.AssignPermission(permission); } _roleRepository.Add(role); await _unitOfWork.CommitAsync(); return(role.Id); }
public async Task HandleAsync_Should_Create_Role() { var createRoleCommand = new CreateRoleCommand(Guid.NewGuid(), DefaultRoleEnumeration.Administrator.DisplayName); var role = new Role(createRoleCommand.RoleId, Array.Empty <byte>(), createRoleCommand.Name); var nameIsNotTakenVerificationResult = VerificationResult.Ok(); _roleVerificationServiceMock.Setup(x => x.VerifyNameIsNotTakenAsync(It.IsAny <string>())) .ReturnsAsync(nameIsNotTakenVerificationResult); _mapperMock.Setup(x => x.Map <CreateRoleCommand, Role>(It.IsAny <CreateRoleCommand>())).Returns(role); _roleRepositoryMock.Setup(x => x.AddAsync(It.IsAny <Role>())).Returns(Task.CompletedTask).Verifiable(); Func <Task> result = async() => await _commandHandler.HandleAsync(createRoleCommand); await result.Should().NotThrowAsync <Exception>(); _roleRepositoryMock.Verify(x => x.AddAsync(It.Is <Role>(r => r == role)), Times.Once); }
public async Task <IActionResult> Post([FromBody] CreateRoleCommand command) { try { var role = await _mediator.Send(command); return(Ok(role)); } catch (KeyNotFoundException ex) { return(NotFound()); } catch (ArgumentException argumentException) { return(BadRequest(argumentException.Message)); } }
public async Task CanCreateAndDeleteRole() { //Arrange var facade = _fixture.Facade; var roleName = Guid.NewGuid().ToString(); var command = new CreateRoleCommand(roleName, "{\"Version\": \"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Action\":\"sts:AssumeRole\", \"Principal\":{ \"AWS\": \"642375522597\" }}]}"); //Act var result = await facade.Execute(command); var result2 = await facade.Execute(new DeleteRoleCommand(result.RoleName)); //Assert Assert.NotNull(result); Assert.Equal(roleName, result.RoleName); Assert.True(result2.IsCompletedSuccessfully); }
public async Task HandleAsync_Should_Throw_ConflictException_When_Name_Is_Already_Used() { var createRoleCommand = new CreateRoleCommand(Guid.NewGuid(), DefaultRoleEnumeration.Administrator.DisplayName); var errors = new Collection <IError> { new Error(RoleErrorCodeEnumeration.NameIsAlreadyTaken, RoleErrorMessage.NameIsAlreadyTaken) }; var nameIsNotTakenVerificationResult = VerificationResult.Fail(errors); _roleVerificationServiceMock.Setup(x => x.VerifyNameIsNotTakenAsync(It.IsAny <string>())) .ReturnsAsync(nameIsNotTakenVerificationResult); Func <Task> result = async() => await _commandHandler.HandleAsync(createRoleCommand); var exceptionResult = await result.Should().ThrowExactlyAsync <ConflictException>(); exceptionResult.And.Errors.Should().BeEquivalentTo(errors); }
public async Task <OperationResult <string> > Handle(CreateRoleCommand request, CancellationToken cancellationToken) { var add = await unitOfWork.RoleRepository.AddAsync(new Role(request.Name, request.Description), cancellationToken); if (add.Success) { try { await unitOfWork.CommitSaveChangeAsync(); } catch (Exception ex) { return(OperationResult <string> .BuildFailure(ex)); } return(OperationResult <string> .BuildSuccessResult("Success Add")); } return(OperationResult <string> .BuildFailure(add.ErrorMessage)); }
public async Task Handle_GivenSavingSucceeds_ExpectSuccessfulResult() { var roleQueries = new Mock <IRoleQueries>(); roleQueries.Setup(x => x.CheckForPresenceOfRoleByName(It.IsAny <string>())) .ReturnsAsync(() => new StatusCheckModel(false)); var roleRepository = new Mock <IRoleRepository>(); var unitOfWork = new Mock <IUnitOfWork>(); unitOfWork.Setup(x => x.SaveEntitiesAsync(It.IsAny <CancellationToken>())).ReturnsAsync(() => true); roleRepository.Setup(x => x.UnitOfWork).Returns(unitOfWork.Object); var handler = new CreateRoleCommandHandler(roleRepository.Object, roleQueries.Object); var cmd = new CreateRoleCommand("name", new List <Guid>()); var result = await handler.Handle(cmd, CancellationToken.None); Assert.True(result.IsSuccess); }
public async Task <RequestResponse> CreateRoleAsync(CreateRoleCommand role) { var existRole = await _roleManager.FindByNameAsync(role.Name); if (existRole == null) { await _roleManager.CreateAsync(new AppRole { Name = role.Name, NormalizedName = role.Name.ToUpper() }); return(RequestResponse.Success()); } else { throw new Exception("The role already exist"); } }
public async Task ShouldCreateNew() { // Arrange Guid expectedId = Guid.NewGuid(); var repository = new Mock <IRoleRepository>(); CreateRoleCommand cmd = new CreateRoleCommand(expectedId, "Name", "Code", null); RoleCommandHandler actual = new RoleCommandHandler(repository.Object); // Act await actual.HandleAsync(cmd); // Assert repository.Verify(e => e.Add(It.Is <Role>(a => a.Id == expectedId) ), Times.Once ); }
public async Task <ActionResult <RoleViewModel> > Create([FromBody] CreateRoleCommand newRole) { if (newRole == null) { return(StatusCode(400)); } if (!ModelState.IsValid) { return(StatusCode(422)); } var result = await _Mediator.Send(newRole); var role = await _Mediator.Send(new GetRoleByIdQuery() { Id = result }); return(StatusCode(201, role)); }