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 ThenTheCommandIsHandledAndValidatorCalled() { //Arrange _registerUserCommandValidator.Setup(x => x.ValidateAsync(It.IsAny <RegisterUserCommand>())).ReturnsAsync(new ValidationResult { ValidationDictionary = new Dictionary <string, string> { { "MyError", "Some error has happened" } } }); //Act var actual = Assert.ThrowsAsync <InvalidRequestException>(async() => await _registerUserCommandHandler.Handle(new RegisterUserCommand())); //Assert _registerUserCommandValidator.Verify(x => x.ValidateAsync(It.IsAny <RegisterUserCommand>())); Assert.Contains(new KeyValuePair <string, string>("MyError", "Some error has happened"), actual.ErrorMessages); }
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 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); }
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 void Handle(RegisterUserCommand command) { command.User.Salt = HashPassword.GenerateSalt(50); command.User.Password = HashPassword.GenerateHash(command.User.Password, command.User.Salt); using (_unitOfWork = new UnitOfWork()) { _handler.Handle(command); } }
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)); }
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 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_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 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 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_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 Handler_Register() { var registerUser = new User { Email = "*****@*****.**", FullName = "test test" }; _command = new RegisterUserCommand { Email = registerUser.Email, FullName = registerUser.FullName, Password = "******" }; var result = await _registerUserCommandHandler.Handle(_command, CancellationToken.None); result.Message.Should().Be(Messages.Added); }
public async Task Handler_Register() { var registerUser = new User(); registerUser.Email = "*****@*****.**"; registerUser.FullName = "test test"; command = new RegisterUser.Command { Email = registerUser.Email, FullName = registerUser.FullName, Password = "******" }; var result = await registerUserCommandHandler.Handle(command, new System.Threading.CancellationToken()); Assert.That(result.Message, Is.EqualTo(Messages.Added)); }
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 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); }
public void RegistrationCommand_PresentInvalidFormattedName_ThrowsException() { // ---- Arrange ---- const string badName = ""; const string email = "*****@*****.**"; const string password = "******"; var command = new RegisterUserCommand(email, badName, password); var handler = new RegisterUserCommandHandler(_repositoryProviderMock.Object); // ---- Act & Assert ---- var exception = Assert.ThrowsAsync <InvalidNameFormatException>(async() => await handler.Handle(command, CancellationToken.None)); Assert.AreEqual(badName, exception.Name); }
public async Task Should_pass_user_registration_result_from_user_manager_to_caller() { // Act var expectedResult = Result.Success(); var userManagerMock = new Mock <IUserManager>(); userManagerMock .Setup(mock => mock.CreateAsync("*****@*****.**", "P@ssw0rd")) .ReturnsAsync(expectedResult); var handler = new RegisterUserCommandHandler(userManagerMock.Object); // Act var actualResult = await handler.Handle(new RegisterUserCommand("*****@*****.**", "P@ssw0rd")); // Assert actualResult.Result.Should().Be(expectedResult); }
public async Task Should_Raise_UserRegisteredEvent_When_UserRegistered() { //Arrange var mediatorMock = new Mock <IMediator>(); Mock <IUserManagerService> userManagerService = new Mock <IUserManagerService>(); Mock <IIdentityDataContext> identityDataContext = new Mock <IIdentityDataContext>(); var applicationUser = new ApplicationUser() { Email = String.Empty, UserName = String.Empty, FirstName = String.Empty, LastName = String.Empty, Id = 1, PasswordHash = String.Empty }; userManagerService.Setup(r => r.CreateUser(It.IsAny <ApplicationUser>(), It.IsAny <String>())) .Returns(Task.FromResult(applicationUser)); mediatorMock.Setup(p => p.Publish(It.IsAny <UserRegisteredEvent>(), It.IsAny <CancellationToken>())) .Returns(Task.CompletedTask); var sut = new RegisterUserCommandHandler(identityDataContext.Object, _mapper, _logger, mediatorMock.Object, userManagerService.Object); //Act await sut.Handle(new RegisterUserCommand( firstName : String.Empty, lastName : String.Empty, password : String.Empty, email : String.Empty, dateOfBirth : DateTime.Now, userName : String.Empty ), It.IsAny <CancellationToken>()); //Assert mediatorMock.Verify(m => m.Publish(It.Is <UserRegisteredEvent>(cc => cc.Id == applicationUser.Id), It.IsAny <CancellationToken>()), Times.Once); }
public void Handle_GivenValidRequest_ShouldRaiseUserRegisteredNotification() { // Arrange var mediatorMock = new Mock <IMediator>(); var sut = new RegisterUserCommandHandler(_context, mediatorMock.Object); var cmd = new RegisterUserCommand() { Email = "*****@*****.**", FirstName = "Petar", IsBusinessOwner = false, LastName = "Peric", Username = "******" }; // Act var result = sut.Handle(cmd, CancellationToken.None); // Assert mediatorMock.Verify(m => m.Publish(It.Is <UserRegistered>(cc => cc.Data.Username == cmd.Email), It.IsAny <CancellationToken>()), Times.Once); }
public void RegistrationCommand_PresentAlreadyExistsEmail_ThrowsException() { // ---- Arrange ---- const string name = "test user"; const string email = "*****@*****.**"; const string password = "******"; _authRepositoryMock.Setup(r => r.IsUserIdentityExists(email)) .ReturnsAsync(true); var command = new RegisterUserCommand(email, name, password); var handler = new RegisterUserCommandHandler(_repositoryProviderMock.Object); // ---- Act & Assert ---- var exception = Assert.ThrowsAsync <UserAlreadyExistsException>(async() => await handler.Handle(command, CancellationToken.None)); _authRepositoryMock.Verify(r => r.IsUserIdentityExists(email), Times.Once); Assert.AreEqual(email, exception.Email); }
public void Handle_OnValidData_ReturnsProperMessage() { var userServiceMock = new Mock <IUserService>(); userServiceMock .Setup(x => x.RegisterAsync(It.IsAny <RegisterUserCommand>())) .Returns(Task.FromResult("some text")); var sut = new RegisterUserCommandHandler(userServiceMock.Object); var registerCommand = new RegisterUserCommand { Email = "*****@*****.**", Password = "******" }; var result = sut.Handle(registerCommand, new CancellationToken()); result.Should().NotBeNull(); result.Result.Message.Should().NotBeNull(); result.Result.Message.Should().Be("some text"); }
public async Task Should_Throws_DuplicateException_When_User_Already_Exists() { //Arrange var mediatorMock = new Mock <IMediator>(); Mock <IUserManagerService> userManagerService = new Mock <IUserManagerService>(); Mock <IIdentityDataContext> identityDataContext = new Mock <IIdentityDataContext>(); var applicationUser = new ApplicationUser() { Email = String.Empty, UserName = String.Empty, FirstName = String.Empty, LastName = String.Empty, Id = 1, PasswordHash = String.Empty }; userManagerService.Setup(r => r.CreateUser(It.IsAny <ApplicationUser>(), It.IsAny <String>())) .Throws <DuplicateException>(); mediatorMock.Setup(p => p.Publish(It.IsAny <UserRegisteredEvent>(), It.IsAny <CancellationToken>())) .Returns(Task.CompletedTask); var sut = new RegisterUserCommandHandler(identityDataContext.Object, _mapper, _logger, mediatorMock.Object, userManagerService.Object); //Act/Assert await Assert.ThrowsAsync <DuplicateException>(async() => { await sut.Handle(new RegisterUserCommand( firstName: String.Empty, lastName: String.Empty, password: String.Empty, email: String.Empty, dateOfBirth: DateTime.Now, userName: String.Empty ), It.IsAny <CancellationToken>()); }); }
public async Task GivenNewUser_Handle_ShouldReturnNewRegisteredUser() { var registerUserCommand = new RegisterUserCommand(); const string expectedNewUserId = "new-id"; const string expectedNewUserDisplayName = "New User"; const string expectedNewUserEmailAddress = "*****@*****.**"; var mockUserService = new Mock <IUserService>(); mockUserService.Setup(service => service.GetUserInfo(It.IsAny <CancellationToken>())) .ReturnsAsync(new TestUser(expectedNewUserId, expectedNewUserDisplayName, expectedNewUserEmailAddress)); var sut = new RegisterUserCommandHandler(mockUserService.Object, Context, Mapper); var result = await sut.Handle(registerUserCommand, CancellationToken.None); result.Value.Id.ShouldBeGreaterThan(0); result.Value.DisplayName.ShouldBe(expectedNewUserDisplayName); result.Value.EmailAddress.ShouldBe(expectedNewUserEmailAddress); result.Value.ExternalUserId.ShouldBe(expectedNewUserId); }