public void RegisterUser(RegistrationInfo registrationInfo)
{
Assert.ArgumentNotNull(registrationInfo, nameof(registrationInfo));
Assert.ArgumentNotNullOrEmpty(registrationInfo.Email, "registrationInfo.Email");
Assert.ArgumentNotNullOrEmpty(registrationInfo.Password, "registrationInfo.Password");
Assert.ArgumentNotNullOrEmpty(registrationInfo.ConfirmPassword, "registrationInfo.ConfirmPassword");
var fullName = Context.Domain.GetFullName(registrationInfo.Email);
Assert.IsNotNullOrEmpty(fullName, "Can't retrieve full userName");
var user = User.Create(fullName, registrationInfo.Password);
user.Profile.Email = registrationInfo.Email;
user.Profile.Save();
AuthenticationManager.Login(user);
}
public void RegisterShouldReturnModelIfItsNotValid(RegistrationInfo registrationInfo, [Frozen] IAccountRepository repo, [NoAutoProperties] AccountsController controller)
{
controller.ModelState.AddModelError("Error", "Error");
var result = controller.Register(registrationInfo);
result.Should().BeOfType<ViewResult>().Which.Model.Should().Be(registrationInfo);
}
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 RegisterShouldRedirectToHomePageIfUserLoggedIn(Database db, [Content] DbItem item, RegistrationInfo registrationInfo, [Frozen] IAccountRepository repo, [NoAutoProperties] AccountsController controller)
{
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))
{
using (new UserSwitcher(@"extranet\John", true))
{
var result = controller.Register(registrationInfo);
result.Should().BeOfType<RedirectResult>().Which.Url.Should().Be("/");
}
}
}
public void RegisterShouldCallRegisterUserAndRedirectToHomePage(Database db, [Content] DbItem item, RegistrationInfo registrationInfo, [Frozen] IAccountRepository repo, [Frozen] INotificationService notifyService)
{
repo.Exists(Arg.Any<string>()).Returns(false);
var controller = new AccountsController(repo, notifyService);
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<RedirectResult>().Which.Url.Should().Be("/");
repo.Received(1).RegisterUser(registrationInfo);
}
}
public void RegisterShouldReturnModelWithErrorIfSameUserExists(Database db, [Content] DbItem item, RegistrationInfo registrationInfo, [Frozen] IAccountRepository repo, [NoAutoProperties] AccountsController controller)
{
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))
using (new UserSwitcher($@"extranet\{registrationInfo.Email}", false))
{
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 == Errors.UserAlreadyExists);
}
}
public void RegisterShouldReturnModelIfItsNotValid(Database db, [Content] DbItem item, RegistrationInfo registrationInfo, [Frozen] IAccountRepository repo, [NoAutoProperties] AccountsController controller)
{
var fakeSite = new FakeSiteContext(new StringDictionary
{
{
"displayMode", "normal"
}
}) as SiteContext;
using (new SiteContextSwitcher(fakeSite))
{
controller.ModelState.AddModelError("Error", "Error");
var result = controller.Register(registrationInfo);
result.Should().BeOfType<ViewResult>().Which.Model.Should().Be(registrationInfo);
}
}
public void RegisterShouldCallRegisterUserAndRedirectToHomePage(Database db, [Content] DbItem item, Item profileItem, RegistrationInfo registrationInfo, [Frozen] IAccountRepository repo, [Frozen] INotificationService notifyService, [Frozen] IAccountsSettingsService accountsSettingsService, [Frozen] IUserProfileService userProfileService)
{
accountsSettingsService.GetPageLinkOrDefault(Arg.Any<Item>(), Arg.Any<ID>(), Arg.Any<Item>()).Returns("/redirect");
repo.Exists(Arg.Any<string>()).Returns(false);
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<RedirectResult>().Which.Url.Should().Be("/redirect");
repo.Received(1).RegisterUser(registrationInfo.Email, registrationInfo.Password, Arg.Any<string>());
}
}
public void RegisterShouldCreateUserWithEmailAndPassword(FakeMembershipUser user, MembershipProvider membershipProvider, RegistrationInfo registrationInfo, string userProfile, AccountRepository repository)
{
user.ProviderName.Returns("fake");
user.UserName.Returns("name");
MembershipCreateStatus status;
membershipProvider.CreateUser(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(), Arg.Any<bool>(), Arg.Any<object>(), out status).Returns(user);
membershipProvider.GetUser(Arg.Any<string>(), Arg.Any<bool>()).Returns(user);
using (new Switcher<Domain, Domain>(new Domain("somedomain")))
{
using (new MembershipSwitcher(membershipProvider))
{
repository.RegisterUser(registrationInfo.Email,registrationInfo.Password, userProfile);
membershipProvider.Received(1).CreateUser($@"somedomain\{registrationInfo.Email}", registrationInfo.Password, Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(), Arg.Any<bool>(), Arg.Any<object>(), out status);
}
}
}
public void RegisterShouldTrackLoginAndRegisterEvents(FakeMembershipUser user, [Substitute]MembershipProvider membershipProvider, [Substitute]AuthenticationProvider authenticationProvider, RegistrationInfo registrationInfo, [Frozen]IAccountTrackerService accountTrackerService, AccountRepository repository, string profileId)
{
user.UserName.Returns("name");
MembershipCreateStatus status;
membershipProvider.CreateUser(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(), Arg.Any<bool>(), Arg.Any<object>(), out status).Returns(user);
membershipProvider.GetUser(Arg.Any<string>(), Arg.Any<bool>()).Returns(user);
using (new Switcher<Domain, Domain>(new Domain("somedomain")))
{
using (new MembershipSwitcher(membershipProvider))
{
using (new AuthenticationSwitcher(authenticationProvider))
{
repository.RegisterUser(registrationInfo.Email, registrationInfo.Password, profileId);
accountTrackerService.Received(1).TrackLogin();
accountTrackerService.Received(1).TrackRegister();
}
}
}
}
public void RegisterShouldCreateLoginUser(FakeMembershipUser user, [Substitute] MembershipProvider membershipProvider, [Substitute] AuthenticationProvider authenticationProvider, RegistrationInfo registrationInfo, AccountRepository repository, string profileId)
{
user.ProviderName.Returns("fake");
user.UserName.Returns("name");
MembershipCreateStatus status;
membershipProvider.CreateUser(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(), Arg.Any<bool>(), Arg.Any<object>(), out status).Returns(user);
membershipProvider.GetUser(Arg.Any<string>(), Arg.Any<bool>()).Returns(user);
using (new Switcher<Domain, Domain>(new Domain("somedomain")))
{
using (new MembershipSwitcher(membershipProvider))
{
using (new AuthenticationSwitcher(authenticationProvider))
{
repository.RegisterUser(registrationInfo.Email, registrationInfo.Password, profileId);
authenticationProvider.Received(1).Login(Arg.Is<User>(u => u.Name == $@"somedomain\{registrationInfo.Email}"));
}
}
}
}
public void LogoutShouldLogoutUser(User user, MembershipProvider membershipProvider, RegistrationInfo registrationInfo, AccountRepository repository)
{
var authenticationProvider = Substitute.For<AuthenticationProvider>();
authenticationProvider.GetActiveUser().Returns(user);
using (new AuthenticationSwitcher(authenticationProvider))
{
repository.Logout();
authenticationProvider.Received(1).Logout();
}
}
public void RegisterShouldThrowArgumentException(RegistrationInfo registrationInfo)
{
var repository = new AccountRepository();
repository.Invoking(x => x.RegisterUser(registrationInfo)).ShouldThrow<ArgumentNullException>();
}
public void RegisterShouldReturnModelWithErrorIfSameUserExists(RegistrationInfo registrationInfo, [Frozen] IAccountRepository repo, [NoAutoProperties] AccountsController controller)
{
using (new UserSwitcher($@"extranet\{registrationInfo.Email}", false))
{
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 == Errors.UserAlreadyExists);
}
}
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(RegistrationInfo registrationInfo)
{
var redirect = this.RedirectAuthenticatedUser();
if (redirect != null)
{
return redirect;
}
if (!this.ModelState.IsValid)
{
return this.View(registrationInfo);
}
if (this.accountRepository.Exists(registrationInfo.Email))
{
this.ModelState.AddModelError(nameof(registrationInfo.Email), Errors.UserAlreadyExists);
return this.View(registrationInfo);
}
try
{
this.accountRepository.RegisterUser(registrationInfo);
var link = this.accountsSettingsService.GetPageLinkOrDefault(Context.Item, Templates.AccountsSettings.Fields.AfterLoginPage, Context.Site.GetRootItem());
return this.Redirect(link);
}
catch (MembershipCreateUserException ex)
{
Log.Error($"Can't create user with {registrationInfo.Email}", ex, this);
this.ModelState.AddModelError(nameof(registrationInfo.Email), ex.Message);
return this.View(registrationInfo);
}
}
public ActionResult Register(RegistrationInfo registrationInfo)
{
if (!Context.IsLoggedIn)
{
if (!this.ModelState.IsValid)
{
return this.View(registrationInfo);
}
if (this.accountRepository.Exists(registrationInfo.Email))
{
this.ModelState.AddModelError(nameof(registrationInfo.Email), Errors.UserAlreadyExists);
return this.View(registrationInfo);
}
try
{
this.accountRepository.RegisterUser(registrationInfo);
}
catch (MembershipCreateUserException ex)
{
Log.Error($"Can't create user with {registrationInfo.Email}", ex, this);
this.ModelState.AddModelError(nameof(registrationInfo.Email), ex.Message);
return this.View(registrationInfo);
}
}
return this.Redirect(Context.Site.GetRoot().Url());
}
