public void EmailTests_HappyPath() { var repoMoq = new Mock <ISomeBoundedRepository>(); var customers = new[] { new Customer() { Id = 1, Email = "*****@*****.**" }, new Customer() { Id = 2, Email = "*****@*****.**" }, }; repoMoq.Setup(e => e.Entity <Customer>()).Returns(customers.AsQueryable()); var command = new ChangeEmailCommand(repoMoq.Object); const string newEmail = "[email protected]"; command.Change(1, newEmail); Assert.AreEqual(newEmail, customers.Where(e => e.Id == 1).Single().Email); }
private async Task ExecuteMethodReturnsUserIsNull() { //Arrange var mocks = GetMocks(); var users = GetUsers().AsQueryable().BuildMock(); SetSettingsInDb(mocks.userMock, users); mocks.dbMock.Setup(m => m.Users).Returns(mocks.userMock.Object); var changeEmail = new ChangeEmailCommand(mocks.dbMock.Object); var message = new Message() { Chat = new Chat() { Id = 2 }, Text = "/changeEmail@[email protected]" }; var client = new TelegramBotClient(AppConfig.Token); //Act var result = await changeEmail.Execute(message, client); //Assert Assert.NotNull(result); Assert.False(result?.isSuccessed); Assert.Equal("User is null", result?.Message); }
public void Arrange() { _passwordService = new Mock <IPasswordService>(); _passwordService.Setup(s => s.VerifyAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())) .Returns(Task.FromResult(false)); _passwordService.Setup(s => s.VerifyAsync(Password, Hashedpassword, Salt, PasswordProfileId)) .Returns(Task.FromResult(true)); _validator = new ChangeEmailCommandValidator(_passwordService.Object); _command = new ChangeEmailCommand { User = new Domain.User { Id = "USER1", Password = Hashedpassword, Salt = Salt, PasswordProfileId = PasswordProfileId, SecurityCodes = new[] { new Domain.SecurityCode { Code = SecurityCode, CodeType = Domain.SecurityCodeType.ConfirmEmailCode, ExpiryTime = DateTime.MaxValue } } }, SecurityCode = SecurityCode, Password = Password }; }
public async Task <APIResult> ChangeEmail([FromBody] ChangeEmailCommand command) { var rs = await mediator.Send(command); return(new APIResult() { Result = rs }); }
public async Task <bool> Handle(ChangeEmailCommand request, CancellationToken cancellationToken) { var result = await _userAppService.ChangeEmail(request); if (result == null) { throw new UserFriendlyException("An error has been occurred while changing email. Please try again later."); } return(true); }
private void ChangeEmail(User user, ChangeEmailCommand command) { if (user.Email != command.OldEmail) { throw new ServerSideException("Old email and user email does not match"); } user.Email = command.NewEmail; user.IsAccountConfirmed = false; user.ConfirmGuid = new Guid(); }
public async Task <User> ChangeEmail(ChangeEmailCommand command) { var user = await _userRepository.GetByUniqueIdAsync(command.UserId); if (user == null) { throw new UserFriendlyException("The user does not found!"); } user.ChangeEmail(command.Email); await _userRepository.SaveChanges(); return(user); }
public async Task Handle(ChangeEmailCommand command) { try { var settings = await Repository.GetByKeyAsync<Domain.Models.GeneralSettings>(command.SettingsId); settings.ChangeEmail(command.Email); await Repository.SaveChangesAsync(); } catch { throw; } }
public async Task <UserDto> ChangeEmail(ChangeEmailCommand command) { var user = await _dbContext.Users.FirstOrDefaultAsync(e => e.Id == command.UserId); if (user == null) { throw new UserFriendlyException("The user does not found!"); } user.ChangeEmail(command.Email); await _dbContext.SaveChangesAsync(); return(Mapper.Map <UserDto>(user)); }
private void ContaintMethodReturnsFalse() { //Arrange var dbMock = new Mock <TelegramBotContext>(); var changeEmail = new ChangeEmailCommand(dbMock.Object); var message = new Message() { Text = Guid.NewGuid().ToString() }; //Act var result = changeEmail.IsContains(message); //Assert Assert.False(result); }
private void ContaintMethodReturnsTrue() { //Arrange var dbMock = new Mock <TelegramBotContext>(); var changeEmail = new ChangeEmailCommand(dbMock.Object); var message = new Message() { Text = "/changeEmail" }; //Act var result = changeEmail.IsContains(message); //Assert Assert.True(result); }
public async Task Post_email_mal_formado_BadRequest(string email) { // Arrange await GetAuthenticatedClientAsync(); var userManager = ServiceProvider.GetRequiredService <UserManager <ApplicationUser> >(); var user = await userManager.FindByNameAsync("Admin"); var data = new ChangeEmailCommand(user.Id, email); var requestContent = SerializerUtils.GetRequestContent(data); // Act var response = await Client.PostAsync(BaseUrl, requestContent); // Assert response.StatusCode.ShouldBe(HttpStatusCode.BadRequest); }
public async Task Post_id_usuario_no_existe_NotFound() { // Arrange await GetAuthenticatedClientAsync(); var userManager = ServiceProvider.GetRequiredService <UserManager <ApplicationUser> >(); var user = await userManager.FindByNameAsync("Admin"); var data = new ChangeEmailCommand("123123213", user.Email); var requestContent = SerializerUtils.GetRequestContent(data); // Act var response = await Client.PostAsync(BaseUrl, requestContent); // Assert response.StatusCode.ShouldBe(HttpStatusCode.NotFound); }
public async Task Post_cambiar_email_datos_correctos_Ok() { // Arrange await GetAuthenticatedClientAsync(); var userManager = ServiceProvider.GetRequiredService <UserManager <ApplicationUser> >(); var user = await userManager.FindByNameAsync("Admin"); var data = new ChangeEmailCommand(user.Id, "*****@*****.**"); var requestContent = SerializerUtils.GetRequestContent(data); // Act var response = await Client.PostAsync(BaseUrl, requestContent); // Assert response.EnsureSuccessStatusCode(); }
public async Task InvokeHandler() { // Arrange var updateEmailHandler = new Mock <ICommandHandlerAsync <ChangeEmailCommand> >(); var handlers = new Dictionary <Type, IEnumerable <object> > { { typeof(ICommandHandlerAsync <ChangeEmailCommand>), new object[] { updateEmailHandler.Object } } }; var sut = new CommandDispatcher(handlers); var updateEmailCommand = new ChangeEmailCommand("somemail", "newmail"); // Act await sut.DispatchAsync(updateEmailCommand); // Assert updateEmailHandler.Verify(handler => handler.HandleAsync(updateEmailCommand), Times.Once); }
public async Task NotInvokeHandlerWhenOfInvalidType() { // Arrange var updateEmailHandler = new Mock <ICommandHandlerAsync <ChangeEmailCommand> >(); var handlers = new Dictionary <Type, IEnumerable <object> > { { typeof(ICommandHandlerAsync <ChangeEmailCommand>), new[] { new { Invalid = "Handler" } } } }; var updateEmailCommand = new ChangeEmailCommand("somemail", "newmail"); var sut = new CommandDispatcher(handlers); // Act await sut.DispatchAsync(updateEmailCommand); // Assert updateEmailHandler.Verify(handler => handler.HandleAsync(updateEmailCommand), Times.Never); }
public void Buses_CommandBus_ChangeEmailFor1005TimesTest() { SourcedCustomer customer = new SourcedCustomer(); using (IDomainRepository domainRepository = application.ObjectContainer.GetService <IDomainRepository>()) { domainRepository.Save(customer); domainRepository.Commit(); } ChangeEmailCommand cmd = new ChangeEmailCommand(customer.ID, "*****@*****.**"); using (ICommandBus bus = application.ObjectContainer.GetService <ICommandBus>()) { bus.Publish(cmd); bus.Commit(); } }
public void Handle(ChangeEmailCommand command) { ValidateCommandParameters(command); using (var dbContext = new UserAccountDataContext()) { User user = dbContext.Users.SingleOrDefault(u => u.Id == command.UserId); if (user == null) { throw new ServerSideException("Ups, something went wrong! Refresh page and try agine"); } ChangeEmail(user, command); dbContext.SaveChanges(); // TODO add event: User email changed - send confirm email } }
public void Arrange() { _validator = new Mock <IValidator <ChangeEmailCommand> >(); _validator.Setup(v => v.ValidateAsync(It.IsAny <ChangeEmailCommand>())) .ReturnsAsync(new ValidationResult()); _userRepository = new Mock <IUserRepository>(); _auditService = new Mock <IAuditService>(); _handler = new ChangeEmailCommandHandler(_validator.Object, _userRepository.Object, _auditService.Object); _command = new ChangeEmailCommand { User = new Domain.User { Id = UserId, Email = OldEmail, SecurityCodes = new[] { new Domain.SecurityCode { Code = SecurityCode, CodeType = Domain.SecurityCodeType.ConfirmEmailCode, ExpiryTime = DateTime.MaxValue, ReturnUrl = ReturnUrl, PendingValue = NewEmail }, new Domain.SecurityCode { Code = "WRONG-CODE", CodeType = Domain.SecurityCodeType.ConfirmEmailCode, ExpiryTime = DateTime.Now.AddDays(30), ReturnUrl = "http://not-here" } } }, SecurityCode = SecurityCode, Password = Password }; }
private void ValidateCommandParameters(ChangeEmailCommand command) { if (!IsValidEmail(command.OldEmail)) { throw new ServerSideException("Your old email has invalid format"); } if (!IsValidEmail(command.NewEmail)) { throw new ServerSideException("Your new email has invalid format"); } if (!IsValidEmail(command.NewEmailRepeat)) { throw new ServerSideException("Your confirm email has invalid format"); } if (command.NewEmail != command.NewEmailRepeat) { throw new ServerSideException("Emails does not match"); } }
public void EmailTests_NoCustomer() { var repoMoq = new Mock <ISomeBoundedRepository>(); var customers = new[] { new Customer() { Id = 1, Email = "*****@*****.**" }, new Customer() { Id = 2, Email = "*****@*****.**" }, }; repoMoq.Setup(e => e.Entity <Customer>()).Returns(customers.AsQueryable()); var command = new ChangeEmailCommand(repoMoq.Object); const string newEmail = "asdasd2222"; command.Change(67756756, newEmail); }
public async Task <ActionResult> ChangeEmail(ChangeEmailCommand changeEmailCommand) { return(Ok(await Mediator.Send(changeEmailCommand))); }
public async Task <ActionResult <ChangeEmailDto> > ChangeEmail(ChangeEmailCommand command) { return(await Mediator.Send(command)); }
public async Task <IActionResult> ChangeEmail(ChangeEmailCommand command) { throw new NotImplementedException(); }
public ActionResult ChangeEmail(ChangeEmailCommand command) { HandleCommand(command, Json("User email changed")); return(RedirectToAction("Index")); }