public async Task When_User_Exist_Throw_Exception(RegisterUserCommand model)
{
//Arrange
_userRepository.Setup(x => x.IsUserExist(It.IsAny <string>())).ReturnsAsync(true);
//Assert
await Assert.ThrowsAsync <AppException>(() => _sut.Handle(model, default));
}
public async void Handle_GivenValidRegistrationDetails_ShouldSucceed()
{
// arrange
var mockUserRepository = new Mock <IUserRepository>();
List <AppUser> users = new List <AppUser>
{
new AppUser()
{
Email = "*****@*****.**"
}
};
var mockUserManager = MockUserManager <AppUser>(users);
var mockMediatorHandler = new Mock <IMediatorHandler>();
var mockUnitOfWork = new Mock <IUnitOfWork>();
mockUnitOfWork.Setup(uow => uow.Commit()).Returns(true);
var notificationHandler = new DomainNotificationHandler();
var useHandler = new RegisterUserHandler(mockUserRepository.Object, mockUserManager.Object, mockUnitOfWork.Object, mockMediatorHandler.Object, notificationHandler);
// act
try
{
await useHandler.Handle(new RegisterUserRequest("firstName", "lastName", "*****@*****.**", "userName", "password"));
}
catch (Exception ex)
{
// assert
Assert.True(false, "Expected no exception, but got: " + ex.Message);
}
}
public void NotAllowPasswordWithoutAtLeastOneSpecial()
{
//Arrange
var aUser = TestHelper.MakeUser("*****@*****.**",
TestHelper.MakeValidPassword.Replace(
TestHelper.SpecialChar,
TestHelper.Digit
)
);
var existingRepo = TestHelper.MakeRepo();
var mockRepo = new Mock <IEntityRepository <User> >();
mockRepo.Setup(repo => repo.Entities)
.Returns(existingRepo);
var sut = new RegisterUserHandler(mockRepo.Object);
var registerUser = new RegisterUser(aUser.Email, aUser.Password);
//Act
var response = sut.Handle(registerUser);
//Assert
Assert.True(response.HasErrors());
Assert.True(response.HasMessage <PasswordLacksSpecialCharacter>());
}
public async Task ShouldRegisterUser()
{
// Arrange
using var scope = Factory.Services.CreateScope();
var registerUserModel = new RegisterUserModel
{
FirstName = "first name",
LastName = "last name",
Password = "******",
UserName = Guid.NewGuid().ToString()
};
var sut = new RegisterUserHandler(userManager, unitOfWork, mediator, mapper, currentUserServiceMock.Object);
// Act
User sutResult = await sut.Handle(new RegisterUserCommand(registerUserModel), new CancellationToken(false));
// Assert
Assert.NotNull(sutResult);
var addedUser = await unitOfWork.Users.GetEntityAsync(sutResult.Id);
Assert.NotNull(addedUser);
Assert.Equal(registerUserModel.FirstName, addedUser.FirstName);
Assert.Equal(registerUserModel.LastName, addedUser.LastName);
Assert.Equal(registerUserModel.UserName, addedUser.UserName);
Assert.Equal(registerUserModel.FirstName, sutResult.FirstName);
Assert.Equal(registerUserModel.LastName, sutResult.LastName);
Assert.Equal(registerUserModel.UserName, sutResult.UserName);
}
private void Act()
{
_result = _subject.Handle(new RegisterUser
{
Email = _email
}, CancellationToken.None).GetAwaiter().GetResult();
}
public void exception_is_thrown()
{
Action t = () =>
{
_subject.Handle(new RegisterUser
{
Email = _email,
Token = _inviteToken
}, CancellationToken.None).GetAwaiter().GetResult();
};
t.Should().Throw <ArgumentException>();
}
public void ThrowsExceptionWhenEmailIsAlreadyInUse()
{
_repoMock.Setup(r => r.Get(It.IsAny <Expression <Func <User, bool> > >()))
.Returns(new List <User> {
new User {
}
});
var handler = new RegisterUserHandler(null, _repoMock.Object);
Action action = () => handler.Handle(Request, new System.Threading.CancellationToken());
action.Should().ThrowExactly <EntityAlreadyExistsException>().WithMessage("[email protected] is already in use.");
}
public void CallRepoAddAndPublishesEventWhenDataIsValid()
{
_repoMock.Setup(r => r.Get(It.IsAny <Expression <Func <User, bool> > >()))
.Returns(new List <User>());
_repoMock.Setup(r => r.Add(It.IsAny <User>()));
_busMock.Setup(r => r.Publish(It.IsAny <UserRegisteredEvent>()));
var handler = new RegisterUserHandler(_busMock.Object, _repoMock.Object);
handler.Handle(Request, new System.Threading.CancellationToken());
_repoMock.Verify(r => r.Add(It.IsAny <User>()), Times.Once);
_busMock.Verify(r => r.Publish(It.IsAny <UserRegisteredEvent>()), Times.Once);
}
public async Task Should_ReturnBadRequest_When_PassingParametersAreEmpty(string username, string password)
{
var cancellationToken = new CancellationToken();
var databaseContext = Create.MockedDbContextFor <DatabaseContext>();
var userPasswordUtility = Substitute.For <IUserPasswordUtility>();
var saltGeneratorUtility = Substitute.For <ISaltGeneratorUtility>();
saltGeneratorUtility.Generate().Returns(Encoding.ASCII.GetBytes("UserPasswordTest"));
userPasswordUtility.HashPassword(password, Encoding.ASCII.GetBytes("UserPasswordTest")).Returns("HashedPassword");
databaseContext.Set <SystemUser>().Add(new SystemUser()
{
Id = 1,
Password = "******",
Username = "******",
Salt = Encoding.ASCII.GetBytes("password1")
});
databaseContext.Set <SystemUser>().Add(new SystemUser()
{
Id = 2,
Password = "******",
Username = "******",
Salt = Encoding.ASCII.GetBytes("password2")
});
databaseContext.Set <SystemUser>().Add(new SystemUser()
{
Id = 3,
Password = "******",
Username = "******",
Salt = Encoding.ASCII.GetBytes("password3")
});
databaseContext.SaveChanges();
var entity = new RegisterUserRequest(username, password);
var handler = new RegisterUserHandler(databaseContext, userPasswordUtility, saltGeneratorUtility);
var result = await handler.Handle(entity, cancellationToken);
Assert.Multiple(() =>
{
Assert.IsFalse(result.Success);
Assert.AreEqual(result.StatusCode, HttpStatusCode.BadRequest);
});
}
public void AllowValidPassword()
{
//Arrange
var aUser = TestHelper.MakeUser("*****@*****.**", TestHelper.MakeValidPassword);
var existingRepo = TestHelper.MakeRepo();
var mockRepo = new Mock <IEntityRepository <User> >();
mockRepo.Setup(repo => repo.Entities)
.Returns(existingRepo);
var sut = new RegisterUserHandler(mockRepo.Object);
var registerUser = new RegisterUser(aUser.Email, aUser.Password);
//Act
var response = sut.Handle(registerUser);
//Assert
Assert.True(!response.HasErrors());
}
public void RegisterRolTest()
{
Usuario u3 = new Usuario
{
UserName = "******",
RolId = 2,
UserPassword = "******",
UsuarioId = 3
};
mockRepository.Setup(x => x.RegisterUser(u3))
.Returns(true);
var handler = new RegisterUserHandler(mockRepository.Object);
RegisterUser ru = new RegisterUser(u3);
var res = handler.Handle(ru, ct);
Assert.IsTrue(res.Result);
}
public void NotAllowEmailWithout_At()
{
//Arrange
var aUser = TestHelper.MakeUser("mat.com");
var existingRepo = TestHelper.MakeRepo();
var mockRepo = new Mock <IEntityRepository <User> >();
mockRepo.Setup(repo => repo.Entities)
.Returns(existingRepo);
var sut = new RegisterUserHandler(mockRepo.Object);
var registerUser = new RegisterUser(aUser.Email, aUser.Password);
//Act
var response = sut.Handle(registerUser);
//Assert
Assert.True(response.HasErrors());
Assert.True(response.HasMessage <EmailLacksAtCharacter>());
}