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));
}