public async Task Should_Throw_NotFoundException_In_Update_User_Profile_When_User_Not_Found()
{
//Arrange
Mock <IUserManagerService> userManagerService = new Mock <IUserManagerService>();
Mock <IIdentityDataContext> identityDataContext = new Mock <IIdentityDataContext>();
var message = new UpdateUserInfoCommand(
id: 1,
firstName: "Test2",
lastName: "Test2"
);
var applicationUser = new ApplicationUser()
{
Email = String.Empty,
UserName = String.Empty,
FirstName = "Test",
LastName = "Test",
Id = 1,
PasswordHash = String.Empty
};
userManagerService.Setup(r => r.GetUserById(It.Is <int>(id => id == message.Id)))
.Returns(Task.FromResult(applicationUser));
userManagerService.Setup(r => r.UpdateProfile(It.IsAny <int>(), It.IsAny <String>(), It.IsAny <String>()))
.Throws <NotFoundException>();
var sut = new UpdateUserInfoCommandHandler(identityDataContext.Object, userManagerService.Object);
//Act/Assert
await Assert.ThrowsAsync <NotFoundException>(async() => { await sut.Handle(message, default); });
}
public virtual async Task <IActionResult> UpdateUserInfo(
[FromBody][ModelBinder(BinderType = typeof(UserCommandModelBinder))] UpdateUserInfoCommand profileUpdateCommand)
{
await this._commandDispather.HandleAsync <UpdateUserInfoCommand>(profileUpdateCommand);
return(NoContent());
}
public async Task <UserDetailsDto> UpdateUserRoleOrTeam([FromRoute] Guid userId,
[FromBody] UserForUpdateDto dto)
{
var command = new UpdateUserInfoCommand
{
UserForUpdateDto = dto
};
command.UserForUpdateDto.UserId = userId;
return(await _mediator.Send(command));
}
public void UserCommandHandler_Handle_UpdateUserInfoCommand_EditExistingUser_InvalidEmail()
{
IRequestHandler <UpdateUserInfoCommand, bool> handler = GetCommandHandlerInstance();
var commandData = new UpdateUserInfoCommand()
{
Id = MarkId, Email = "*****@*****.**", Name = "Mark Zuckerberg"
};
Action action = () => handler.Handle(commandData, default).Wait();
action.Should().Throw <Exception>();
}
public void UserCommandHandler_Handle_UpdateUserInfoCommand_EditExistingUser_ValidEmail()
{
IRequestHandler <UpdateUserInfoCommand, bool> handler = GetCommandHandlerInstance();
var commandData = new UpdateUserInfoCommand()
{
Id = GatesId, Email = "*****@*****.**", Name = "Bill Gates"
};
var result = handler.Handle(commandData, default).Result;
result.Should().BeTrue();
}
public async Task Should_Update_User_Profile()
{
//Arrange
Mock <IUserManagerService> userManagerService = new Mock <IUserManagerService>();
Mock <IIdentityDataContext> identityDataContext = new Mock <IIdentityDataContext>();
var message = new UpdateUserInfoCommand(
id: 1,
firstName: "Test",
lastName: "Test"
);
var applicationUser = new ApplicationUser()
{
Email = String.Empty,
UserName = String.Empty,
FirstName = String.Empty,
LastName = String.Empty,
Id = 1,
PasswordHash = String.Empty
};
userManagerService.Setup(r => r.GetUserById(It.Is <int>(id => id == message.Id)))
.Returns(Task.FromResult(applicationUser));
userManagerService.Setup(r => r.UpdateProfile(It.IsAny <int>(), It.IsAny <String>(), It.IsAny <String>()))
.Returns((int id, string firstName, string lastName) =>
{
applicationUser.FirstName = firstName;
applicationUser.LastName = lastName;
return(Task.FromResult(applicationUser));
});
var sut = new UpdateUserInfoCommandHandler(identityDataContext.Object, userManagerService.Object);
//Act
var result = await sut.Handle(message, default);
//Assert
result.ShouldNotBeNull();
result.ShouldBeOfType <Unit>();
applicationUser.FirstName.ShouldBe(message.FirstName);
applicationUser.LastName.ShouldBe(message.LastName);
}
public async Task <bool> Handle(UpdateUserInfoCommand request, CancellationToken cancellationToken)
{
var userDomain = _UserRepository.GetById(request.Id).Result.ToDomain <User>(_Mapper);
userDomain.SetPersonalInfo(request.Name, request.Email);
await _UserRepository.Update(userDomain.ToModel <Command.User>(_Mapper));
await _UnitOfWork.Commit();
var publishMessage = new Message();
publishMessage.MessageType = "UpdateUser";
publishMessage.SetData(userDomain.ToQueryModel <Query.User>(_Mapper));
await _Bus.SendMessage(publishMessage);
return(true);
}
public async Task <ActionResult> SaveInfo(UserInfoRequest model)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Index"));
}
model.UserId = User.GetUserDbId();
var cmd = new UpdateUserInfoCommand(0, model);
await CommandBus.Send(cmd);
var isOk = cmd.Response.ResponseObj;
if (isOk)
{
User.AddUpdateClaim("FullName", model.FullName);
User.AddUpdateClaim(ClaimTypes.MobilePhone, model.Phone);
}
return(RedirectToAction("Index"));
}
public async Task Should_Update_User_And_Return_NoContentResult()
{
//Arrange
var mockMediator = new Mock <IMediator>();
var user = new ApplicationUser()
{
Id = 1,
PasswordHash = String.Empty,
FirstName = String.Empty,
LastName = String.Empty,
UserName = String.Empty,
Email = String.Empty,
SecurityStamp = Guid.NewGuid().ToString()
};
var message = new UpdateUserInfoCommand(
1,
"Test",
"Test"
);
mockMediator.Setup(x => x.Send(It.IsAny <UpdateUserInfoCommand>(), default))
.Returns <UpdateUserInfoCommand, CancellationToken>((command, c) =>
{
user.FirstName = command.FirstName;
user.LastName = command.LastName;
return(Task.FromResult(Unit.Value));
});
var controller = new UserController(mockMediator.Object);
SetAuthenticationContext(controller);
//Act
var result = await controller.UpdateUserInfo(message);
//Assert
result.ShouldNotBeNull();
user.FirstName.ShouldBe("Test");
user.LastName.ShouldBe("Test");
result.ShouldBeAssignableTo <NoContentResult>();
}
public Task UpdateUserInfo([FromBody] UpdateUserInfoCommand profileUpdateCommand)
{
return(Mediator.Send(profileUpdateCommand));
}
public async Task <IActionResult> UpdateUserInfo([FromBody] UpdateUserInfoCommand profileUpdateCommand)
{
await Mediator.Send(profileUpdateCommand);
return(NoContent());
}
