public AccountsController(IAccountRepository accountRepository, INotificationService notificationService, IAccountsSettingsService accountsSettingsService, IUserProfileService userProfileService)
{
this.accountRepository = accountRepository;
this.notificationService = notificationService;
this.accountsSettingsService = accountsSettingsService;
this.userProfileService = userProfileService;
}
public void Logout_ShouldCallSitecoreLogout(Database db, [Content] DbItem item, IAccountRepository repo, INotificationService ns, IAccountsSettingsService acc)
{
var fakeSite = new FakeSiteContext(new StringDictionary
{
{"rootPath", "/sitecore/content"},
{"startItem", item.Name}
}) as SiteContext;
fakeSite.Database = db;
using (new SiteContextSwitcher(fakeSite))
{
var ctrl = new AccountsController(repo, ns, acc, null, null);
ctrl.Logout();
repo.Received(1).Logout();
}
}
public void Logout_ShouldRedirectUserToHomePage(Database db, [Content] DbItem item, IAccountRepository repo, INotificationService ns, IAccountsSettingsService acc)
{
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 ctrl = new AccountsController(repo, ns, acc, null, null);
var result = ctrl.Logout();
result.Should().BeOfType<RedirectResult>().Which.Url.Should().Be("/");
}
}
public void ForgotPasswordShoudCatchAndReturnViewWithError(PasswordResetInfo model, [Frozen] IAccountRepository repo, INotificationService notificationService, IAccountsSettingsService settingService)
{
var fakeSite = new FakeSiteContext(new StringDictionary
{
{
"displayMode", "normal"
}
}) as SiteContext;
using (new SiteContextSwitcher(fakeSite))
{
repo.RestorePassword(Arg.Any<string>()).ThrowsForAnyArgs(new Exception("Error"));
repo.Exists(Arg.Any<string>()).Returns(true);
var controller = new AccountsController(repo, notificationService, settingService);
var result = controller.ForgotPassword(model);
result.Should().BeOfType<ViewResult>().Which.Model.Should().Be(model);
result.Should().BeOfType<ViewResult>().Which.ViewData.ModelState.Should().ContainKey(nameof(model.Email))
.WhichValue.Errors.Should().Contain(x => x.ErrorMessage == "Error");
}
}
public void ForgotPasswordShouldReturnSuccessView([Frozen] IAccountRepository repo, INotificationService ns, PasswordResetInfo model, IAccountsSettingsService accountSetting, InfoMessage info)
{
var fakeSite = new FakeSiteContext(new StringDictionary
{
{
"displayMode", "normal"
}
}) as SiteContext;
using (new SiteContextSwitcher(fakeSite))
{
var controller = new AccountsController(repo, ns, accountSetting, null);
repo.RestorePassword(Arg.Any<string>()).Returns("new password");
repo.Exists(Arg.Any<string>()).Returns(true);
var result = controller.ForgotPassword(model);
result.Should().BeOfType<ViewResult>().Which.ViewName.Should().Be("InfoMessage");
}
}
public void TrackOutcome_ValidOutcome_ShouldRegisterOutcome([Frozen] ID outcomeDefinitionId, [Frozen] IAccountsSettingsService accountsSettingsService, [NoAutoProperties] AccountTrackerService trackerService, ITracker tracker, Contact contact, CurrentInteraction interaction)
{
tracker.IsActive.Returns(true);
tracker.Contact.Returns(contact);
tracker.Interaction.Returns(interaction);
tracker.Session.Returns(Substitute.For <Session>());
tracker.Session.CustomData.Returns(new Dictionary <string, object>());
using (new TrackerSwitcher(tracker))
{
trackerService.TrackOutcome(outcomeDefinitionId);
tracker.GetContactOutcomes().Should().Contain(o => o.DefinitionId == outcomeDefinitionId);
}
}
public NotificationService(IAccountsSettingsService siteSettings)
{
this.siteSettings = siteSettings;
}
public void OnActionExecuting_RedirectEqualsCurrent_ShouldRedirectToRootPage(Database db, [Content] DbItem item, string afterLoginLink, [Frozen] IAccountsSettingsService accountsSettingsService, [Substitute] ActionExecutingContext filterContext, [Greedy] AccountsRedirectAuthenticatedAttribute redirectAuthenticatedAttribute)
{
//Arrange
var siteContext = new FakeSiteContext(new StringDictionary
{
{
"rootPath", "/sitecore/content"
},
{
"startItem", item.Name
}
}) as SiteContext;
siteContext.Database = db;
accountsSettingsService.GetPageLinkOrDefault(Arg.Any <Item>(), Templates.AccountsSettings.Fields.AfterLoginPage, Arg.Any <Item>()).Returns(afterLoginLink);
filterContext.HttpContext.Request.RawUrl.Returns(afterLoginLink);
//Act
using (new SiteContextSwitcher(siteContext))
using (new Sitecore.Security.Accounts.UserSwitcher(@"extranet\John", true))
{
redirectAuthenticatedAttribute.OnActionExecuting(filterContext);
}
//Assert
filterContext.Result.Should().BeOfType <RedirectResult>().Which.Url.Should().NotBe(afterLoginLink);
}
public AccountTrackerService(IAccountsSettingsService accountsSettingsService)
{
this.accountsSettingsService = accountsSettingsService;
}
public FedAuthLoginButtonRepository(BaseCorePipelineManager pipelineManager, IAccountsSettingsService accountsSettingsService)
{
_pipelineManager = pipelineManager;
_accountsSettingsService = accountsSettingsService;
}
public void _Login_LoggedIn_ShouldRedirect(Database db, [Content] DbItem item, User user, [Frozen] IAccountRepository repo, LoginInfo info, INotificationService service, IAccountsSettingsService accountSetting, IUserProfileService userProfileService)
{
userProfileService.ValidateUser(Arg.Any <User>()).ReturnsForAnyArgs(true);
var controller = new AccountsController(repo, service, accountSetting, userProfileService, null);
repo.Login(string.Empty, string.Empty).ReturnsForAnyArgs(x => user);
var result = controller._Login(info);
result.Should().BeOfType <JsonResult>();
((result as JsonResult).Data as LoginResult).RedirectUrl.Should().BeEquivalentTo(info.ReturnUrl);
}
public void Login_ValidaData_ShouldRedirectToReturnUrl([Frozen] IAccountRepository repo, LoginInfo info, User user, INotificationService service, IAccountsSettingsService accountSetting, IUserProfileService userProfileService)
{
userProfileService.ValidateUser(Arg.Any<User>()).ReturnsForAnyArgs(true);
var controller = new AccountsController(repo, service, accountSetting, userProfileService, null);
repo.Login(string.Empty, string.Empty).ReturnsForAnyArgs(x => user);
var result = controller.Login(info);
result.Should().BeOfType<RedirectResult>().Which.Url.Should().Be(info.ReturnUrl);
}
public void Login_ReturnUrlNotSet_ShouldRedirectToRoot(Database db, [Content] DbItem item, User user, [Frozen] IAccountRepository repo, IUserProfileService userProfileService, LoginInfo info, INotificationService service, IAccountsSettingsService accountSetting)
{
accountSetting.GetPageLinkOrDefault(Arg.Any <Item>(), Arg.Any <ID>(), Arg.Any <Item>()).Returns("/");
userProfileService.ValidateUser(Arg.Any <User>()).ReturnsForAnyArgs(true);
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))
{
info.ReturnUrl = null;
var controller = new AccountsController(repo, service, accountSetting, userProfileService, null);
repo.Login(string.Empty, string.Empty).ReturnsForAnyArgs(x => user);
var result = controller.Login(info);
result.Should().BeOfType <RedirectResult>().Which.Url.Should().Be("/");
}
}
public void ForgotPassword_ValidData_ShouldReturnViewWithoutModel([Frozen] IAccountRepository repo, INotificationService service, IAccountsSettingsService accountsSettings, MailMessage mailMessage)
{
accountsSettings.GetForgotPasswordMailTemplate().ReturnsForAnyArgs(x => mailMessage);
var controller = new AccountsController(repo, service, accountsSettings, null, null);
var fakeSite = new FakeSiteContext(new StringDictionary
{
{ "displayMode", "normal" }
}) as SiteContext;
using (new SiteContextSwitcher(fakeSite))
{
var result = controller.ForgotPassword();
result.Should().BeOfType <ViewResult>().Which.Model.Should().BeNull();
}
}
public void Login_ValidaData_ShouldRedirectToReturnUrl([Frozen] IAccountRepository repo, LoginInfo info, User user, INotificationService service, IAccountsSettingsService accountSetting, IUserProfileService userProfileService)
{
userProfileService.ValidateUser(Arg.Any <User>()).ReturnsForAnyArgs(true);
var controller = new AccountsController(repo, service, accountSetting, userProfileService, null);
repo.Login(string.Empty, string.Empty).ReturnsForAnyArgs(x => user);
var result = controller.Login(info);
result.Should().BeOfType <RedirectResult>().Which.Url.Should().Be(info.ReturnUrl);
}
public void TrackRegister_Call_ShouldTrackRegistrationGoal(Db db, ID outcomeID, ITracker tracker, [Frozen] IAccountsSettingsService accountsSettingsService, AccountTrackerService accountTrackerService)
{
// Arrange
tracker.IsActive.Returns(true);
tracker.Contact.Returns(Substitute.For <Contact>());
tracker.Interaction.Returns(Substitute.For <CurrentInteraction>());
tracker.Session.Returns(Substitute.For <Session>());
tracker.Session.CustomData.Returns(new Dictionary <string, object>());
accountsSettingsService.GetRegistrationOutcome(Arg.Any <Item>()).Returns(outcomeID);
db.Add(new DbItem("Item", ConfigSettings.RegistrationGoalId));
db.Add(new DbItem("Item", ConfigSettings.LoginGoalId));
using (new TrackerSwitcher(tracker))
{
accountTrackerService.TrackRegistration();
tracker.CurrentPage.Received(1).Register(Arg.Is <PageEventItem>(x => x.ID == ConfigSettings.RegistrationGoalId));
tracker.GetContactOutcomes().Should().Contain(o => o.DefinitionId == outcomeID);
}
}
public void TrackOutcome_InactiveTracker_ShouldNotTrack([Frozen] ID outcomeDefinitionId, [Frozen] IAccountsSettingsService accountsSettingsService, [NoAutoProperties] AccountTrackerService trackerService, ITracker tracker)
{
// Arrange
tracker.IsActive.Returns(false);
tracker.Session.Returns(Substitute.For <Session>());
tracker.Session.CustomData.Returns(new Dictionary <string, object>());
using (new TrackerSwitcher(tracker))
{
// Act
trackerService.TrackOutcome(outcomeDefinitionId);
// Assert
tracker.GetContactOutcomes().Should().BeEmpty();
}
}
public void LoginShouldRedirectToReturnUrlIfLoggedIn([Frozen] IAccountRepository repo, LoginInfo info, INotificationService service, IAccountsSettingsService accountSetting)
{
var controller = new AccountsController(repo, service, accountSetting, null);
repo.Login(string.Empty, string.Empty).ReturnsForAnyArgs(x => true);
var result = controller.Login(info);
result.Should().BeOfType<RedirectResult>().Which.Url.Should().Be(info.ReturnUrl);
}
public void ForgotPassword_ValidData_ShouldReturnViewWithoutModel([Frozen] IAccountRepository repo, INotificationService service, IAccountsSettingsService accountsSettings, MailMessage mailMessage)
{
accountsSettings.GetForgotPasswordMailTemplate().ReturnsForAnyArgs(x => mailMessage);
var controller = new AccountsController(repo, service, accountsSettings, null, null);
var fakeSite = new FakeSiteContext(new StringDictionary
{
{"displayMode", "normal"}
}) as SiteContext;
using (new SiteContextSwitcher(fakeSite))
{
var result = controller.ForgotPassword();
result.Should().BeOfType<ViewResult>().Which.Model.Should().BeNull();
}
}
public void LoginShouldReturnViewModelIfModelStateNotValid([Frozen] IAccountRepository repo, LoginInfo info, INotificationService service, IAccountsSettingsService accountSetting)
{
var controller = new AccountsController(repo, service, accountSetting, null);
controller.ModelState.AddModelError("Error", "Error");
var result = controller.Login(info);
result.Should().BeOfType<ViewResult>();
}
public void SendPasswordShouldUseSourceAddressFromSettings(IAccountsSettingsService settings, MailMessage msg)
{
var sentMail = this.SentMail(settings, msg);
sentMail.FromAddress.Address.Should().BeEquivalentTo(msg.From.Address);
}
public void SendPasswordShouldSendOnlyOneEmail(IAccountsSettingsService settings, MailMessage msg)
{
this.SentMail(settings, msg);
this.SmtpServer.ReceivedEmailCount.Should().Be(1);
}
public void LoginShouldRedirectToReturnUrlIfLoggedIn([Frozen] IAccountRepository repo, LoginInfo info, INotificationService service, IAccountsSettingsService accountSetting)
{
var controller = new AccountsController(repo, service, accountSetting, null, null);
repo.Login(string.Empty, string.Empty).ReturnsForAnyArgs(x => true);
var result = controller.Login(info);
result.Should().BeOfType <RedirectResult>().Which.Url.Should().Be(info.ReturnUrl);
}
public void TrackRegister_Call_ShouldTrackRegistrationGoal(ID outcomeID, ITracker tracker, [Frozen] IAccountsSettingsService accountsSettingsService, [Frozen] ITrackerService trackerService, [Greedy] AccountTrackerService accountTrackerService)
{
// Arrange
accountsSettingsService.GetRegistrationOutcome(Arg.Any <Item>()).Returns(outcomeID.Guid);
//Act
accountTrackerService.TrackRegistration();
//Assert
trackerService.Received(1).TrackGoal(AccountTrackerService.RegistrationGoalId);
trackerService.Received(1).TrackOutcome(outcomeID.Guid);
}
public void LoginShouldReturnViewModelIfModelStateNotValid([Frozen] IAccountRepository repo, LoginInfo info, INotificationService service, IAccountsSettingsService accountSetting)
{
var controller = new AccountsController(repo, service, accountSetting, null, null);
controller.ModelState.AddModelError("Error", "Error");
var result = controller.Login(info);
result.Should().BeOfType <ViewResult>();
}
public AccountsController(IAccountRepository accountRepository, INotificationService notificationService, IAccountsSettingsService accountsSettingsService, IGetRedirectUrlService getRedirectUrlService, IUserProfileService userProfileService, IContactProfileService contactProfileService)
{
this.accountRepository = accountRepository;
this.notificationService = notificationService;
this.accountsSettingsService = accountsSettingsService;
this.getRedirectUrlService = getRedirectUrlService;
this.userProfileService = userProfileService;
this.contactProfileService = contactProfileService;
}
public void ForgotPasswordShouldReturnSuccessView([Frozen] IAccountRepository repo, INotificationService ns, PasswordResetInfo model, IAccountsSettingsService accountSetting, InfoMessage info)
{
var fakeSite = new FakeSiteContext(new StringDictionary
{
{
"displayMode", "normal"
}
}) as SiteContext;
using (new SiteContextSwitcher(fakeSite))
{
var controller = new AccountsController(repo, ns, accountSetting, null, null);
repo.RestorePassword(Arg.Any <string>()).Returns("new password");
repo.Exists(Arg.Any <string>()).Returns(true);
var result = controller.ForgotPassword(model);
result.Should().BeOfType <ViewResult>().Which.ViewName.Should().Be(ViewPath.InfoMessage);
}
}
public void _LoginShouldRedirectIfLoggedIn(Database db, [Content] DbItem item, [Frozen] IAccountRepository repo, LoginInfo info, INotificationService service, IAccountsSettingsService accountSetting)
{
var controller = new AccountsController(repo, service, accountSetting, null, null);
repo.Login(string.Empty, string.Empty).ReturnsForAnyArgs(x => true);
var result = controller._Login(info);
result.Should().BeOfType <JsonResult>();
((result as JsonResult).Data as LoginResult).RedirectUrl.Should().BeEquivalentTo(info.ReturnUrl);
}
public void TrackRegister_Call_ShouldTrackRegistrationGoal(Db db, ID outcomeID, ITracker tracker, [Frozen] IAccountsSettingsService accountsSettingsService, [Frozen] ITrackerService trackerService, [Greedy] AccountTrackerService accountTrackerService)
{
// Arrange
accountsSettingsService.GetRegistrationOutcome(Arg.Any <Item>()).Returns(outcomeID);
db.Add(new DbItem("Item", ConfigSettings.RegistrationGoalId));
db.Add(new DbItem("Item", ConfigSettings.LoginGoalId));
//Act
accountTrackerService.TrackRegistration();
//Assert
trackerService.Received().TrackPageEvent(ConfigSettings.RegistrationGoalId);
trackerService.Received().TrackOutcome(outcomeID);
}
public void LoginShouldAddModelStateErrorIfNotLoggedIn(Database db, [Content] DbItem item, [Frozen] IAccountRepository repo, LoginInfo info, INotificationService service, [Frozen] IAccountsSettingsService accountSetting)
{
accountSetting.GetPageLinkOrDefault(Arg.Any <Item>(), Arg.Any <ID>(), Arg.Any <Item>()).Returns("/");
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))
{
info.ReturnUrl = null;
info.Email = null;
info.Password = null;
var controller = new AccountsController(repo, service, accountSetting, null, null);
repo.Login(string.Empty, string.Empty).ReturnsForAnyArgs(x => true);
var result = controller.Login(info);
result.Should().BeOfType <RedirectResult>().Which.Url.Should().Be("/");
}
}
public void _Login_LoggedIn_ShouldRedirect(Database db, [Content] DbItem item, User user, [Frozen] IAccountRepository repo, LoginInfo info, INotificationService service, IAccountsSettingsService accountSetting, IUserProfileService userProfileService)
{
userProfileService.ValidateUser(Arg.Any<User>()).ReturnsForAnyArgs(true);
var controller = new AccountsController(repo, service, accountSetting, userProfileService, null);
repo.Login(string.Empty, string.Empty).ReturnsForAnyArgs(x => user);
var result = controller._Login(info);
result.Should().BeOfType<JsonResult>();
((result as JsonResult).Data as LoginResult).RedirectUrl.Should().BeEquivalentTo(info.ReturnUrl);
}
public void ShouldAddErrorToModelStateIfNotLoggedIn([Frozen] IAccountRepository repo, LoginInfo info, INotificationService service, IAccountsSettingsService accountSetting)
{
repo.Login(string.Empty, string.Empty).ReturnsForAnyArgs(x => false);
var controller = new AccountsController(repo, service, accountSetting, null, null);
var result = controller.Login(info);
controller.ModelState.IsValid.Should().BeFalse();
controller.ModelState.Keys.Should().Contain("invalidCredentials");
}
public GetRedirectUrlService(IAccountsSettingsService accountsSettingsService)
{
this.accountsSettingsService = accountsSettingsService;
}
public NotificationService(IAccountsSettingsService siteSettings)
{
this.siteSettings = siteSettings;
}
public void LogoutShouldCallSitecoreLogout(Database db, [Content] DbItem item, IAccountRepository repo, INotificationService ns, IAccountsSettingsService acc)
{
var fakeSite = new FakeSiteContext(new StringDictionary
{
{
"rootPath", "/sitecore/content"
},
{
"startItem", item.Name
}
}) as SiteContext;
fakeSite.Database = db;
using (new SiteContextSwitcher(fakeSite))
{
var ctrl = new AccountsController(repo, ns, acc, null);
ctrl.Logout();
repo.Received(1).Logout();
}
}
public void ForgotPasswordShoudCatchAndReturnViewWithError(PasswordResetInfo model, [Frozen] IAccountRepository repo, INotificationService notificationService, IAccountsSettingsService settingService)
{
var fakeSite = new FakeSiteContext(new StringDictionary
{
{
"displayMode", "normal"
}
}) as SiteContext;
using (new SiteContextSwitcher(fakeSite))
{
repo.RestorePassword(Arg.Any <string>()).ThrowsForAnyArgs(new Exception("Error"));
repo.Exists(Arg.Any <string>()).Returns(true);
var controller = new AccountsController(repo, notificationService, settingService, null);
var result = controller.ForgotPassword(model);
result.Should().BeOfType <ViewResult>().Which.Model.Should().Be(model);
result.Should().BeOfType <ViewResult>().Which.ViewData.ModelState.Should().ContainKey(nameof(model.Email))
.WhichValue.Errors.Should().Contain(x => x.ErrorMessage == "Error");
}
}
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 void LoginDialogShouldRedirectIfLoggedIn(Database db, [Content] DbItem item, [Frozen] IAccountRepository repo, LoginInfo info, INotificationService service, IAccountsSettingsService accountSetting)
{
var controller = new AccountsController(repo, service, accountSetting, null);
repo.Login(string.Empty, string.Empty).ReturnsForAnyArgs(x => true);
var result = controller.LoginDialog(info);
result.Should().BeOfType<JsonResult>();
((result as JsonResult).Data as LoginResult).RedirectUrl.Should().BeEquivalentTo(info.ReturnUrl);
}
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 LoginShouldRedirectToRootIfReturnUrlNotSet(Database db, [Content] DbItem item, [Frozen] IAccountRepository repo, LoginInfo info, INotificationService service, IAccountsSettingsService accountSetting)
{
accountSetting.GetPageLinkOrDefault(Arg.Any<Item>(), Arg.Any<ID>(), Arg.Any<Item>()).Returns("/");
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))
{
info.ReturnUrl = null;
var controller = new AccountsController(repo, service, accountSetting, null);
repo.Login(string.Empty, string.Empty).ReturnsForAnyArgs(x => true);
var result = controller.Login(info);
result.Should().BeOfType<RedirectResult>().Which.Url.Should().Be("/");
}
}
public void LogoutShouldRedirectUserToHomePage(Database db, [Content] DbItem item, IAccountRepository repo, INotificationService ns, IAccountsSettingsService acc)
{
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 ctrl = new AccountsController(repo, ns, acc, null);
var result = ctrl.Logout();
result.Should().BeOfType <RedirectResult>().Which.Url.Should().Be("/");
}
}
public void ShouldAddErrorToModelStateIfNotLoggedIn([Frozen] IAccountRepository repo, LoginInfo info, INotificationService service, IAccountsSettingsService accountSetting)
{
repo.Login(string.Empty, string.Empty).ReturnsForAnyArgs(x => false);
var controller = new AccountsController(repo, service, accountSetting, null);
var result = controller.Login(info);
controller.ModelState.IsValid.Should().BeFalse();
controller.ModelState.Keys.Should().Contain("invalidCredentials");
}
public AccountTrackerService(IAccountsSettingsService accountsSettingsService, ITrackerService trackerService)
{
this.accountsSettingsService = accountsSettingsService;
this.trackerService = trackerService;
}
public AccountsRedirectAuthenticatedAttribute(IAccountsSettingsService accountsSettingsService)
{
this.accountsSettingsService = accountsSettingsService;
}
public AccountsController(IAccountRepository accountRepository, INotificationService notificationService, IAccountsSettingsService accountsSettingsService, IGetRedirectUrlService getRedirectUrlService, IUserProfileService userProfileService, IFedAuthLoginButtonRepository fedAuthLoginRepository)
{
this.FedAuthLoginRepository = fedAuthLoginRepository;
this.AccountRepository = accountRepository;
this.NotificationService = notificationService;
this.AccountsSettingsService = accountsSettingsService;
this.GetRedirectUrlService = getRedirectUrlService;
this.UserProfileService = userProfileService;
}
