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 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; }