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);
}
