public void RegisterShouldReturnBadRequestIfCreatingUserFails()
{
//Arrange
var model = new RegisterModelBuilder().WithValidStudentEmail().Build();
var errorCode = Guid.NewGuid().ToString();
var identityResult = IdentityResult.Failed(new IdentityError
{
Code = errorCode,
Description = Guid.NewGuid().ToString()
});
_userManagerMock.Setup(manager => manager.CreateAsync(It.IsAny <User>(), It.IsAny <string>()))
.ReturnsAsync(identityResult);
//Act
var result = _controller.Register(model).Result as BadRequestObjectResult;
//Assert
Assert.That(result, Is.Not.Null);
var serializableError = result.Value as SerializableError;
Assert.That(serializableError, Is.Not.Null);
Assert.That(serializableError.Keys, Has.One.EqualTo(errorCode));
_userManagerMock.Verify(
manager => manager.CreateAsync(
It.Is <User>(user => user.Email == model.Email && user.UserName == model.Email), model.Password),
Times.Once);
_mailSenderMock.Verify(sender => sender.SendConfirmUserEmailMessageAsync(It.IsAny <User>(), It.IsAny <string>()), Times.Never);
}
public void RegisterShouldCreateUserAndSendConfirmationMail()
{
//Arrange
var model = new RegisterModelBuilder().WithValidStudentEmail().Build();
var confirmationToken = Guid.NewGuid().ToString();
_userManagerMock.Setup(manager => manager.GenerateEmailConfirmationTokenAsync(It.IsAny <User>()))
.ReturnsAsync(confirmationToken);
var identityResult = IdentityResult.Success;
_userManagerMock.Setup(manager => manager.CreateAsync(It.IsAny <User>(), It.IsAny <string>()))
.ReturnsAsync(identityResult);
//Act
var result = _controller.Register(model).Result as OkResult;
//Assert
Assert.That(result, Is.Not.Null);
_userManagerMock.Verify(
manager => manager.CreateAsync(
It.Is <User>(user => user.Email == model.Email && user.UserName == model.Email), model.Password),
Times.Once);
_userManagerMock.Verify(
manager => manager.GenerateEmailConfirmationTokenAsync(It.Is <User>(user => user.Email == model.Email)),
Times.Once);
_mailSenderMock.Verify(sender => sender.SendConfirmUserEmailMessageAsync(It.Is <User>(user => user.Email == model.Email), confirmationToken), Times.Once);
}
public virtual ActionResult Register()
{
var builder = new RegisterModelBuilder();
var model = builder.Build();
return(PartialView(model));
}
public void ShouldListUsers()
{
var ruimin = new RegisterModelBuilder()
.WithEmail("*****@*****.**")
.WithRole(Roles.Author)
.Build();
var akani = new RegisterModelBuilder()
.WithEmail("*****@*****.**")
.WithRole(Roles.Admin)
.Build();
UsingSession(session =>
{
var accountController = new AccountController(session)
{
EmailService = GetEmailMock().Object
};
accountController.Create(ruimin);
accountController.Create(akani);
});
UsingSession(session =>
{
var accountController = new AccountController(session);
var viewResult = accountController.List();
var actualUsers = ((List <User>)(viewResult.Model));
Assert.AreEqual(2, actualUsers.Count);
Assert.IsTrue(UserEqual(akani, actualUsers.First()));
Assert.IsTrue(UserEqual(ruimin, actualUsers.Last()));
});
}
public void ShouldNotBeAbleToCreateUserWithAnExistingEmail()
{
var model = new RegisterModelBuilder()
.WithEmail("*****@*****.**")
.WithRole(Roles.Admin)
.Build();
UsingSession(session =>
{
var controller = new AccountController(session)
{
EmailService = GetEmailMock().Object
};
controller.Create(model);
});
UsingSession(session =>
{
var controller = new AccountController(session)
{
EmailService = GetEmailMock().Object
};
var viewResult = (System.Web.Mvc.ViewResult)(controller.Create(model));
Assert.AreEqual("A user with this email already exists", controller.TempData["flashError"]);
Assert.AreEqual(string.Empty, viewResult.MasterName);
Assert.AreEqual("Add a User", viewResult.ViewBag.Title);
});
}
public void ShouldCreateNewUser()
{
var model = new RegisterModelBuilder()
.WithEmail("*****@*****.**")
.WithRole(Roles.Admin)
.Build();
UsingSession(session =>
{
var controller = new AccountController(session)
{
EmailService = GetEmailMock().Object
};
var actionResult = (System.Web.Mvc.RedirectToRouteResult)(controller.Create(model));
Assert.AreEqual("Account", actionResult.RouteValues["controller"]);
Assert.AreEqual("List", actionResult.RouteValues["action"]);
});
UsingSession(session =>
{
var users = session.Query <User>().Customize(a => a.WaitForNonStaleResultsAsOfLastWrite()).ToList();
Assert.AreEqual(1, users.Count());
var user = users.First();
Assert.AreEqual(model.Email, user.Username);
Assert.AreEqual(model.Role, user.Roles.First());
});
}
public void RegisterShouldValidateCaptcha()
{
//Arrange
var model = new RegisterModelBuilder().WithValidStudentEmail().Build();
//Act
var result = _controller.Register(model).Result;
//Assert
Assert.That(result, Is.Not.Null);
_captchaValidatorMock.Verify(validator => validator.Validate(model.CaptchaToken, _controller.HttpContext.Connection.RemoteIpAddress));
}
public void ShouldConfirmNewUserWithTokenAndNewPassword()
{
var model = new RegisterModelBuilder()
.Build();
var mock = GetEmailMock();
string secureToken = null;
mock.Setup(e => e.SendConfirmation(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <int>()))
.Callback <string, string, string, int>((from, to, token, userId) =>
{
secureToken = token;
});
string oldPassword = "";
UsingSession(session =>
{
var controller = new AccountController(session)
{
EmailService = mock.Object
};
controller.Create(model);
oldPassword = session.Query <User>().First(u => u.Username == model.Email).Password;
});
UsingSession(session =>
{
var user = session.Query <User>().First();
var controller = new AccountController(session)
{
EmailService = mock.Object
};
var localPasswordModel = new LocalPasswordModelBuilder()
.WithSecurityToken(secureToken)
.WithUserId(user.Id)
.Build();
var mockAccountService = new Mock <IAccountService>();
mockAccountService.Setup(s => s.Login(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>())).Returns(true);
controller.AccountService = mockAccountService.Object;
var actionResult = (System.Web.Mvc.RedirectToRouteResult)(controller.RegisterConfirmation(localPasswordModel));
Assert.AreEqual("Home", actionResult.RouteValues["controller"]);
Assert.AreEqual("Index", actionResult.RouteValues["action"]);
});
UsingSession(session =>
{
Assert.IsTrue(session.Query <User>().First(u => u.Username == model.Email).IsApproved);
Assert.AreNotEqual(oldPassword,
session.Query <User>().First(u => u.Username == model.Email).Password);
});
}
public void RegisterShouldReturnBadRequestForNonPxlEmailAddress()
{
//Arrange
var model = new RegisterModelBuilder().WithEmail("*****@*****.**").Build();
//Act
var result = _controller.Register(model).Result as BadRequestObjectResult;
//Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Value, Does.Contain("PXL").IgnoreCase);
_userManagerMock.Verify(manager => manager.CreateAsync(It.IsAny <User>(), It.IsAny <string>()), Times.Never);
_mailSenderMock.Verify(sender => sender.SendConfirmUserEmailMessageAsync(It.IsAny <User>(), It.IsAny <string>()), Times.Never);
}
public void RegisterShouldAssignLectorRoleForPxlEmailAddress()
{
//Arrange
var model = new RegisterModelBuilder().WithValidLectorEmail().Build();
var identityResult = IdentityResult.Success;
_userManagerMock.Setup(manager => manager.CreateAsync(It.IsAny <User>(), It.IsAny <string>()))
.ReturnsAsync(identityResult);
//Act
var result = _controller.Register(model).Result as OkResult;
//Assert
Assert.That(result, Is.Not.Null);
_userManagerMock.Verify(manager => manager.AddToRoleAsync(It.Is <User>(user => user.Email == model.Email), Role.Constants.Lector), Times.Once);
}
public void RegisterShouldReturnBadRequestIfCaptchaIsInvalid()
{
//Arrange
var model = new RegisterModelBuilder().WithValidStudentEmail().Build();
var expectedCaptchaResult = new CaptchaVerificationResult {
Success = false
};
_captchaValidatorMock.Setup(validator => validator.Validate(It.IsAny <string>(), It.IsAny <IPAddress>()))
.ReturnsAsync(expectedCaptchaResult);
//Act
var result = _controller.Register(model).Result as BadRequestObjectResult;
//Assert
Assert.That(result, Is.Not.Null);
_captchaValidatorMock.Verify(validator => validator.Validate(model.CaptchaToken, _controller.HttpContext.Connection.RemoteIpAddress));
_userManagerMock.Verify(manager => manager.CreateAsync(It.IsAny <User>(), It.IsAny <string>()), Times.Never);
_mailSenderMock.Verify(sender => sender.SendConfirmUserEmailMessageAsync(It.IsAny <User>(), It.IsAny <string>()), Times.Never);
}
public void RegisterShouldReturnBadRequestIfModelIsInvalid()
{
//Arrange
var model = new RegisterModelBuilder().Build();
var errorKey = "someValidationError";
_controller.ModelState.AddModelError(errorKey, Guid.NewGuid().ToString());
//Act
var result = _controller.Register(model).Result as BadRequestObjectResult;
//Assert
Assert.That(result, Is.Not.Null);
var serializableError = result.Value as SerializableError;
Assert.That(serializableError, Is.Not.Null);
Assert.That(serializableError.Keys, Has.One.EqualTo(errorKey));
_userManagerMock.Verify(manager => manager.CreateAsync(It.IsAny <User>(), It.IsAny <string>()), Times.Never);
_mailSenderMock.Verify(sender => sender.SendConfirmUserEmailMessageAsync(It.IsAny <User>(), It.IsAny <string>()), Times.Never);
}
public void ShouldCreateNewUserNotApproved()
{
var model = new RegisterModelBuilder()
.Build();
var mock = GetEmailMock();
UsingSession(session =>
{
var controller = new AccountController(session)
{
EmailService = mock.Object
};
controller.Create(model);
});
UsingSession(session =>
{
var user = session.Query <User>().Customize(a => a.WaitForNonStaleResultsAsOfLastWrite()).First();
Assert.IsFalse(user.IsApproved);
mock.Verify(e => e.SendConfirmation("*****@*****.**", model.Email, user.ConfirmationToken, user.Id), Times.Once());
});
}
