public virtual ActionResult ResetPassword(string username, string token, PasswordResetViewModel model)
{
ViewBag.ResetTokenValid = _userService.ResetPasswordWithToken(username, token, model.NewPassword);
if (!ViewBag.ResetTokenValid)
{
ModelState.AddModelError("", "The Password Reset Token is not valid or expired.");
return(View(model));
}
return(RedirectToAction(MVC.Users.PasswordChanged()));
}
public virtual ActionResult ResetPassword(string username, string token, PasswordResetViewModel model)
{
// We don't want Login to have us as a return URL
// By having this value present in the dictionary BUT null, we don't put "returnUrl" on the Login link at all
ViewData[Constants.ReturnUrlViewDataKey] = null;
ViewBag.ResetTokenValid = UserService.ResetPasswordWithToken(username, token, model.NewPassword);
if (!ViewBag.ResetTokenValid)
{
ModelState.AddModelError("", "The Password Reset Token is not valid or expired.");
return(View(model));
}
return(RedirectToAction(MVC.Users.PasswordChanged()));
}
public void ResetsPasswordForValidToken()
{
var userService = new Mock <IUserService>();
userService.Setup(u => u.ResetPasswordWithToken("user", "token", "newpwd")).Returns(true);
var controller = CreateController(userSvc: userService);
var model = new PasswordResetViewModel
{
ConfirmPassword = "******",
NewPassword = "******"
};
var result = controller.ResetPassword("user", "token", model) as RedirectToRouteResult;
Assert.NotNull(result);
userService.Verify(u => u.ResetPasswordWithToken("user", "token", "newpwd"));
}
public void ShowsErrorIfTokenExpired()
{
var userService = new Mock <IUserService>();
userService.Setup(u => u.ResetPasswordWithToken("user", "token", "newpwd")).Returns(false);
var controller = CreateController(userSvc: userService);
var model = new PasswordResetViewModel
{
ConfirmPassword = "******",
NewPassword = "******"
};
controller.ResetPassword("user", "token", model);
Assert.Equal("The Password Reset Token is not valid or expired.", controller.ModelState[""].Errors[0].ErrorMessage);
userService.Verify(u => u.ResetPasswordWithToken("user", "token", "newpwd"));
}
public void ShowsErrorIfTokenExpired()
{
GetMock <AuthenticationService>()
.Setup(u => u.ResetPasswordWithToken("user", "token", "newpwd"))
.Returns(false);
var controller = GetController <UsersController>();
var model = new PasswordResetViewModel
{
ConfirmPassword = "******",
NewPassword = "******"
};
controller.ResetPassword("user", "token", model);
Assert.Equal("The Password Reset Token is not valid or expired.", controller.ModelState[""].Errors[0].ErrorMessage);
GetMock <AuthenticationService>()
.Verify(u => u.ResetPasswordWithToken("user", "token", "newpwd"));
}
public async Task ShowsErrorIfTokenExpired(bool forgot)
{
GetMock <AuthenticationService>()
.Setup(u => u.ResetPasswordWithToken("user", "token", "newpwd"))
.CompletesWithNull();
var controller = GetController <UsersController>();
var model = new PasswordResetViewModel
{
ConfirmPassword = "******",
NewPassword = "******"
};
await controller.ResetPassword("user", "token", model, forgot);
Assert.Equal("The Password Reset Token is not valid or expired.", controller.ModelState[""].Errors[0].ErrorMessage);
GetMock <AuthenticationService>()
.Verify(u => u.ResetPasswordWithToken("user", "token", "newpwd"));
}
public void ResetsPasswordForValidToken()
{
GetMock <AuthenticationService>()
.Setup(u => u.ResetPasswordWithToken("user", "token", "newpwd"))
.Returns(true);
var controller = GetController <UsersController>();
var model = new PasswordResetViewModel
{
ConfirmPassword = "******",
NewPassword = "******"
};
var result = controller.ResetPassword("user", "token", model) as RedirectToRouteResult;
Assert.NotNull(result);
GetMock <AuthenticationService>()
.Verify(u => u.ResetPasswordWithToken("user", "token", "newpwd"));
}
public async Task SendsPasswordAddedMessageWhenForgotFalse()
{
var cred = new Credential("foo", "bar")
{
User = new User("foobar")
};
GetMock <AuthenticationService>()
.Setup(u => u.ResetPasswordWithToken("user", "token", "newpwd"))
.CompletesWith(cred);
var controller = GetController <UsersController>();
var model = new PasswordResetViewModel
{
ConfirmPassword = "******",
NewPassword = "******"
};
await controller.ResetPassword("user", "token", model, forgot : false);
GetMock <IMessageService>()
.Verify(m => m.SendCredentialAddedNotice(cred.User, cred));
}
public async Task ResetsPasswordForValidToken(bool forgot)
{
var cred = new Credential("foo", "bar")
{
User = new User("foobar")
};
GetMock <AuthenticationService>()
.Setup(u => u.ResetPasswordWithToken("user", "token", "newpwd"))
.CompletesWith(cred);
var controller = GetController <UsersController>();
var model = new PasswordResetViewModel
{
ConfirmPassword = "******",
NewPassword = "******"
};
var result = await controller.ResetPassword("user", "token", model, forgot) as RedirectToRouteResult;
Assert.NotNull(result);
GetMock <AuthenticationService>()
.Verify(u => u.ResetPasswordWithToken("user", "token", "newpwd"));
}
public async Task SendsPasswordAddedMessageWhenForgotFalse()
{
var cred = new Credential("foo", "bar") { User = new User("foobar") };
GetMock<AuthenticationService>()
.Setup(u => u.ResetPasswordWithToken("user", "token", "newpwd"))
.CompletesWith(cred);
var controller = GetController<UsersController>();
var model = new PasswordResetViewModel
{
ConfirmPassword = "******",
NewPassword = "******"
};
await controller.ResetPassword("user", "token", model, forgot: false);
GetMock<IMessageService>()
.Verify(m => m.SendCredentialAddedNotice(cred.User, cred));
}
public async Task ResetsPasswordForValidToken(bool forgot)
{
var cred = new Credential("foo", "bar") { User = new User("foobar") };
GetMock<AuthenticationService>()
.Setup(u => u.ResetPasswordWithToken("user", "token", "newpwd"))
.CompletesWith(cred);
var controller = GetController<UsersController>();
var model = new PasswordResetViewModel
{
ConfirmPassword = "******",
NewPassword = "******"
};
var result = await controller.ResetPassword("user", "token", model, forgot) as RedirectToRouteResult;
Assert.NotNull(result);
GetMock<AuthenticationService>()
.Verify(u => u.ResetPasswordWithToken("user", "token", "newpwd"));
}
public async Task ShowsErrorIfTokenExpired(bool forgot)
{
GetMock<AuthenticationService>()
.Setup(u => u.ResetPasswordWithToken("user", "token", "newpwd"))
.CompletesWithNull();
var controller = GetController<UsersController>();
var model = new PasswordResetViewModel
{
ConfirmPassword = "******",
NewPassword = "******"
};
await controller.ResetPassword("user", "token", model, forgot);
Assert.Equal("The Password Reset Token is not valid or expired.", controller.ModelState[""].Errors[0].ErrorMessage);
GetMock<AuthenticationService>()
.Verify(u => u.ResetPasswordWithToken("user", "token", "newpwd"));
}
public void ShowsErrorIfTokenExpired()
{
var userService = new Mock<IUserService>();
userService.Setup(u => u.ResetPasswordWithToken("user", "token", "newpwd")).Returns(false);
var controller = CreateController(userSvc: userService);
var model = new PasswordResetViewModel
{
ConfirmPassword = "******",
NewPassword = "******"
};
var result = controller.ResetPassword("user", "token", model) as ViewResult;
Assert.Equal("The Password Reset Token is not valid or expired.", controller.ModelState[""].Errors[0].ErrorMessage);
userService.Verify(u => u.ResetPasswordWithToken("user", "token", "newpwd"));
}
public virtual async Task <ActionResult> ResetPassword(string username, string token, PasswordResetViewModel model, bool forgot)
{
// We don't want Login to have us as a return URL
// By having this value present in the dictionary BUT null, we don't put "returnUrl" on the Login link at all
ViewData[Constants.ReturnUrlViewDataKey] = null;
if (!ModelState.IsValid)
{
return(ResetPassword(forgot));
}
ViewBag.ForgotPassword = forgot;
Credential credential = null;
try
{
credential = await AuthenticationService.ResetPasswordWithToken(username, token, model.NewPassword);
}
catch (InvalidOperationException ex)
{
ModelState.AddModelError(string.Empty, ex.Message);
return(View(model));
}
ViewBag.ResetTokenValid = credential != null;
if (!ViewBag.ResetTokenValid)
{
ModelState.AddModelError(string.Empty, Strings.InvalidOrExpiredPasswordResetToken);
return(View(model));
}
if (credential != null && !forgot)
{
// Setting a password, so notify the user
MessageService.SendCredentialAddedNotice(credential.User, AuthenticationService.DescribeCredential(credential));
}
return(RedirectToAction("PasswordChanged"));
}
public virtual async Task <ActionResult> ResetPassword(string username, string token, PasswordResetViewModel model, bool forgot)
{
// We don't want Login to have us as a return URL
// By having this value present in the dictionary BUT null, we don't put "returnUrl" on the Login link at all
ViewData[Constants.ReturnUrlViewDataKey] = null;
var cred = await AuthService.ResetPasswordWithToken(username, token, model.NewPassword);
ViewBag.ResetTokenValid = cred != null;
ViewBag.ForgotPassword = forgot;
if (!ViewBag.ResetTokenValid)
{
ModelState.AddModelError("", "The Password Reset Token is not valid or expired.");
return(View(model));
}
if (cred != null && !forgot)
{
// Setting a password, so notify the user
MessageService.SendCredentialAddedNotice(cred.User, cred);
}
return(RedirectToAction(
actionName: "PasswordChanged",
controllerName: "Users"));
}
public void ShowsErrorIfTokenExpired()
{
var controller = new TestableUsersController();
controller.MockUserService
.Setup(u => u.ResetPasswordWithToken("user", "token", "newpwd"))
.Returns(false);
var model = new PasswordResetViewModel
{
ConfirmPassword = "******",
NewPassword = "******"
};
controller.ResetPassword("user", "token", model);
Assert.Equal("The Password Reset Token is not valid or expired.", controller.ModelState[""].Errors[0].ErrorMessage);
controller.MockUserService
.Verify(u => u.ResetPasswordWithToken("user", "token", "newpwd"));
}
public void ResetsPasswordForValidToken()
{
GetMock<AuthenticationService>()
.Setup(u => u.ResetPasswordWithToken("user", "token", "newpwd"))
.Returns(true);
var controller = GetController<UsersController>();
var model = new PasswordResetViewModel
{
ConfirmPassword = "******",
NewPassword = "******"
};
var result = controller.ResetPassword("user", "token", model) as RedirectToRouteResult;
Assert.NotNull(result);
GetMock<AuthenticationService>()
.Verify(u => u.ResetPasswordWithToken("user", "token", "newpwd"));
}
public virtual async Task<ActionResult> ResetPassword(string username, string token, PasswordResetViewModel model, bool forgot)
{
// We don't want Login to have us as a return URL
// By having this value present in the dictionary BUT null, we don't put "returnUrl" on the Login link at all
ViewData[Constants.ReturnUrlViewDataKey] = null;
if (!ModelState.IsValid)
{
return ResetPassword(forgot);
}
ViewBag.ForgotPassword = forgot;
Credential credential = null;
try
{
credential = await _authService.ResetPasswordWithToken(username, token, model.NewPassword);
}
catch (InvalidOperationException ex)
{
ModelState.AddModelError("", ex.Message);
return View(model);
}
ViewBag.ResetTokenValid = credential != null;
if (!ViewBag.ResetTokenValid)
{
ModelState.AddModelError("", Strings.InvalidOrExpiredPasswordResetToken);
return View(model);
}
if (credential != null && !forgot)
{
// Setting a password, so notify the user
_messageService.SendCredentialAddedNotice(credential.User, credential);
}
return RedirectToAction(
actionName: "PasswordChanged",
controllerName: "Users");
}
public virtual async Task<ActionResult> ResetPassword(string username, string token, PasswordResetViewModel model, bool forgot)
{
// We don't want Login to have us as a return URL
// By having this value present in the dictionary BUT null, we don't put "returnUrl" on the Login link at all
ViewData[Constants.ReturnUrlViewDataKey] = null;
var cred = await AuthService.ResetPasswordWithToken(username, token, model.NewPassword);
ViewBag.ResetTokenValid = cred != null;
ViewBag.ForgotPassword = forgot;
if (!ViewBag.ResetTokenValid)
{
ModelState.AddModelError("", "The Password Reset Token is not valid or expired.");
return View(model);
}
if (cred != null && !forgot)
{
// Setting a password, so notify the user
MessageService.SendCredentialAddedNotice(cred.User, cred);
}
return RedirectToAction(
actionName: "PasswordChanged",
controllerName: "Users");
}
public virtual ActionResult ResetPassword(string username, string token, PasswordResetViewModel model)
{
// We don't want Login to have us as a return URL
// By having this value present in the dictionary BUT null, we don't put "returnUrl" on the Login link at all
ViewData[Constants.ReturnUrlViewDataKey] = null;
ViewBag.ResetTokenValid = UserService.ResetPasswordWithToken(username, token, model.NewPassword);
if (!ViewBag.ResetTokenValid)
{
ModelState.AddModelError("", "The Password Reset Token is not valid or expired.");
return View(model);
}
return RedirectToAction(MVC.Users.PasswordChanged());
}
public virtual ActionResult ResetPassword(string username, string token, PasswordResetViewModel model)
{
ViewBag.ResetTokenValid = _userService.ResetPasswordWithToken(username, token, model.NewPassword);
if (!ViewBag.ResetTokenValid)
{
ModelState.AddModelError("", "The Password Reset Token is not valid or expired.");
return View(model);
}
return RedirectToAction(MVC.Users.PasswordChanged());
}
public void ResetsPasswordForValidToken()
{
var userService = new Mock<IUserService>();
userService.Setup(u => u.ResetPasswordWithToken("user", "token", "newpwd")).Returns(true);
var controller = CreateController(userSvc: userService);
var model = new PasswordResetViewModel
{
ConfirmPassword = "******",
NewPassword = "******"
};
var result = controller.ResetPassword("user", "token", model) as RedirectToRouteResult;
Assert.NotNull(result);
userService.Verify(u => u.ResetPasswordWithToken("user", "token", "newpwd"));
}
