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 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 async Task AddProduct_ReturnsProductCRUDResultModelWithIsSuccessfulFalse_On_InvalidUserException()
{
// Arrange
var expectedException = new InvalidUserException("msg");
var fileManager = new Mock <IFileManager>();
fileManager.Setup(x => x.ValidateFile(It.IsAny <IFormFile>()))
.Returns(It.IsAny <string>());
var userManager = new Mock <IUserManager>();
userManager.Setup(x => x.GetByUserId(It.IsAny <int>()))
.ThrowsAsync(expectedException);
var productService = new ProductServiceBuilder()
.WithFileManager(fileManager.Object)
.WithUserManager(userManager.Object)
.Build();
// Assert
var result = await productService.AddProduct(new AddProductModel(), It.IsAny <int>());
// Act
Assert.False(result.IsSuccessful);
Assert.Contains(expectedException.Message, result.Message);
}
public void ToStringGetsDescription()
{
var description = "test description";
var message = "test message";
var ex = new InvalidUserException(message, description);
Assert.AreEqual(description, ex.ToString());
}
private ChangePassword(IUserRepository userRepository, int userId, string newPassword, string appKey)
{
_userRepository = userRepository;
_newPassword = newPassword;
_appKey = appKey;
_userId = userId;
ValidateInstance();
InvalidUserExceptionCreator = () => InvalidUserException.Create(_userId);
}
public void InvalidRegisterException_ReturnsDefaultErrorMessage()
{
// Act
var error = new InvalidUserException();
// Assert
Assert.Equal("A user with this ID or email does not exist", error.Message);
Assert.Equal(typeof(InvalidUserException), error.GetType());
}
public void InvalidUserException_ReturnsProvidedErrorMessage(string errorMessage)
{
// Act
var error = new InvalidUserException(errorMessage);
// Assert
Assert.Equal(errorMessage, error.Message);
Assert.Equal(typeof(InvalidUserException), error.GetType());
}
public String[] GetCredentials(InvalidUserException e)
{
// User has not logged in yet, ask the user if this occurs
if (name == null)
{
return(PromptForCredentials());
}
string[] tokens = { name, password, group, role, discriminator };
return(tokens);
}
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 void Add(User user)
{
if (ReferenceEquals(user, null))
{
var ex = new ArgumentNullException($"{nameof(user)} is null");
this.logger?.Error(ex, ex.Message);
throw ex;
}
if (ReferenceEquals(user.FirstName, null) || ReferenceEquals(user.LastName, null))
{
var ex = new InvalidUserException($"{nameof(user)} isn't fully initialized");
this.logger?.Error(ex, ex.Message);
throw ex;
}
if (this.storage.Contains(user))
{
var ex = new UserAlreadyExistException($"{nameof(user)} already exists");
this.logger?.Error(ex, ex.Message);
throw ex;
}
rwLockSlim.EnterWriteLock();
try
{
user.Identifier = this.generateIdentifierFunction();
if (user.Identifier < 0)
{
var ex = new InvalidIdentifierException($"{nameof(user.Identifier)} can't be under zero");
this.logger?.Error(ex, ex.Message);
throw ex;
}
if (storage.Select(usr => usr.Identifier).Contains(user.Identifier))
{
var ex = new InvalidIdentifierException($"{nameof(user.Identifier)} '{user.Identifier}' already has been taken");
this.logger?.Error(ex, ex.Message);
throw ex;
}
this.logger?.Info($"Added {nameof(user)} with fields:\n ID:{user.Identifier}\n FirstName:{user.FirstName}\n LastName:{user.LastName}\n Age:{user.Age}");
this.storage.Add(user);
}
finally
{
rwLockSlim.ExitWriteLock();
}
Notify(new Message {
Action = Action.Add, User = user.Clone()
});
}
public void GetObjectData()
{
var description = "test description";
var message = "test message";
var ex = new InvalidUserException(message, description);
var info = new SerializationInfo(typeof(InvalidInvitationException), new FormatterConverter());
var context = new StreamingContext();
ex.GetObjectData(info, context);
Assert.AreEqual(message, info.GetString("Message"));
}
public String[] GetCredentials(InvalidUserException e)
//throws CanceledOperationException
{
// Have not logged in yet, shoult not happen but just in case
if (name == null)
{
return(PromptForCredentials());
}
// Return cached credentials
String[] tokens = { name, password, group, role, discriminator };
return(tokens);
}
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 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();
}
