public SecurityCreateUserException(MembershipCreateUserException exception)
: base(errors.ContainsKey(exception.StatusCode)
? errors[exception.StatusCode]
: UnknownCreateUserError,
exception)
{
}
public void WhenITryToCreateANewUserWithTheSameUserName()
{
try
{
membershipUser = Membership.CreateUser(knownUserName, "password");
}
catch (MembershipCreateUserException e)
{
ex = e;
}
}
public void WhenITryToCreateANewUserWithTheSameEmail()
{
var newUserName = Guid.NewGuid().ToString();
try
{
membershipUser = Membership.CreateUser(newUserName, password, email);
}
catch (MembershipCreateUserException e)
{
ex = e;
}
}
public Guid AddAccount(string email, string password, bool test)
{
string username = System.Web.Security.Membership.GetUserNameByEmail(email);
// cannot add user if email is already taken...
if (!string.IsNullOrEmpty(username))
{
try
{
Roles.AddUserToRole(username, "Member");
}
catch (Exception)
{
}
return (Guid)System.Web.Security.Membership.GetUser(username).ProviderUserKey;
}
MembershipUser user = null;
MembershipCreateStatus status;
user = System.Web.Security.Membership.CreateUser(email, password, email, "none", "none", true, out status);
if (status == MembershipCreateStatus.Success)
{
Roles.AddUserToRole(user.UserName, "Member");
return (Guid)user.ProviderUserKey;
}
else
{
MembershipCreateUserException ex = new MembershipCreateUserException(MembershipHelper.GetErrorMessage(status));
throw new FaultException<MembershipCreateUserException>(ex);
}
}
public void CreateUser_displays_username_validation_error_when_duplicate_username_supplied()
{
// arrange
var exception = new MembershipCreateUserException(MembershipCreateStatus.DuplicateUserName);
_userService.Setup(x => x.Create(null, null, null, null, null)).Throws(exception);
var viewModel = new CreateUserViewModel();
// act
var returnedResult = _controller.CreateUser(viewModel);
// assert
var result = Assert.IsType<ViewResult>(returnedResult);
Assert.Equal("", result.ViewName);
Assert.Equal(viewModel, result.Model);
var modelState = result.ViewData.ModelState;
Assert.True(modelState.ContainsKey(string.Empty));
Assert.Equal(exception.Message, modelState[string.Empty].Errors.First().ErrorMessage);
}
public void RegisterShouldReturnErrorIfRegistrationThrowsMembershipException(RegistrationInfo registrationInfo, MembershipCreateUserException exception, [Frozen] IAccountRepository repo, [Frozen] INotificationService notifyService)
{
repo.When(x => x.RegisterUser(Arg.Any<RegistrationInfo>())).Do(x => { throw new MembershipCreateUserException(); });
var controller = new AccountsController(repo, notifyService);
var result = controller.Register(registrationInfo);
result.Should().BeOfType<ViewResult>().Which.Model.Should().Be(registrationInfo);
result.Should().BeOfType<ViewResult>().Which.ViewData.ModelState.Should().ContainKey(nameof(registrationInfo.Email))
.WhichValue.Errors.Should().Contain(x => x.ErrorMessage == exception.Message);
}
public void RegisterShouldReturnErrorIfRegistrationThrowsMembershipException(Database db, [Content] DbItem item, Item profileItem, RegistrationInfo registrationInfo, MembershipCreateUserException exception, [Frozen] IAccountRepository repo, [Frozen] INotificationService notifyService, [Frozen] IAccountsSettingsService accountsSettingsService, [Frozen] IUserProfileService userProfileService)
{
repo.When(x => x.RegisterUser(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>())).Do(x => { throw new MembershipCreateUserException(); });
userProfileService.GetUserDefaultProfileId().Returns(profileItem.ID.ToString());
var controller = new AccountsController(repo, notifyService, accountsSettingsService, userProfileService);
var fakeSite = new FakeSiteContext(new StringDictionary
{
{
"rootPath", "/sitecore/content"
},
{
"startItem", item.Name
}
}) as SiteContext;
fakeSite.Database = db;
Language.Current = Language.Invariant;
using (new SiteContextSwitcher(fakeSite))
{
var result = controller.Register(registrationInfo);
result.Should().BeOfType<ViewResult>().Which.Model.Should().Be(registrationInfo);
result.Should().BeOfType<ViewResult>().Which.ViewData.ModelState.Should().ContainKey(nameof(registrationInfo.Email))
.WhichValue.Errors.Should().Contain(x => x.ErrorMessage == exception.Message);
}
}
public ActionResult Register(RegisterModel model)
{
if (ModelState.IsValid)
{
// Attempt to register the user
try
{
if (db.Authors.Find(model.UserName) != null || db.Students.Find(model.UserName) != null)
{
MembershipCreateUserException e = new MembershipCreateUserException(MembershipCreateStatus.DuplicateUserName);
throw e;
}
if (model.AccountType == AccountType.Author)
{
try
{
Author author = new Author();
author.AuthorUserName = model.UserName;
author.Password = model.Password;
author.FirstName = model.FirstName;
author.LastName = model.LastName;
author.PersonalEmail = model.PersonalEmail;
author.Courses = new List<Course>();
db.Authors.Add(author);
db.SaveChanges();
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
Trace.TraceInformation("Property: {0} Error: {1}", validationError.PropertyName, validationError.ErrorMessage);
}
}
}
LoginUser(model.UserName, false);
return RedirectToAction("Index", "Author"); // redirect to Author home page
}
else
{
Author student = new Author();
student.AuthorUserName = model.UserName;
student.Password = model.Password;
student.FirstName = model.FirstName;
student.LastName = model.LastName;
student.PersonalEmail = model.PersonalEmail;
db.Authors.Add(student);
db.SaveChanges();
LoginUser(model.UserName, false);
return RedirectToAction("Index", "Home"); // redirect to student home page
}
}
catch (MembershipCreateUserException e)
{
ModelState.AddModelError("", ErrorCodeToString(e.StatusCode));
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
