public AddToRole()
{
_addToRoleRequest = new AddToRoleRequest
{
Role = "Admin",
UserId = "UserId"
};
_user = new ApplicationUser();
_userManager.Setup(um => um.FindByIdAsync(_addToRoleRequest.UserId))
.ReturnsAsync(_user);
}
public async Task AddUserToRoleAsync_WhenUserNotFoundById_ReturnsNoAccountsRegisteredWithCurrentEmail()
{
var request = new AddToRoleRequest
{
UserId = Guid.NewGuid(),
RoleName = "role"
};
var httpResponse = await PostAsync(RoleControllerRoutes.AddToRole, request);
httpResponse.EnsureSuccessStatusCode();
var response = await httpResponse.BodyAs <ApiResponse>();
response.ResponseException !.ErrorMessage.Should().Be($"No Accounts Registered with id {request.UserId}.");
response.ResponseException.ErrorCode.Should().Be(ErrorCode.UserNotFound);
}
public async Task AddUserToRoleAsync_WhenUserNotFound_ShouldReturnUserNotFound()
{
var request = new AddToRoleRequest()
{
UserId = Guid.NewGuid(),
RoleName = "engineer"
};
this._mockUserManger.Setup(e => e.FindByIdAsync(request.UserId.ToString()))
.ReturnsAsync((User)null);
var result = await sut.AddUserToRoleAsync(request);
result.IsSuccess.Should().BeFalse();
result.ResponseException.Should().NotBeNull();
result.ResponseException !.ErrorCode.Should().Be(ErrorCode.UserNotFound);
result.ResponseException.ErrorMessage.Should().Be($"No Accounts Registered with id {request.UserId}.");
}
public async Task AddUserToRoleAsync_WhenRequestValid_ReturnsSuccessResponse()
{
var context = GetService <TimeTrackingIdentityDbContext>();
var userInDatabase = await context.Users.LastAsync();
var request = new AddToRoleRequest
{
UserId = userInDatabase.Id,
RoleName = "TeamLead"
};
var httpResponse = await PostAsync(RoleControllerRoutes.AddToRole, request);
httpResponse.EnsureSuccessStatusCode();
var response = await httpResponse.BodyAs <ApiResponse>();
response.StatusCode.Should().Be(200);
response.IsSuccess.Should().BeTrue();
}
public async Task AddUserToRoleAsync_WhenNoSuchRoleExistsAsync_ReturnsNoSuchRoleExistsAsync()
{
var context = GetService <TimeTrackingIdentityDbContext>();
var userInDatabase = await context.Users.LastAsync();
var request = new AddToRoleRequest
{
UserId = userInDatabase.Id,
RoleName = "role"
};
var httpResponse = await PostAsync(RoleControllerRoutes.AddToRole, request);
httpResponse.EnsureSuccessStatusCode();
var response = await httpResponse.BodyAs <ApiResponse>();
response.ResponseException !.ErrorCode.Should().Be(ErrorCode.RoleNotFound);
response.ResponseException !.ErrorMessage.Should().Be($"Role {request.RoleName} not found.");
}
public async Task AddUserToRoleAsync_WhenRoleNotFound_ShouldReturnUserNotFound()
{
var request = new AddToRoleRequest()
{
UserId = Guid.NewGuid(),
RoleName = "engineer"
};
this._mockUserManger.Setup(e => e.FindByIdAsync(request.UserId.ToString()))
.ReturnsAsync(new User());
this._mockRoleManger.Setup(t => t.RoleExistsAsync(request.RoleName))
.ReturnsAsync(false);
var result = await sut.AddUserToRoleAsync(request);
result.IsSuccess.Should().BeFalse();
result.ResponseException.Should().NotBeNull();
result.ResponseException !.ErrorCode.Should().Be(ErrorCode.RoleNotFound);
result.ResponseException.ErrorMessage.Should().Be($"Role {request.RoleName} not found.");
}
public async Task AddUserToRoleAsync_WhenAddToRoleSuccess_ShouldReturnSuccess()
{
var request = new AddToRoleRequest()
{
UserId = Guid.NewGuid(),
RoleName = "engineer"
};
var user = new User();
this._mockUserManger.Setup(e => e.FindByIdAsync(request.UserId.ToString()))
.ReturnsAsync(user);
this._mockRoleManger.Setup(t => t.RoleExistsAsync(request.RoleName))
.ReturnsAsync(true);
this._mockUserManger.Setup(e => e.AddToRoleAsync(user, request.RoleName))
.ReturnsAsync(IdentityResult.Success);
var result = await sut.AddUserToRoleAsync(request);
result.IsSuccess.Should().BeTrue();
result.StatusCode.Should().Be(200);
}
public async Task <ApiResponse> AddUserToRoleAsync(AddToRoleRequest model)
{
var user = await _userManager.FindByIdAsync(model.UserId.ToString());
if (user == null)
{
return(new ApiResponse(
new ApiError()
{
ErrorCode = ErrorCode.UserNotFound,
ErrorMessage = $"No Accounts Registered with id {model.UserId}.",
}));
}
if (!await _roleManager.RoleExistsAsync(model.RoleName))
{
return(new ApiResponse(
new ApiError()
{
ErrorCode = ErrorCode.RoleNotFound,
ErrorMessage = $"Role {model.RoleName} not found.",
}));
}
var addUserResponse = await _userManager.AddToRoleAsync(user, model.RoleName);
if (!addUserResponse.Succeeded)
{
_logger.LogWarning("Failed to add user {0} to role by reason {1}", model.UserId, addUserResponse.Errors);
return(new ApiResponse(
new ApiError()
{
ErrorCode = ErrorCode.AddToRoleFailed,
ErrorMessage = $"Add user {model.UserId} to role {model.RoleName} failed.",
}));
}
return(ApiResponse.Success());
}
public async Task AddUserToRoleAsync_WhenAddToRoleFailed_ShouldReturnAddToRoleFailed()
{
var request = new AddToRoleRequest()
{
UserId = Guid.NewGuid(),
RoleName = "engineer"
};
var user = new User();
this._mockUserManger.Setup(e => e.FindByIdAsync(request.UserId.ToString()))
.ReturnsAsync(user);
this._mockRoleManger.Setup(t => t.RoleExistsAsync(request.RoleName))
.ReturnsAsync(true);
this._mockUserManger.Setup(e => e.AddToRoleAsync(user, request.RoleName))
.ReturnsAsync(IdentityResult.Failed());
var result = await sut.AddUserToRoleAsync(request);
result.IsSuccess.Should().BeFalse();
result.ResponseException.Should().NotBeNull();
result.ResponseException !.ErrorCode.Should().Be(ErrorCode.AddToRoleFailed);
result.ResponseException.ErrorMessage.Should().Be($"Add user {request.UserId} to role {request.RoleName} failed.");
}
public async Task <IActionResult> AddToRole([FromBody] AddToRoleRequest model)
{
if (model.Role != "Admin" && model.Role != "Teacher")
{
return(BadRequest(nameof(model.Role)));
}
var user = await _userManager.FindByIdAsync(model.UserId);
if (user == null)
{
return(BadRequest(nameof(model.UserId)));
}
var result = await _userManager.AddToRoleAsync(user, model.Role);
if (result.Succeeded)
{
return(Ok());
}
return(BadRequest());
}
public async Task <ApiResponse> AddToRole([FromBody] AddToRoleRequest request)
{
return(await _roleService.AddUserToRoleAsync(request));
}
