public Boolean CanReset(AccountResetView view)
{
Boolean isValid = IsValidResetToken(view.Token);
isValid &= ModelState.IsValid;
return isValid;
}
public void Reset_ResetsAccount()
{
Account account = context.Set <Account>().AsNoTracking().Single();
AccountResetView view = ObjectFactory.CreateAccountResetView();
hasher.HashPassword(view.NewPassword).Returns("Reset");
account.RecoveryTokenExpirationDate = null;
account.RecoveryToken = null;
account.Passhash = "Reset";
service.Reset(view);
Account actual = context.Set <Account>().AsNoTracking().Single();
Account expected = account;
Assert.Equal(expected.RecoveryTokenExpirationDate, actual.RecoveryTokenExpirationDate);
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.Equal(expected.RoleId, actual.RoleId);
Assert.Equal(expected.Email, actual.Email);
Assert.Equal(expected.Id, actual.Id);
}
public void Reset(AccountResetView view)
{
Account account = UnitOfWork.Repository <Account>().Single(acc => acc.RecoveryToken == view.Token);
account.Passhash = hasher.HashPassword(view.NewPassword);
account.RecoveryTokenExpirationDate = null;
account.RecoveryToken = null;
UnitOfWork.Repository <Account>().Update(account);
UnitOfWork.Commit();
}
public void Reset(AccountResetView view)
{
Account account = UnitOfWork.Select <Account>().Single(model => model.RecoveryToken == view.Token);
account.Passhash = Hasher.HashPassword(view.NewPassword);
account.RecoveryTokenExpirationDate = null;
account.RecoveryToken = null;
UnitOfWork.Update(account);
UnitOfWork.Commit();
}
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 Reset(AccountResetView account)
{
if (Service.IsLoggedIn())
{
return(RedirectToDefault());
}
if (!Validator.CanReset(account))
{
return(RedirectToAction("Recover"));
}
Service.Reset(account);
Alerts.Add(AlertTypes.Success, Messages.SuccesfulReset);
return(RedirectToAction("Login"));
}
public void Reset_ResetsAccount()
{
AccountResetView accountReset = ObjectFactory.CreateAccountResetView();
Account expected = context.Set <Account>().AsNoTracking().Single();
hasher.HashPassword(accountReset.NewPassword).Returns("Reset");
service.Reset(accountReset);
Account actual = context.Set <Account>().Single();
expected.RecoveryTokenExpirationDate = null;
expected.RecoveryToken = null;
expected.Passhash = "Reset";
TestHelper.PropertyWiseEqual(expected, actual);
}
public ActionResult Reset(String token)
{
if (Service.IsLoggedIn())
{
return(RedirectToDefault());
}
AccountResetView account = new AccountResetView();
account.Token = token;
if (!Validator.CanReset(account))
{
return(RedirectToAction("Recover"));
}
return(View());
}
public ActionResult Reset(AccountResetView account)
{
if (Service.IsLoggedIn(User))
{
return(RedirectToDefault());
}
if (!Validator.CanReset(account))
{
return(RedirectIfAuthorized("Recover"));
}
Service.Reset(account);
Alerts.AddSuccess(Messages.SuccessfulReset, 4000);
return(RedirectIfAuthorized("Login"));
}
public ActionResult Reset(AccountResetView account)
{
if (Service.IsLoggedIn(User))
{
return(RedirectToDefault());
}
if (!Validator.CanReset(account))
{
return(RedirectToAction(nameof(Recover)));
}
Service.Reset(account);
Alerts.AddSuccess(Message.For <AccountView>("SuccessfulReset"), 4000);
return(RedirectToAction(nameof(Login)));
}
public void Reset_Account()
{
AccountResetView view = ObjectsFactory.CreateAccountResetView();
service.Reset(view);
Account actual = context.Set <Account>().AsNoTracking().Single();
Account expected = account;
Assert.Equal(hasher.HashPassword(view.NewPassword !), actual.Passhash);
Assert.Equal(expected.CreationDate, actual.CreationDate);
Assert.Equal(expected.IsLocked, actual.IsLocked);
Assert.Equal(expected.Username, actual.Username);
Assert.Null(actual.RecoveryTokenExpirationDate);
Assert.Equal(expected.RoleId, actual.RoleId);
Assert.Equal(expected.Email, actual.Email);
Assert.Equal(expected.Id, actual.Id);
Assert.Null(actual.RecoveryToken);
}
