public void Recover_Information() { AccountRecoveryView view = ObjectsFactory.CreateAccountRecoveryView(); account.RecoveryTokenExpirationDate = DateTime.Now.AddMinutes(30); String?oldToken = account.RecoveryToken; view.Email = view.Email?.ToUpper(); account.RecoveryToken = service.Recover(view); Account actual = context.Set <Account>().AsNoTracking().Single(); Account expected = account; Assert.InRange(actual.RecoveryTokenExpirationDate !.Value.Ticks, expected.RecoveryTokenExpirationDate.Value.Ticks - TimeSpan.TicksPerSecond, expected.RecoveryTokenExpirationDate.Value.Ticks + TimeSpan.TicksPerSecond); Assert.Equal(expected.RecoveryToken, actual.RecoveryToken); Assert.Equal(expected.CreationDate, actual.CreationDate); Assert.Equal(expected.IsLocked, actual.IsLocked); Assert.Equal(expected.Passhash, actual.Passhash); Assert.Equal(expected.Username, actual.Username); Assert.NotEqual(oldToken, actual.RecoveryToken); Assert.Equal(expected.RoleId, actual.RoleId); Assert.Equal(expected.Email, actual.Email); Assert.Equal(expected.Id, actual.Id); Assert.NotNull(actual.RecoveryToken); }
public async Task <ActionResult> Recover(AccountRecoveryView account) { if (Service.IsLoggedIn(User)) { return(RedirectToDefault()); } if (!Validator.CanRecover(account)) { return(View(account)); } String token = Service.Recover(account); if (token != null) { String url = Url.Action("Reset", "Auth", new { token }, Request.Url.Scheme); await MailClient.SendAsync( account.Email, Messages.RecoveryEmailSubject, String.Format(Messages.RecoveryEmailBody, url)); } Alerts.Add(AlertType.Info, Messages.RecoveryInformation, 0); return(RedirectToAction("Login")); }
public void Recover_UpdatesAccountRecoveryInformation() { Account account = context.Set <Account>().AsNoTracking().Single(); account.RecoveryTokenExpirationDate = DateTime.Now.AddMinutes(30); AccountRecoveryView recoveryAccount = ObjectFactory.CreateAccountRecoveryView(); recoveryAccount.Email = recoveryAccount.Email.ToLower(); service.Recover(recoveryAccount); Account actual = context.Set <Account>().AsNoTracking().Single(); Account expected = account; Assert.AreEqual(expected.RecoveryTokenExpirationDate.Value.Ticks, actual.RecoveryTokenExpirationDate.Value.Ticks, TimeSpan.TicksPerSecond * 2); Assert.AreNotEqual(expected.RecoveryToken, actual.RecoveryToken); Assert.AreEqual(expected.CreationDate, actual.CreationDate); Assert.AreEqual(expected.Passhash, actual.Passhash); Assert.AreEqual(expected.Username, actual.Username); Assert.AreEqual(expected.RoleId, actual.RoleId); Assert.AreEqual(expected.Email, actual.Email); Assert.AreEqual(expected.Id, actual.Id); Assert.IsNotNull(actual.RecoveryToken); }
public async Task <ActionResult> Recover(AccountRecoveryView account) { if (Service.IsLoggedIn(User)) { return(RedirectToDefault()); } if (!Validator.CanRecover(account)) { return(View(account)); } if (Service.Recover(account) is String token) { String url = Url.Action("Reset", "Auth", new { token }, Request.Scheme); await MailClient.SendAsync(account.Email !, Message.For <AccountView>("RecoveryEmailSubject"), Message.For <AccountView>("RecoveryEmailBody", url)); } Alerts.AddInfo(Message.For <AccountView>("RecoveryInformation")); return(RedirectToAction("Login")); }
public void Recover_NoEmail_ReturnsNull() { AccountRecoveryView view = ObjectsFactory.CreateAccountRecoveryView(); view.Email = "*****@*****.**"; Assert.Null(service.Recover(view)); }
public void Recover_DoesNotSendRecoveryInformation() { AccountRecoveryView account = ObjectFactory.CreateAccountRecoveryView(); account.Email = "*****@*****.**"; service.Recover(account); mailClient.DidNotReceive().Send(Arg.Any <String>(), Arg.Any <String>(), Arg.Any <String>()); }
public void SetUp() { validator = Substitute.For <IAccountValidator>(); service = Substitute.For <IAccountService>(); accountRecovery = ObjectFactory.CreateAccountRecoveryView(); accountReset = ObjectFactory.CreateAccountResetView(); accountLogin = ObjectFactory.CreateAccountLoginView(); account = new AccountView(); controller = Substitute.ForPartsOf <AuthController>(validator, service); controller.ControllerContext = new ControllerContext(); }
public void SetUp() { validator = Substitute.For <IAccountValidator>(); service = Substitute.For <IAccountService>(); accountRecovery = ObjectFactory.CreateAccountRecoveryView(); accountReset = ObjectFactory.CreateAccountResetView(); accountLogin = ObjectFactory.CreateAccountLoginView(); account = new AccountView(); controller = Substitute.ForPartsOf <AuthController>(service, validator); controller.Url = new UrlHelper(new HttpMock().HttpContext.Request.RequestContext); controller.ControllerContext = new ControllerContext(); }
public AuthControllerTests() { mail = Substitute.For <IMailClient>(); service = Substitute.For <IAccountService>(); validator = Substitute.For <IAccountValidator>(); controller = Substitute.ForPartsOf <AuthController>(validator, service, mail); controller.ControllerContext.HttpContext = Substitute.For <HttpContext>(); controller.TempData = Substitute.For <ITempDataDictionary>(); controller.ControllerContext.RouteData = new RouteData(); controller.Url = Substitute.For <IUrlHelper>(); accountRecovery = ObjectFactory.CreateAccountRecoveryView(); accountReset = ObjectFactory.CreateAccountResetView(); accountLogin = ObjectFactory.CreateAccountLoginView(); }
public AuthControllerTests() { mailClient = Substitute.For <IMailClient>(); service = Substitute.For <IAccountService>(); validator = Substitute.For <IAccountValidator>(); controller = Substitute.ForPartsOf <AuthController>(validator, service, mailClient); HttpContextBase context = HttpContextFactory.CreateHttpContextBase(); controller.Url = new UrlHelper(context.Request.RequestContext); controller.ControllerContext = new ControllerContext(); controller.ControllerContext.HttpContext = context; accountRecovery = ObjectFactory.CreateAccountRecoveryView(); accountReset = ObjectFactory.CreateAccountResetView(); accountLogin = ObjectFactory.CreateAccountLoginView(); }
public ActionResult Recover(AccountRecoveryView account) { if (Service.IsLoggedIn()) { return(RedirectToDefault()); } if (!Validator.CanRecover(account)) { return(View(account)); } Service.Recover(account); Alerts.Add(AlertTypes.Info, Messages.RecoveryInformation, 0); return(RedirectToAction("Login")); }
public String Recover(AccountRecoveryView view) { Account account = UnitOfWork.Select <Account>().SingleOrDefault(model => model.Email.ToLower() == view.Email.ToLower()); if (account == null) { return(null); } account.RecoveryTokenExpirationDate = DateTime.Now.AddMinutes(30); account.RecoveryToken = Guid.NewGuid().ToString(); UnitOfWork.Update(account); UnitOfWork.Commit(); return(account.RecoveryToken); }
public void Recover_SendsRecoveryInformation() { HttpRequest request = HttpContext.Current.Request; String scheme = HttpContext.Current.Request.Url.Scheme; Account recoveredAccount = context.Set <Account>().Single(); UrlHelper urlHelper = new UrlHelper(request.RequestContext); AccountRecoveryView account = ObjectFactory.CreateAccountRecoveryView(); service.Recover(account); String expectedEmail = account.Email; String expectedEmailSubject = Messages.RecoveryEmailSubject; String recoveryUrl = urlHelper.Action("Reset", "Auth", new { token = recoveredAccount.RecoveryToken }, scheme); String expectedEmailBody = String.Format(Messages.RecoveryEmailBody, recoveryUrl); mailClient.Received().Send(expectedEmail, expectedEmailSubject, expectedEmailBody); }
public void Recover_UpdatesAccountRecoveryInformation() { AccountRecoveryView account = ObjectFactory.CreateAccountRecoveryView(); Account expected = context.Set <Account>().AsNoTracking().Single(); String oldToken = expected.RecoveryToken; account.Email = account.Email.ToLower(); service.Recover(account); Account actual = context.Set <Account>().Single(); expected.RecoveryTokenExpirationDate = actual.RecoveryTokenExpirationDate; expected.RecoveryToken = actual.RecoveryToken; Assert.AreEqual(actual.RecoveryTokenExpirationDate.Value.Ticks, DateTime.Now.AddMinutes(30).Ticks, 10000000); Assert.AreNotEqual(oldToken, actual.RecoveryToken); TestHelper.PropertyWiseEqual(expected, actual); Assert.IsNotNull(actual.RecoveryToken); }
public void Recover(AccountRecoveryView view) { Account account = UnitOfWork.Repository <Account>().SingleOrDefault(acc => acc.Email.ToLower() == view.Email.ToLower()); if (account == null) { return; } account.RecoveryTokenExpirationDate = DateTime.Now.AddMinutes(30); account.RecoveryToken = Guid.NewGuid().ToString(); UnitOfWork.Repository <Account>().Update(account); UnitOfWork.Commit(); HttpRequest request = HttpContext.Current.Request; UrlHelper urlHelper = new UrlHelper(request.RequestContext); String url = urlHelper.Action("Reset", "Auth", new { token = account.RecoveryToken }, request.Url.Scheme); String recoveryEmailBody = String.Format(Messages.RecoveryEmailBody, url); mailClient.Send(account.Email, Messages.RecoveryEmailSubject, recoveryEmailBody); }
public Boolean CanRecover(AccountRecoveryView view) { return(ModelState.IsValid); }