public async Task Create_Post_UserAlreadyExists_NotSaveUser_RedirectToListWithErrorMessage()
{
// Arrange
var mockUserRepository = new Mock <IUserRepository>();
mockUserRepository.Setup(x => x.GetUserByUserNameAsync(It.IsAny <string>())).ReturnsAsync(_user1);
var sut = new UsersController(null, null, null, _mockRoleRepository.Object,
mockUserRepository.Object, null);
var expectedModel = new UserCreateUpdateViewModel {
UserName = _user1.UserName
};
// Act
var result = await sut.Create(expectedModel);
// Assert
mockUserRepository.Verify(x => x.GetUserByUserNameAsync(It.IsAny <string>()), Times.Once);
mockUserRepository.Verify(x => x.AddUserAsync(It.IsAny <User>()), Times.Never);
_mockRoleRepository.Verify(x => x.GetAllRolesAsync(), Times.Never);
var alertDecoratorResult = Assert.IsType <AlertDecoratorResult>(result);
Assert.Equal(alertDecoratorResult.Message,
$"User with same username {expectedModel.UserName} alredy exists.");
var redirectToActionResult = Assert.IsType <RedirectToActionResult>(alertDecoratorResult.InnerResult);
Assert.False(redirectToActionResult.Permanent);
Assert.Equal(redirectToActionResult.ActionName, "List");
}
public async Task <IActionResult> Create(UserCreateUpdateViewModel model)
{
return(await TryGetActionResultAsync(async() =>
{
if (!ModelState.IsValid)
{
return View(model);
}
var user = _mapper.Map <UserDto>(model);
var result = await UserService.CreateAsync(user);
switch (result.Status)
{
case ServiceResponseStatus.NotFound:
case ServiceResponseStatus.InvalidOperation:
TempData["Error"] = "Не удалось создать пользователя.";
return RedirectToAction("Index");
case ServiceResponseStatus.AlreadyExists:
ModelState.AddModelError("Login", "Пользователь с таким логином уже существует.");
return View(model);
}
TempData["Success"] = $"Пользователь \"{model.Login}\" был успешно создан.";
return RedirectToAction("Index");
}, OnFault));
}
public async Task Edit_Post_InvalidId_NotSaveUserAndRedirectToListWithErrorMessage(int id)
{
// Arrange
var mockUserRepository = new Mock <IUserRepository>();
mockUserRepository.Setup(x => x.GetUserByIdAsync(It.IsAny <int>())).ReturnsAsync((User)null);
var sut = new UsersController(null, null, null, null, mockUserRepository.Object, null);
var model = new UserCreateUpdateViewModel {
Id = id, UserName = _user1.UserName
};
// Act
var result = await sut.Edit(model);
// Assert
mockUserRepository.Verify(x => x.GetUserByIdAsync(It.IsAny <int>()), Times.Once);
mockUserRepository.Verify(x => x.UpdateUserAsync(It.IsAny <User>()), Times.Never);
var alertDecoratorResult = Assert.IsType <AlertDecoratorResult>(result);
Assert.Equal(alertDecoratorResult.Message, "Please select a user.");
var redirectToActionResult = Assert.IsType <RedirectToActionResult>(alertDecoratorResult.InnerResult);
Assert.False(redirectToActionResult.Permanent);
Assert.Equal("List", redirectToActionResult.ActionName);
}
public async Task Create_Post_InvalidModel_NotSaveUser_ReturnViewResult()
{
// Arrange
var mockUserRepository = new Mock <IUserRepository>();
var sut = new UsersController(null, null, null, _mockRoleRepository.Object, null, null);
sut.ModelState.AddModelError("x", "Test Error");
var expectedModel = new UserCreateUpdateViewModel {
UserName = "******"
};
// Act
var result = await sut.Create(expectedModel);
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
Assert.Equal("Create", viewResult.ViewName);
var model = Assert.IsType <UserCreateUpdateViewModel>(viewResult.Model);
Assert.Equal(expectedModel.UserName, model.UserName);
Assert.Equal(2, model.AvailableRoles.Count);
mockUserRepository.Verify(x => x.AddUserAsync(It.IsAny <User>()), Times.Never);
}
public async Task Edit_Post_ValidId_SaveUserAndRedirectToListWithSuccessfulMessage()
{
// Arrange
User savedUser = null;
var mockUserRepository = new Mock <IUserRepository>();
mockUserRepository.Setup(x => x.GetUserByIdAsync(_user1.Id)).ReturnsAsync(_user1);
mockUserRepository.Setup(x => x.UpdateUserAsync(It.IsAny <User>()))
.Returns(Task.CompletedTask)
.Callback <User>(x => savedUser = x);
var mockRoleRepository = new Mock <IRoleRepository>();
mockRoleRepository.Setup(x => x.GetAllRolesAsync()).ReturnsAsync(_roles);
mockRoleRepository.Setup(x => x.GetUserRolesForUserAsync(_user1.Id)).ReturnsAsync(new List <UserRole>());
var mockUserSession = new Mock <IUserSession>();
mockUserSession.Setup(x => x.UserName).Returns("johndoe");
var sut = new UsersController(_mockDateTime.Object, _mapper, null, mockRoleRepository.Object,
mockUserRepository.Object, mockUserSession.Object);
var model = new UserCreateUpdateViewModel
{
Id = _user1.Id,
UserName = _user1.UserName,
FirstName = _user1.FirstName,
SelectedRoleIds = new List <int> {
1
}
};
// Act
var result = await sut.Edit(model);
// Assert
mockUserRepository.Verify(x => x.GetUserByIdAsync(It.IsAny <int>()), Times.Once);
_mockDateTime.Verify(x => x.Now, Times.Once);
mockUserSession.Verify(x => x.UserName, Times.Once);
mockRoleRepository.Verify(x => x.GetAllRolesAsync(), Times.Once);
mockRoleRepository.Verify(x => x.GetUserRolesForUserAsync(It.IsAny <int>()), Times.Once);
mockUserRepository.Verify(x => x.UpdateUserAsync(It.IsAny <User>()), Times.Once);
Assert.Equal(model.Id, savedUser.Id);
Assert.Equal(model.UserName, savedUser.UserName);
Assert.Equal(model.FirstName, savedUser.FirstName);
var alertDecoratorResult = Assert.IsType <AlertDecoratorResult>(result);
Assert.Equal(alertDecoratorResult.Message, $"{_user1.FirstName}'s account was updated successfully.");
var redirectToActionResult = Assert.IsType <RedirectToActionResult>(alertDecoratorResult.InnerResult);
Assert.False(redirectToActionResult.Permanent);
Assert.Equal("List", redirectToActionResult.ActionName);
}
public async Task <IActionResult> Create()
{
var model = new UserCreateUpdateViewModel
{
AvailableRoles = await GetAvailableRoles(),
IsActive = true
};
return(View("Create", model));
}
public async Task <IActionResult> Edit(UserCreateUpdateViewModel model)
{
if (ModelState.IsValid)
{
var user = await _userRepository.GetUserByIdAsync(model.Id);
if (user == null)
{
return(RedirectToAction("List").WithError("Please select a user."));
}
var dateTimeNow = _dateTime.Now;
var username = _userSession.UserName;
user = _mapper.Map(model, user);
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.IsActive = model.IsActive;
user.LastLoginDate = dateTimeNow;
user.ModifiedOn = dateTimeNow;
user.ModifiedBy = username;
var allRoles = await _roleRepository.GetAllRolesAsync();
var allUserRoles = await _roleRepository.GetUserRolesForUserAsync(model.Id);
foreach (var role in allRoles)
{
if (model.SelectedRoleIds.Any(r => r == role.Id))
{
if (allUserRoles.All(r => r.RoleId != role.Id))
{
user.UserRoles.Add(new UserRole {
User = user, Role = role
});
}
}
else if (allUserRoles.Any(r => r.RoleId == role.Id))
{
var removingUserRole = allUserRoles.FirstOrDefault(r => r.RoleId == role.Id);
user.UserRoles.Remove(removingUserRole);
}
}
await _userRepository.UpdateUserAsync(user);
return(RedirectToAction("List").WithSuccess($"{user.FirstName}'s account was updated successfully."));
}
// If we got this far, something failed, redisplay form
model.AvailableRoles = await GetAvailableRoles();
return(View(model));
}
public async Task <IActionResult> Create(UserCreateUpdateViewModel model)
{
if (ModelState.IsValid)
{
var checkingUser = await _userRepository.GetUserByUserNameAsync(model.UserName);
if (checkingUser != null)
{
return(RedirectToAction("List")
.WithError($"User with same username {model.UserName} alredy exists."));
}
var dateTimeNow = _dateTime.Now;
var username = _userSession.UserName;
var user = _mapper.Map <UserCreateUpdateViewModel, User>(model);
user.LastLoginDate = dateTimeNow;
user.CreatedBy = username;
user.CreatedOn = dateTimeNow;
user.ModifiedBy = username;
user.ModifiedOn = dateTimeNow;
var allRoles = await _roleRepository.GetAllRolesAsync();
foreach (var role in allRoles)
{
if (model.SelectedRoleIds.Any(r => r == role.Id))
{
user.UserRoles.Add(new UserRole {
User = user, Role = role
});
}
}
await _userRepository.AddUserAsync(user);
return(RedirectToAction("List").WithSuccess($"{user.FirstName}'s account was created successfully."));
}
// If we got this far, something failed, redisplay form
model.AvailableRoles = await GetAvailableRoles();
return(View("Create", model));
}
public async Task Create_Post_ValidUser_SaveUserAndRedirectToListWithSuccessfulMessage()
{
// Arrange
var mockUserRepository = new Mock <IUserRepository>();
mockUserRepository.Setup(x => x.GetUserByUserNameAsync(It.IsAny <string>())).ReturnsAsync((User)null);
mockUserRepository.Setup(x => x.AddUserAsync(It.IsAny <User>())).ReturnsAsync(1);
var mockUserSession = new Mock <IUserSession>();
mockUserSession.Setup(x => x.UserName).Returns("johndoe");
var sut = new UsersController(_mockDateTime.Object, _mapper, null, _mockRoleRepository.Object,
mockUserRepository.Object, mockUserSession.Object);
var model = new UserCreateUpdateViewModel {
UserName = _user1.UserName, FirstName = _user1.FirstName
};
// Act
var result = await sut.Create(model);
// Assert
mockUserRepository.Verify(x => x.GetUserByUserNameAsync(It.IsAny <string>()), Times.Once);
_mockDateTime.Verify(x => x.Now, Times.Once);
_mockRoleRepository.Verify(x => x.GetAllRolesAsync(), Times.Once);
mockUserRepository.Verify(x => x.AddUserAsync(It.IsAny <User>()), Times.Once);
var alertDecoratorResult = Assert.IsType <AlertDecoratorResult>(result);
Assert.Equal(alertDecoratorResult.Message, $"{_user1.FirstName}'s account was created successfully.");
var redirectToActionResult = Assert.IsType <RedirectToActionResult>(alertDecoratorResult.InnerResult);
Assert.False(redirectToActionResult.Permanent);
Assert.Equal("List", redirectToActionResult.ActionName);
}
