public async Task Create_User_Email_Already_Exists()
{
var connection = TestHelper.GetConnection();
var options = TestHelper.GetMockDBOptions(connection);
try
{
// Run the test against one instance of the context
using (var context = new AppcentTodoContext(options))
{
TestHelper.EnsureCreated(context);
var service = new RegisterUserCommandHandler(context, TestHelper.GetMapperInstance());
var command = new RegisterUserCommand();
command.Data = new RegisterUserRequest
{
Email = "*****@*****.**",
FirstName = "test firstname",
LastName = "test lastname",
Password = "******",
UserName = "******"
};
var result = await service.Execute(command);
Assert.False(result.Result.IsSuccess);
Assert.Equal("Email is already in use", result.Result.Error.ErrorText);
}
}
finally
{
connection.Close();
}
}
public void Arrange()
{
_registerUserCommandValidator = new Mock <IValidator <RegisterUserCommand> >();
_auditService = new Mock <IAuditService>();
_passwordService = new Mock <IPasswordService>();
_passwordService.Setup(s => s.GenerateAsync(It.IsAny <string>()))
.Returns(Task.FromResult(new SecuredPassword
{
HashedPassword = "******",
Salt = "Generated_Salt",
ProfileId = "Password_Profile_Id"
}));
_userRepository = new Mock <IUserRepository>();
_communicationService = new Mock <ICommunicationService>();
_codeGenerator = new Mock <ICodeGenerator>();
_codeGenerator.Setup(x => x.GenerateAlphaNumeric(6))
.Returns("ABC123XYZ");
_auditService = new Mock <IAuditService>();
_logger = new Mock <ILogger>();
_registerUserCommandHandler = new RegisterUserCommandHandler(_registerUserCommandValidator.Object,
_passwordService.Object,
_userRepository.Object,
_communicationService.Object,
_codeGenerator.Object,
_logger.Object,
_auditService.Object);
}
public async Task Should_Register_A_New_User()
{
Guid userId = Guid.NewGuid();
IApplicationDbContext dbContext = Testing.GetService <IApplicationDbContext>();
Mock <IGuidGenerator> guidGeneratorStub = new Mock <IGuidGenerator>();
guidGeneratorStub.Setup(m => m.GetNextAsync()).ReturnsAsync(userId);
var sut = new RegisterUserCommandHandler(guidGeneratorStub.Object, dbContext);
RegisterUserCommand request = new RegisterUserCommand()
{
Username = "******",
Password = "******",
About = "I like TDD"
};
var registeredUserVm = await sut.Handle(request, CancellationToken.None);
// output verification
registeredUserVm.Id.Should().Be(userId);
registeredUserVm.Username.Should().Be(request.Username);
registeredUserVm.About.Should().Be(request.About);
// state verification
var registeredUser = await dbContext.Users.SingleAsync(u => u.Id == userId);
registeredUser.Username.Should().Be(request.Username);
registeredUser.Password.Should().Be(request.Password);
registeredUser.About.Should().Be(request.About);
}
/// <summary>
/// Start the command bus example.
/// </summary>
public static void Main()
{
Console.WriteLine("==== [StructureMap] ====");
try
{
Task.Factory.StartNew(StructureMapExample.Go).Wait();
}
catch (Exception ex1)
{
Console.WriteLine("Exception - " + ex1.Message);
}
RegisterUserCommandHandler.ResetUsers();
Console.WriteLine("==== [Autofac] ====");
try
{
Task.Factory.StartNew(AutofacExample.Go).Wait();
}
catch (Exception ex1)
{
Console.WriteLine("Exception - " + ex1.Message);
}
Console.WriteLine("Press Enter to exit...");
Console.ReadLine();
}
public async Task Create_User()
{
var connection = TestHelper.GetConnection();
var options = TestHelper.GetMockDBOptions(connection);
try
{
using (var context = new AppcentTodoContext(options))
{
var service = new RegisterUserCommandHandler(context, TestHelper.GetMapperInstance());
var command = new RegisterUserCommand();
command.Data = new RegisterUserRequest
{
Email = "test email",
FirstName = "test firstname",
LastName = "test lastname",
Password = "******",
UserName = "******"
};
var result = await service.Execute(command);
Assert.True(result.Result.IsSuccess);
}
using (var context = new AppcentTodoContext(options))
{
var count = context.AcUsers.Where(e => e.FirstName == "test firstname");
Assert.Equal(1, count.Count());
}
}
finally
{
connection.Close();
}
}
public async Task Should_Register_User()
{
Result <int> userRegistrationResult;
var userRegistrationCommand = new RegisterUserCommand(
"registereduser",
"registered",
"user",
"password",
"*****@*****.**",
"registered user bio",
Convert.FromBase64String(_testFixture.GetTestPictureBase64()));
using (var session = _testFixture.OpenSession(_output))
{
var sut = new RegisterUserCommandHandler(session, Log.Logger);
userRegistrationResult = await sut.Handle(userRegistrationCommand, default);
}
using (new AssertionScope())
{
userRegistrationResult.IsSuccess.Should().BeTrue();
userRegistrationResult.Value.Should().BeGreaterThan(0);
using (var session = _testFixture.OpenSession(_output))
{
(await session.GetAsync <User>(userRegistrationResult.Value)).Should().NotBeNull();
}
}
}
public async Task RegisterUserCommand_UserRegisters_NewUserCreated()
{
var command = new RegisterUserCommand()
{
Username = "******",
Password = "******",
ConfirmPassword = "******",
Name = "Testname",
Surname = "Testsurname",
BirthDate = DateTime.Now,
Email = "*****@*****.**",
Gender = Gender.Male
};
UpdateUserCommand user;
using (var dbContext = new JoggingTrackerDbContext(this._options))
{
dbContext.Roles.Add(new Role()
{
Id = Guid.NewGuid(), Name = Role.UserRole
});
await dbContext.SaveChangesAsync();
var commandHandler = new RegisterUserCommandHandler(this._securityProvider, this._serverTime, this._mapper, dbContext);
user = await commandHandler.Handle(command);
}
using (var dbContext = new JoggingTrackerDbContext(this._options))
{
Assert.NotNull(await dbContext.Users.SingleAsync(u => u.Id == user.Id));
}
}
public async Task UpdateUserRefreshTokenCommandHandler_GivenValidCommand_ShouldInsertedInDb()
{
var serviceProvider = _services
.BuildServiceProvider();
using (var scope = serviceProvider.CreateScope())
{
var scopedServices = scope.ServiceProvider;
try
{
// seed sample user data
var userManager = scopedServices.GetRequiredService <UserManager <User> >();
_logging = scopedServices.GetRequiredService <ILoggerFactory>();
var roleManager = scopedServices.GetRequiredService <RoleManager <Role> >();
await SecurityDbContextSeed.SeedRolesAsync(roleManager);
_commandHandler = new RegisterUserCommandHandler(userManager, _logging.CreateLogger <RegisterUserCommandHandler>());
_dbContext = scopedServices.GetRequiredService <SecurityDbContext>();
IUnitOfWork unitOfWork = new UnitOfWork(_dbContext);
_userRepository = new UserRepository(unitOfWork);
await _commandHandler.Handle(new RegisterUserCommand("test", "test2", "*****@*****.**", "15 sh", "dokki", "giza", "egypt", DateTime.Now, "", "P@ssw0rd"), CancellationToken.None);
var createdUser = await _userRepository.FindAsync(new UserSpecification("*****@*****.**"));
createdUser.ShouldNotBeNull();
}
catch (Exception ex)
{
string.IsNullOrEmpty(ex.Message).ShouldBeTrue();
}
}
}
public void Setup()
{
_userRepository = new Mock <IUserRepository>();
_tokenHelper = new Mock <ITokenHelper>();
loginUserQueryHandler = new LoginUserQueryHandler(_userRepository.Object, _tokenHelper.Object);
registerUserCommandHandler = new RegisterUserCommandHandler(_userRepository.Object);
forgotPasswordCommandHandler = new ForgotPasswordCommandHandler(_userRepository.Object);
}
public void TestInitialize()
{
this.reservedUsernames = new Mock <IReservedUsernameService>();
// Give potentially side-effecting components strict mock behaviour.
this.registerUser = new Mock <IRegisterUserDbStatement>(MockBehavior.Strict);
this.userManager = new Mock <IUserManager>(MockBehavior.Strict);
this.target = new RegisterUserCommandHandler(this.registerUser.Object, this.reservedUsernames.Object, this.userManager.Object);
}
public async Task GivenAlreadyExistingUser_WhenCallingHandle_ThenResultShouldBeFailure()
{
var registerUserCommand = new RegisterUserCommand();
var sut = new RegisterUserCommandHandler(_mockUserService, Context, Mapper);
var result = await sut.Handle(registerUserCommand, CancellationToken.None);
result.IsFailure.Should().BeTrue();
}
public async Task GivenAlreadyExistingUser_WhenCallingHandle_ThenUserAlreadyRegisteredErrorShouldBeReturned()
{
var registerUserCommand = new RegisterUserCommand();
var sut = new RegisterUserCommandHandler(_mockUserService, Context, Mapper);
var result = await sut.Handle(registerUserCommand, CancellationToken.None);
result.Error.Should().Be(Errors.General.UserAlreadyRegistered());
}
public async Task GivenRegisterUserCommandHandler_WhenUserEmailAlreadyExists_ThenThrowsRestException()
{
_mockUserManager.FindByEmailAsync(_command.Email).Returns(_user);
var registerCommandHandler =
new RegisterUserCommandHandler(_mockUserManager, _mockJwtGenerator, _mockEventBus,
_mockUserConfirmationEmail, _mockFailedIdentityResult);
await Assert.ThrowsAsync <RestException>(() =>
registerCommandHandler.Handle(_command, CancellationToken.None));
}
public void RegisterUserCommandHandler_Sends_Email()
{
var handler = new RegisterUserCommandHandler(_repository, _mailClient, new ActivationMailTemplate(_appSettings));
var command = new RegisterUserCommand("*****@*****.**", "test");
handler.Execute(command);
_mailClient.SentMessages.Should().HaveCount(1);
_mailClient.SentMessages[0].Subject.Should().Be("Please activate your account");
_mailClient.SentMessages[0].To.Should().Be("*****@*****.**");
}
public void Setup()
{
_userRepository = new Mock <IUserRepository>();
_tokenHelper = new Mock <ITokenHelper>();
_mediator = new Mock <IMediator>();
_cacheManager = new Mock <ICacheManager>();
_loginUserQueryHandler = new LoginUserQueryHandler(_userRepository.Object, _tokenHelper.Object, _mediator.Object, _cacheManager.Object);
_registerUserCommandHandler = new RegisterUserCommandHandler(_userRepository.Object);
_forgotPasswordCommandHandler = new ForgotPasswordCommandHandler(_userRepository.Object);
}
public RegisterUserTest()
{
// Arrange
Mediator = new Mock <IMediator>();
Mapper = new Mapper(new MapperConfiguration(cfg =>
{
cfg.AddProfile(new MappingProfile());
cfg.ValidateInlineMaps = false;
}));
Logger = new Mock <ILogger <RegisterUserCommandHandler> >();
Handler = new RegisterUserCommandHandler(Mediator.Object, Mapper, Logger.Object);
}
GivenRegisterUserCommandHandler_WhenNewUserHasRegistered_ThenUserConfirmationEmailShouldBeCalled()
{
_mockUserManager.FindByEmailAsync(_command.Email).ReturnsNullForAnyArgs();
_mockUserManager.CreateAsync(_user, _command.Password)
.ReturnsForAnyArgs(Task.FromResult(IdentityResult.Success));
var registerCommandHandler =
new RegisterUserCommandHandler(_mockUserManager, _mockJwtGenerator, _mockEventBus,
_mockUserConfirmationEmail, _mockFailedIdentityResult);
await registerCommandHandler.Handle(_command, CancellationToken.None);
await _mockUserConfirmationEmail.Received().Send(Arg.Any <AppUser>());
}
public async Task GivenValidRegisterUserCommand_WhenCallingHandle_ThenResultShouldBeSuccessful()
{
var registerUserCommand = new RegisterUserCommand();
var mockUserService = Substitute.For <IUserService>();
mockUserService.GetUserInfo(Arg.Any <CancellationToken>()).Returns(new TestUser(_fixture.Create <string>(), _fixture.Create <string>(), _fixture.Create <string>()));
var sut = new RegisterUserCommandHandler(mockUserService, Context, Mapper);
var result = await sut.Handle(registerUserCommand, CancellationToken.None);
result.IsSuccess.Should().BeTrue();
}
public async Task GivenRegisterUserCommandHandler_WhenNewUserDetailsAreProvided_ThenCreatesNewUser()
{
_mockUserManager.FindByEmailAsync(_command.Email).ReturnsNullForAnyArgs();
_mockUserManager.CreateAsync(_user, _command.Password)
.ReturnsForAnyArgs(Task.FromResult(IdentityResult.Success));
var registerCommandHandler =
new RegisterUserCommandHandler(_mockUserManager, _mockJwtGenerator, _mockEventBus,
_mockUserConfirmationEmail, _mockFailedIdentityResult);
var registeredUser = await registerCommandHandler.Handle(_command, CancellationToken.None);
Assert.NotNull(registeredUser);
}
GivenRegisterUserCommandHandler_WhenNewUserDetailsAreProvided_ThenShouldCallUserManagerToFindExistingUser()
{
_mockUserManager.FindByEmailAsync(_command.Email).ReturnsNullForAnyArgs();
_mockUserManager.CreateAsync(_user, _command.Password)
.ReturnsForAnyArgs(Task.FromResult(IdentityResult.Success));
var registerCommandHandler =
new RegisterUserCommandHandler(_mockUserManager, _mockJwtGenerator, _mockEventBus,
_mockUserConfirmationEmail, _mockFailedIdentityResult);
await registerCommandHandler.Handle(_command, CancellationToken.None);
await _mockUserManager.Received().FindByEmailAsync(Arg.Any <string>());
}
public void RegisterUserCommandHandler_Fails_For_Existing_Email()
{
var handler = new RegisterUserCommandHandler(_repository, _mailClient, new ActivationMailTemplate(_appSettings));
var command = new RegisterUserCommand("*****@*****.**", "test");
_context.Users.Add(new User("*****@*****.**", "test"));
var result = handler.Execute(command);
result.Errors.Should().HaveCount(1);
result.Errors[0].Expression.ToString().Should().Be("p => p.Email");
result.Errors[0].Message.Should().Be("Email address already exists");
_mailClient.SentMessages.Should().BeEmpty();
}
public void RegisterUserCommandHandler_Succeeds()
{
var handler = new RegisterUserCommandHandler(_repository, _mailClient, new ActivationMailTemplate(_appSettings));
var command = new RegisterUserCommand("*****@*****.**", "test");
var result = handler.Execute(command);
var user = _context.Users.SingleOrDefault();
result.Errors.Should().BeEmpty();
user.Should().NotBeNull();
user.Status.Should().Be(UserStatus.New);
user.UserEvents.Should().HaveCount(1);
user.UserEvents.Single().Type.Should().Be(UserEventType.Registered);
}
public async Task GivenAlreadyExistingUser_Handle_ShouldReturnUserAlreadyRegisteredError()
{
var registerUserCommand = new RegisterUserCommand();
var mockUserService = new Mock <IUserService>();
mockUserService.Setup(service => service.GetUserInfo(It.IsAny <CancellationToken>()))
.ReturnsAsync(new TestUser("test-id", "Test User", "*****@*****.**"));
var sut = new RegisterUserCommandHandler(mockUserService.Object, Context, Mapper);
var result = await sut.Handle(registerUserCommand, CancellationToken.None);
result.Error.Code.ShouldBe(Errors.General.UserAlreadyRegistered().Code);
}
public async Task GivenNewUser_Handle_ShouldBeAbleToRegisterUser()
{
var registerUserCommand = new RegisterUserCommand();
var mockUserService = new Mock <IUserService>();
mockUserService.Setup(service => service.GetUserInfo(It.IsAny <CancellationToken>()))
.ReturnsAsync(new TestUser("new-id", "New User", "*****@*****.**"));
var sut = new RegisterUserCommandHandler(mockUserService.Object, Context, Mapper);
var result = await sut.Handle(registerUserCommand, CancellationToken.None);
result.IsSuccess.ShouldBe(true);
}
GivenRegisterUserCommandHandler_WhenNewUserFailedToRegister_ThenShouldCallFailedIdentityResult()
{
_mockUserManager.FindByEmailAsync(_command.Email).ReturnsNullForAnyArgs();
_mockUserManager.CreateAsync(_user, _command.Password)
.ReturnsForAnyArgs(Task.FromResult(IdentityResult.Failed()));
var registerCommandHandler =
new RegisterUserCommandHandler(_mockUserManager, _mockJwtGenerator, _mockEventBus,
_mockUserConfirmationEmail, _mockFailedIdentityResult);
await registerCommandHandler.Handle(_command, CancellationToken.None);
_mockFailedIdentityResult.Received()
.Handle(Arg.Any <AppUser>(), Arg.Any <List <IdentityError> >(), Arg.Any <string>());
}
public async Task GivenAlreadyExistingUser_WhenCallingHandle_ThenResultShouldBeFailure()
{
var registerUserCommand = new RegisterUserCommand();
var mockUserService = new Mock <IUserService>();
mockUserService.Setup(service => service.GetUserInfo(It.IsAny <CancellationToken>()))
.ReturnsAsync(new TestUser("test-id", "Test User", "*****@*****.**"));
var sut = new RegisterUserCommandHandler(mockUserService.Object, Context, Mapper);
var result = await sut.Handle(registerUserCommand, CancellationToken.None);
result.IsFailure.Should().BeTrue();
}
public void RegistrationCommand_PresentWeakPassword_ThrowsException()
{
// ---- Arrange ----
const string name = "test user";
const string email = "*****@*****.**";
const string weakPassword = "******";
var command = new RegisterUserCommand(email, name, weakPassword);
var handler = new RegisterUserCommandHandler(_repositoryProviderMock.Object);
// ---- Act & Assert ----
Assert.ThrowsAsync <WeakPasswordException>(async() =>
await handler.Handle(command, CancellationToken.None));
}
public void Should_ThrowException_When_CommandIsNull()
{
var userRepositoryMock = new Mock <IUserRepository>();
var roleLookupMock = new Mock <IRoleLookup>();
var mapperMock = new Mock <IMapper>();
mapperMock.Setup(m => m.Map <RegisterUserCommand, User>(It.IsAny <RegisterUserCommand>())).Returns((User)null);
var target = new RegisterUserCommandHandler(userRepositoryMock.Object, roleLookupMock.Object, mapperMock.Object);
var command = new RegisterUserCommand();
Func <Task> func = async() => await target.HandleAsync(command);
func.ShouldThrow <NullReferenceException>();
}
public async Task GivenValidRegisterUserCommand_WhenCallingHandle_ThenNewUserShouldBeReturned(string newUserId, string newUserDisplayName, string newUserEmailAddress)
{
var registerUserCommand = new RegisterUserCommand();
var mockUserService = Substitute.For <IUserService>();
mockUserService.GetUserInfo(Arg.Any <CancellationToken>()).Returns(new TestUser(newUserId, newUserDisplayName, newUserEmailAddress));
var sut = new RegisterUserCommandHandler(mockUserService, Context, Mapper);
var result = await sut.Handle(registerUserCommand, CancellationToken.None);
result.Value.Id.Should().BePositive();
result.Value.ExternalUserId.Should().Be(newUserId);
result.Value.DisplayName.Should().Be(newUserDisplayName);
result.Value.EmailAddress.Should().Be(newUserEmailAddress);
}
public void RegistrationCommand_PresentInvalidFormattedEmail_ThrowsException()
{
// ---- Arrange ----
const string invalidEmail = "invalid_email";
const string name = "test user";
const string password = "******";
var command = new RegisterUserCommand(invalidEmail, name, password);
var handler = new RegisterUserCommandHandler(_repositoryProviderMock.Object);
// ---- Act & Assert
var exception = Assert.ThrowsAsync <InvalidEmailFormatException>(async() =>
await handler.Handle(command, CancellationToken.None));
Assert.AreEqual(invalidEmail, exception.Email);
}
