public async Task ShouldThrowValidationExceptionOnModifyWhenUserUserNameIsInvalidAndLogItAsync(
string invalidUserUserName)
{
// given
User randomUser = CreateRandomUser();
User invalidUser = randomUser;
invalidUser.UserName = invalidUserUserName;
var invalidUserException = new InvalidUserException(
parameterName: nameof(User.UserName),
parameterValue: invalidUser.UserName);
var expectedUserValidationException =
new UserValidationException(invalidUserException);
// when
ValueTask <User> modifyUserTask =
this.userService.ModifyUserAsync(invalidUser);
// then
await Assert.ThrowsAsync <UserValidationException>(() =>
modifyUserTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedUserValidationException))),
Times.Once);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.userManagementBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnModifyWhenUserIsNullAndLogItAsync()
{
// given
User randomUser = null;
User nullUser = randomUser;
var nullUserException = new NullUserException();
var expectedUserValidationException =
new UserValidationException(nullUserException);
// when
ValueTask <User> modifyUserTask =
this.userService.ModifyUserAsync(nullUser);
// then
await Assert.ThrowsAsync <UserValidationException>(() =>
modifyUserTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedUserValidationException))),
Times.Once);
this.userManagementBrokerMock.Verify(broker =>
broker.SelectUserByIdAsync(It.IsAny <Guid>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.userManagementBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnCreateWhenUserIsNullAndLogItAsync()
{
// given
User invalidUser = null;
var nullUserException = new NullUserException();
string password = GetRandomPassword();
var expectedUserValidationException =
new UserValidationException(nullUserException);
// when
ValueTask <User> createUserTask =
this.userService.RegisterUserAsync(invalidUser, password);
// then
await Assert.ThrowsAsync <UserValidationException>(() =>
createUserTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedUserValidationException))),
Times.Once);
this.userManagementBrokerMock.Verify(broker =>
broker.SelectUserByIdAsync(It.IsAny <Guid>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.userManagementBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidatonExceptionOnRetrieveWhenUserIdIsInvalidAndLogItAsync()
{
// given
Guid randomUserId = default;
Guid inputUserId = randomUserId;
var invalidUserException = new InvalidUserException(
parameterName: nameof(User.Id),
parameterValue: inputUserId);
var expectedUserValidationException =
new UserValidationException(invalidUserException);
// when
ValueTask <User> actualUserTask =
this.userService.RetrieveUserByIdAsync(inputUserId);
// then
await Assert.ThrowsAsync <UserValidationException>(() => actualUserTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedUserValidationException))),
Times.Once);
this.userManagementBrokerMock.Verify(broker =>
broker.SelectUserByIdAsync(It.IsAny <Guid>()),
Times.Never);
this.userManagementBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public void WriteExceptionMessage_WhenUserValidationExceptionOccurs()
{
// Arrange
var loggerMock = new Mock <ILogger>();
var processorMock = new Mock <ICommandProcessor>();
var readerMock = new Mock <IReader>();
var writerMock = new Mock <IWriter>();
string commandAsString = "CreateProject DeathStar 2016-1-1 2018-05-04";
string exceptionMessage = "Invalid command parameters count!";
UserValidationException userValidationException = new UserValidationException(exceptionMessage);
StringBuilder sb = new StringBuilder();
sb.AppendLine(userValidationException.Message);
readerMock.Setup(r => r.ReadLine()).Returns(commandAsString).Callback(() =>
{
readerMock.Setup(r => r.ReadLine()).Returns("Exit");
});
processorMock.Setup(p => p.Process(commandAsString)).Throws(userValidationException);
writerMock.Setup(w => w.Write(sb.ToString()));
IEngine engine = new Engine(loggerMock.Object, processorMock.Object, readerMock.Object, writerMock.Object);
// Act
engine.Start();
// Assert
writerMock.Verify(w => w.Write(sb.ToString()), Times.Once());
}
private Exception CreateAndLogValidationException(Exception exception)
{
var userValidationException = new UserValidationException(exception);
this.loggingBroker.LogError(userValidationException);
return(userValidationException);
}
public async Task ShouldThrowValidationExceptionOnModifyIfStorageUpdatedDateSameAsUpdatedDateAndLogItAsync()
{
// given
int randomNegativeMinutes = GetNegativeRandomNumber();
int minutesInThePast = randomNegativeMinutes;
DateTimeOffset randomDate = GetRandomDateTime();
User randomUser = CreateRandomUser(randomDate);
randomUser.CreatedDate = randomUser.CreatedDate.AddMinutes(minutesInThePast);
User invalidUser = randomUser;
invalidUser.UpdatedDate = randomDate;
User storageUser = randomUser.DeepClone();
Guid UserId = invalidUser.Id;
var invalidUserInputException = new InvalidUserException(
parameterName: nameof(User.UpdatedDate),
parameterValue: invalidUser.UpdatedDate);
var expectedUserValidationException =
new UserValidationException(invalidUserInputException);
this.userManagementBrokerMock.Setup(broker =>
broker.SelectUserByIdAsync(UserId))
.ReturnsAsync(storageUser);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(randomDate);
// when
ValueTask <User> modifyUserTask =
this.userService.ModifyUserAsync(invalidUser);
// then
await Assert.ThrowsAsync <UserValidationException>(() =>
modifyUserTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.userManagementBrokerMock.Verify(broker =>
broker.SelectUserByIdAsync(invalidUser.Id),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedUserValidationException))),
Times.Once);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.userManagementBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnModifyIfUserDoesntExistAndLogItAsync()
{
// given
int randomNegativeMinutes = GetNegativeRandomNumber();
DateTimeOffset dateTime = GetRandomDateTime();
User randomUser = CreateRandomUser(dateTime);
User nonExistentUser = randomUser;
nonExistentUser.CreatedDate = dateTime.AddMinutes(randomNegativeMinutes);
User noUser = null;
var notFoundUserException = new NotFoundUserException(nonExistentUser.Id);
var expectedUserValidationException =
new UserValidationException(notFoundUserException);
this.userManagementBrokerMock.Setup(broker =>
broker.SelectUserByIdAsync(nonExistentUser.Id))
.ReturnsAsync(noUser);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(dateTime);
// when
ValueTask <User> modifyUserTask =
this.userService.ModifyUserAsync(nonExistentUser);
// then
await Assert.ThrowsAsync <UserValidationException>(() =>
modifyUserTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.userManagementBrokerMock.Verify(broker =>
broker.SelectUserByIdAsync(nonExistentUser.Id),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedUserValidationException))),
Times.Once);
this.userManagementBrokerMock.Verify(broker =>
broker.UpdateUserAsync(It.IsAny <User>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.userManagementBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnCreateWhenUserAlreadyExistsAndLogItAsync()
{
// given
DateTimeOffset randomDateTime = GetRandomDateTime();
DateTimeOffset dateTime = randomDateTime;
User randomUser = CreateRandomUser(dateTime);
User alreadyExistsUser = randomUser;
string randomMessage = GetRandomMessage();
string exceptionMessage = randomMessage;
var duplicateKeyException = new DuplicateKeyException(exceptionMessage);
string password = GetRandomPassword();
var alreadyExistsUserException =
new AlreadyExistsUserException(duplicateKeyException);
var expectedUserValidationException =
new UserValidationException(alreadyExistsUserException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(dateTime);
this.userManagementBrokerMock.Setup(broker =>
broker.InsertUserAsync(alreadyExistsUser, password))
.ThrowsAsync(duplicateKeyException);
// when
ValueTask <User> registerUserTask =
this.userService.RegisterUserAsync(alreadyExistsUser, password);
// then
await Assert.ThrowsAsync <UserValidationException>(() =>
registerUserTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.userManagementBrokerMock.Verify(broker =>
broker.InsertUserAsync(alreadyExistsUser, password),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedUserValidationException))),
Times.Once);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.userManagementBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnModifyWhenUpdatedDateIsNotRecentAndLogItAsync(
int minutes)
{
// given
DateTimeOffset dateTime = GetRandomDateTime();
User randomUser = CreateRandomUser(dateTime);
User inputUser = randomUser;
inputUser.UpdatedDate = dateTime.AddMinutes(minutes);
var invalidUserInputException = new InvalidUserException(
parameterName: nameof(User.UpdatedDate),
parameterValue: inputUser.UpdatedDate);
var expectedUserValidationException =
new UserValidationException(invalidUserInputException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(dateTime);
// when
ValueTask <User> modifyUserTask =
this.userService.ModifyUserAsync(inputUser);
// then
await Assert.ThrowsAsync <UserValidationException>(() =>
modifyUserTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedUserValidationException))),
Times.Once);
this.userManagementBrokerMock.Verify(broker =>
broker.SelectUserByIdAsync(It.IsAny <Guid>()),
Times.Never);
this.userManagementBrokerMock.Verify(broker =>
broker.UpdateUserAsync(It.IsAny <User>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.userManagementBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidatonExceptionOnDeleteWhenStorageUserIsInvalidAndLogItAsync()
{
// given
Guid randomUserId = Guid.NewGuid();
Guid inputUserId = randomUserId;
User invalidStorageUser = null;
var notFoundUserException = new NotFoundUserException(inputUserId);
var expectedUserValidationException =
new UserValidationException(notFoundUserException);
this.userManagementBrokerMock.Setup(broker =>
broker.SelectUserByIdAsync(inputUserId))
.ReturnsAsync(invalidStorageUser);
// when
ValueTask <User> deleteUserTask =
this.userService.RemoveUserByIdAsync(inputUserId);
// then
await Assert.ThrowsAsync <UserValidationException>(() =>
deleteUserTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedUserValidationException))),
Times.Once);
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Never);
this.userManagementBrokerMock.Verify(broker =>
broker.SelectUserByIdAsync(inputUserId),
Times.Once);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.userManagementBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnCreateWhenIdIsInvalidAndLogItAsync()
{
// given
User randomUser = CreateRandomUser();
User inputUser = randomUser;
inputUser.Id = default;
string password = GetRandomPassword();
var invalidUserInputException = new InvalidUserException(
parameterName: nameof(User.Id),
parameterValue: inputUser.Id);
var expectedUserValidationException =
new UserValidationException(invalidUserInputException);
// when
ValueTask <User> registerUserTask =
this.userService.RegisterUserAsync(inputUser, password);
// then
await Assert.ThrowsAsync <UserValidationException>(() =>
registerUserTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedUserValidationException))),
Times.Once);
this.userManagementBrokerMock.Verify(broker =>
broker.SelectUserByIdAsync(It.IsAny <Guid>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.userManagementBrokerMock.VerifyNoOtherCalls();
}
