public async Task Handle_GivenEmailAddressHasChangedAndNotInUse_ExpectUserToBeAdded()
{
var user = new Mock <IUser>();
user.Setup(x => x.EmailAddress).Returns("email-address");
var userQueries = new Mock <IUserQueries>();
userQueries.Setup(x =>
x.CheckForPresenceOfUserByEmailAddress(It.IsAny <string>()))
.ReturnsAsync(() => new StatusCheckModel(false));
var userRepository = new Mock <IUserRepository>();
var unitOfWork = new Mock <IUnitOfWork>();
unitOfWork.Setup(x => x.SaveEntitiesAsync(It.IsAny <CancellationToken>())).ReturnsAsync(() => true);
userRepository.Setup(x => x.UnitOfWork).Returns(unitOfWork.Object);
userRepository.Setup(x => x.Find(It.IsAny <Guid>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(Maybe.From(user.Object));
var handler = new UpdateUserCoreDetailsCommandHandler(userRepository.Object, userQueries.Object);
var cmd = new UpdateUserCoreDetailsCommand(TestVariables.UserId, "email-address", "first-name",
"last-name", false, false, new List <Guid>());
await handler.Handle(cmd, CancellationToken.None);
userRepository.Verify(x => x.Update(It.IsAny <IUser>()), Times.Once);
}
private async Task <ResultWithError <ErrorData> > Process(
UpdateUserCoreDetailsCommand request, CancellationToken cancellationToken)
{
var userMaybe = await this._userRepository.Find(request.UserId, cancellationToken);
if (userMaybe.HasNoValue)
{
return(ResultWithError.Fail(new ErrorData(ErrorCodes.UserNotFound)));
}
var user = userMaybe.Value;
if (!string.Equals(request.EmailAddress, user.EmailAddress, StringComparison.InvariantCultureIgnoreCase))
{
var statusCheck =
await this._userQueries.CheckForPresenceOfUserByEmailAddress(request.EmailAddress);
if (statusCheck.IsPresent)
{
return(ResultWithError.Fail(new ErrorData(ErrorCodes.UserAlreadyExists)));
}
}
user.UpdateSystemAccessDetails(request.EmailAddress, request.IsLockable);
user.UpdateProfile(request.FirstName, request.LastName);
user.SetAdminStatus(request.IsAdmin);
user.SetRoles(request.Roles);
this._userRepository.Update(user);
return(ResultWithError.Ok <ErrorData>());
}
public async Task Handle_GivenEmailAddressHasChangedAndInUse_ExpectFailedResult()
{
var user = new Mock <IUser>();
user.Setup(x => x.EmailAddress).Returns("email-address");
var userQueries = new Mock <IUserQueries>();
userQueries.Setup(x =>
x.CheckForPresenceOfUserByEmailAddress(It.IsAny <string>()))
.ReturnsAsync(() => new StatusCheckModel(true));
var userRepository = new Mock <IUserRepository>();
var unitOfWork = new Mock <IUnitOfWork>();
unitOfWork.Setup(x => x.SaveEntitiesAsync(It.IsAny <CancellationToken>())).ReturnsAsync(() => true);
userRepository.Setup(x => x.UnitOfWork).Returns(unitOfWork.Object);
userRepository.Setup(x => x.Find(It.IsAny <Guid>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(Maybe.From(user.Object));
var handler = new UpdateUserCoreDetailsCommandHandler(userRepository.Object, userQueries.Object);
var cmd = new UpdateUserCoreDetailsCommand(TestVariables.UserId, "new-email-address", "first-name",
"last-name", false, false, new List <Guid>());
var result = await handler.Handle(cmd, CancellationToken.None);
Assert.True(result.IsFailure);
Assert.Equal(ErrorCodes.UserAlreadyExists, result.Error.Code);
}
public void Validate_GivenAllPropertiesAreValid_ExpectValidationSuccess()
{
var cmd = new UpdateUserCoreDetailsCommand(TestVariables.UserId, "*****@*****.**", "first-name", "last-name", true, true, new List <Guid>());
var validator = new UpdateUserCoreDetailsCommandValidator();
var result = validator.Validate(cmd);
Assert.True(result.IsValid);
}
public void Validate_GivenFirstNameIsNull_ExpectValidationFailure()
{
var cmd = new UpdateUserCoreDetailsCommand(TestVariables.UserId, "*****@*****.**", null, "last-name", true, true, new List <Guid>());
var validator = new UpdateUserCoreDetailsCommandValidator();
var result = validator.Validate(cmd);
Assert.False(result.IsValid);
Assert.Contains(
result.Errors,
failure => failure.ErrorCode.Equals(ValidationCodes.FieldIsRequired) &&
failure.PropertyName == "FirstName");
}
public void Validate_GivenEmailAddressIsNotValidEmailAddress_ExpectValidationFailure()
{
var cmd = new UpdateUserCoreDetailsCommand(TestVariables.UserId, "email-address", "first-name", "last-name", true, true, new List <Guid>());
var validator = new UpdateUserCoreDetailsCommandValidator();
var result = validator.Validate(cmd);
Assert.False(result.IsValid);
Assert.Contains(
result.Errors,
failure => failure.ErrorCode.Equals(ValidationCodes.ValueMustBeAnEmailAddress) &&
failure.PropertyName == "EmailAddress");
}
public void Validate_GivenEmailAddressIsEmpty_ExpectValidationFailure()
{
var cmd = new UpdateUserCoreDetailsCommand(TestVariables.UserId, string.Empty, "first-name", "last-name", true, true, new List <Guid>());
var validator = new UpdateUserCoreDetailsCommandValidator();
var result = validator.Validate(cmd);
Assert.False(result.IsValid);
Assert.Contains(
result.Errors,
failure => failure.ErrorCode.Equals(ValidationCodes.FieldIsRequired) &&
failure.PropertyName == "EmailAddress");
}
public void Constructor_GiveValidArguments_PropertiesAreSet()
{
var command = new UpdateUserCoreDetailsCommand(TestVariables.UserId, "email-address", "first-name",
"last-name", false, true, new List <Guid> {
TestVariables.RoleId
});
Assert.Equal(TestVariables.UserId, command.UserId);
Assert.Equal("email-address", command.EmailAddress);
Assert.Equal("first-name", command.FirstName);
Assert.Equal("last-name", command.LastName);
Assert.False(command.IsLockable);
Assert.Single(command.Roles);
}
public async Task <ResultWithError <ErrorData> > Handle(
UpdateUserCoreDetailsCommand request, CancellationToken cancellationToken)
{
var result = await this.Process(request, cancellationToken);
var dbResult = await this._userRepository.UnitOfWork.SaveEntitiesAsync(cancellationToken);
if (!dbResult)
{
return(ResultWithError.Fail(new ErrorData(
ErrorCodes.SavingChanges, "Failed To Save Database")));
}
return(result);
}
public async Task Handle_GivenNotUserInSystem_ExpectFailedResult()
{
var userQueries = new Mock <IUserQueries>();
var userRepository = new Mock <IUserRepository>();
var unitOfWork = new Mock <IUnitOfWork>();
unitOfWork.Setup(x => x.SaveEntitiesAsync(It.IsAny <CancellationToken>())).ReturnsAsync(() => true);
userRepository.Setup(x => x.UnitOfWork).Returns(unitOfWork.Object);
userRepository.Setup(x => x.Find(It.IsAny <Guid>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(Maybe <IUser> .Nothing);
var handler = new UpdateUserCoreDetailsCommandHandler(userRepository.Object, userQueries.Object);
var cmd = new UpdateUserCoreDetailsCommand(TestVariables.UserId, "email-address", "first-name",
"last-name", false, false, new List <Guid>());
var result = await handler.Handle(cmd, CancellationToken.None);
Assert.True(result.IsFailure);
Assert.Equal(ErrorCodes.UserNotFound, result.Error.Code);
}
public async Task Handle_GivenSavingSucceeds_ExpectSuccessfulResult()
{
var user = new Mock <IUser>();
user.Setup(x => x.EmailAddress).Returns("email-address");
var userQueries = new Mock <IUserQueries>();
var userRepository = new Mock <IUserRepository>();
var unitOfWork = new Mock <IUnitOfWork>();
unitOfWork.Setup(x => x.SaveEntitiesAsync(It.IsAny <CancellationToken>())).ReturnsAsync(() => true);
userRepository.Setup(x => x.UnitOfWork).Returns(unitOfWork.Object);
userRepository.Setup(x => x.Find(It.IsAny <Guid>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(Maybe.From(user.Object));
var handler = new UpdateUserCoreDetailsCommandHandler(userRepository.Object, userQueries.Object);
var cmd = new UpdateUserCoreDetailsCommand(TestVariables.UserId, "email-address", "first-name",
"last-name", false, false, new List <Guid>());
var result = await handler.Handle(cmd, CancellationToken.None);
Assert.True(result.IsSuccess);
}