public void ModifyAddress_UserNameNotInitialized_ShouldNotReturnAddress(Database db, IContactFactory contactFactory)
{
// arrange
FakeSiteContext.Database = db;
var accountManager = new MockAccountManager()
{
IsCurrentCustomerPartiesInitialized = true
};
var orderManager = new MockOrderManager {
IsAvailableCountriesInitialized = false
};
var rep = new AccountRepository(accountManager, contactFactory, orderManager);
var model = new PartyInputModelItem {
Name = "fake"
};
using (new Sitecore.Security.Accounts.UserSwitcher("null", false))
{
// act
var result = rep.ModifyAddress(model);
// assert
result.Addresses.Count.Should().Be(0);
result.Countries.Count.Should().Be(0);
result.Success.Should().BeFalse();
}
}
public void GivenGuid_WhenIConfirmEmail_ThenLogicManagerGeneratesViewModel()
{
Guid expectedIdentifier = Guid.NewGuid();
Target.ConfirmEmail(expectedIdentifier);
MockAccountManager.Expect(m => m.GenerateConfirmEmailViewModel(expectedIdentifier));
}
private AuthorizationContext CreateAuthorizationContextWithExpectations(string expectedUserKey, User expectedUser)
{
MockHttpContext.User = CreateClaimsPrincipal(expectedUserKey);
AuthorizationContext filterContext = ControllerContextFactory.CreateAuthorizationContext(MockHttpContextBase);
MockAccountManager.Expect(m => m.EnsureUserEntity(filterContext.HttpContext.User.Identity as System.Security.Claims.ClaimsIdentity)).Return(expectedUser);
return(filterContext);
}
public void WhenIEditAUserRole_ThenPartiViewReturned()
{
MockAccountManager.Expect(m => m.GenerateEditViewModel(1)).Return(new UserRoleModel());
PartialViewResult result = (PartialViewResult)Target.EditRole(1);
Assert.IsNotNull(result);
}
public void GivenId_WhenLoginAudit_ThenViewResultReturned()
{
MockAccountManager.Expect(m => m.GenerateUserLoginEventModel(1)).Return(new UserModel());
var result = Target.LoginAudit(1) as ViewResult;
Assert.IsNotNull(result);
}
public void WhenAutocompleteFirstNameIsCalled_ThenLogicManagerGeneratesViewModel()
{
string expectedTerm = "bob";
JsonResult actual = Target.AutocompleteFirstName(expectedTerm);
MockAccountManager.AssertWasCalled(m => m.SearchFirstNames(expectedTerm));
}
public void WhenRequestDataTableAjaxHandler_ThenJsonResultContainsDataTableResultModel()
{
DataTableRequestModel requestModel = new DataTableRequestModel();
MockAccountManager.Expect(m => m.GenerateDataTableResultViewModel(Arg.Is(requestModel), Arg <IClientDataTable <User> > .Is.NotNull)).Return(new DataTableResultModel());
JsonResult result = Target.DataTableAjaxHandler(requestModel);
result.AssertGetData <DataTableResultModel>();
}
public void GivenNoSearchFilter_WhenIGetUserIds_ThenAllIdsAreReturned()
{
var expected = new[] { 18, 382 };
MockAccountManager.Expect(m => m.GetFilteredUserIds(Arg <IClientDataTable <User> > .Is.NotNull)).Return(expected);
var result = Target.AllFilteredUserIds() as JsonResult;
result.AssertGetData(expected);
}
public void GivenAValidUserId_WhenIGenerateUserAssociations_ThenAPartialViewIsReturned()
{
int id = 1;
MockAccountManager.Expect(m => m.GenerateUserAssociationsViewModel(id)).Return(new UserAssociationsModel());
var result = Target.UserAssociations(id) as PartialViewResult;
Assert.IsNotNull(result);
}
public void GivenUser_WhenIViewProfile_ThenLogicManagerGeneratesViewModel()
{
EducationSecurityPrincipal expectedUser = new EducationSecurityPrincipal(new EducationSecurityIdentity(Identity, TestUser));
MockHttpContext.Expect(m => m.User).Return(expectedUser);
ViewResult actual = Target.UserProfile();
MockAccountManager.AssertWasCalled(m => m.GenerateUserProfileViewModel(expectedUser));
}
public void WhenAutocompleteLastNameIsCalled_ThenJsonResultHasData()
{
IEnumerable <string> expected = new string[] { "bob", "bob smith" };
string expectedTerm = "bob";
MockAccountManager.Expect(m => m.SearchLastNames(expectedTerm)).Return(expected);
JsonResult actual = Target.AutocompleteLastName(expectedTerm);
actual.AssertGetData(expected);
}
public void GivenGuid_WhenIConfirmEmail_ThenViewHasViewModel()
{
ConfirmEmailModel expected = new ConfirmEmailModel();
Guid expectedIdentifier = Guid.NewGuid();
MockAccountManager.Expect(m => m.GenerateConfirmEmailViewModel(expectedIdentifier)).Return(expected);
ViewResult actual = Target.ConfirmEmail(expectedIdentifier);
actual.AssertGetViewModel(expected);
}
public void WhenRequestDataTableAjaxHandler_ThenGenerateListViewModelReceivesCorrectDataTableRequest_AndResultPassedToJson()
{
DataTableResultModel expected = new DataTableResultModel();
DataTableRequestModel requestModel = new DataTableRequestModel();
MockAccountManager.Expect(m => m.GenerateDataTableResultViewModel(Arg.Is(requestModel), Arg <IClientDataTable <User> > .Is.NotNull)).Return(expected);
JsonResult result = Target.DataTableAjaxHandler(requestModel);
result.AssertGetData(expected);
}
public void GivenLogicManagerReturnsViewModel_WhenIEditRole_ThenPartialViewResultContainsViewModel()
{
int expectedId = 878797;
UserRoleModel expected = new UserRoleModel();
MockAccountManager.Expect(m => m.GenerateEditViewModel(expectedId)).Return(expected);
var result = Target.EditRole(expectedId) as PartialViewResult;
result.AssertGetViewModel(expected);
}
public void GivenUser_WhenIViewProfile_ThenViewHasViewModel()
{
UserModel expected = new UserModel();
EducationSecurityPrincipal expectedUser = new EducationSecurityPrincipal(new EducationSecurityIdentity(Identity, TestUser));
MockHttpContext.Expect(m => m.User).Return(expectedUser);
MockAccountManager.Expect(m => m.GenerateUserProfileViewModel(expectedUser)).Return(expected);
ViewResult actual = Target.UserProfile();
actual.AssertGetViewModel(expected);
}
public void GivenAClaimsIdentityExists_AndUserIsAuthenticated_AndUserExists_AndRequestIsForUserProfile_WhenIAuthorize_ThenResultIsNotRedirectResult()
{
string userKey = "whatever";
AuthorizationContext authorizationContext = CreateAuthorizationContext(false, userKey);
authorizationContext.HttpContext.Request.Expect(m => m.FilePath).Return("/Account/UserProfile");
MockAccountManager.Expect(m => m.EnsureUserEntity(authorizationContext.HttpContext.User.Identity as System.Security.Claims.ClaimsIdentity)).Return(new User());
Target.OnAuthorization(authorizationContext);
Assert.IsNotInstanceOfType(authorizationContext.Result, typeof(RedirectToRouteResult));
}
public void GivenAClaimsIdentityExists_AndUserIsAuthenticated_AndUserExists_AndUserHasRole_WhenIAuthorize_ThenResultIsNotUnauthorized()
{
string userKey = "whatever";
AuthorizationContext authorizationContext = CreateAuthorizationContext(false, userKey);
authorizationContext.HttpContext.Request.Expect(m => m.FilePath).Return("hsdjkfhdkjhsfkjhdkjsf");
MockAccountManager.Expect(m => m.EnsureUserEntity(authorizationContext.HttpContext.User.Identity as System.Security.Claims.ClaimsIdentity)).Return(new User());
Target.Roles = "supervisor";
Target.OnAuthorization(authorizationContext);
Assert.IsNotInstanceOfType(authorizationContext.Result, typeof(HttpUnauthorizedResult));
}
public void GivenAuditOnMapCalled_AndClaimsPrincipalMisMatches_WhenAuthorizing_ThenDoNotCallAuditLoginOnAccountManager()
{
User expectedUserEntity = new User {
UserKey = "whatever"
};
AuthorizationContext filterContext = CreateAuthorizationContextWithExpectations(expectedUserEntity.UserKey, expectedUserEntity);
UserIdentityMapAttribute.AuditOnMap("something else");
Target.OnAuthorization(filterContext);
MockAccountManager.AssertWasNotCalled(m => m.AuditLogin(null), o => o.IgnoreArguments());
}
public void GivenGenerateViewModelThrowsValidationExceptionOnPostedRoles_WhenCreateRole_ThenPartialViewResultIsReturned_AndModelStateContainsPostedRolesErrors()
{
UserRoleModel viewModel = new UserRoleModel {
UserId = 1
};
MockAccountManager.Expect(m => m.Create(viewModel, User)).Throw(new ValidationException(new ValidationResult("fake error happened!", new string[] { "PostedRoles" }), null, null));
PartialViewResult result = Target.CreateRole(viewModel) as PartialViewResult;
Assert.IsNotNull(result);
Assert.IsTrue(Target.ModelState["PostedRoles"].Errors.Count > 0);
}
public void GivenAClaimsIdentityExistsOnRootLevel_AndUserIsAuthenticated_AndUserExists_WhenIAuthorize_ThenHttpContextUserIsSetToEducationPrincipal()
{
string userKey = "whatever";
AuthorizationContext authorizationContext = CreateAuthorizationContext(false, userKey);
authorizationContext.HttpContext.Request.Expect(m => m.FilePath).Return("hsdjkfhdkjhsfkjhdkjsf");
MockAccountManager.Expect(m => m.EnsureUserEntity(authorizationContext.HttpContext.User.Identity as System.Security.Claims.ClaimsIdentity)).Return(new User());
Target.OnAuthorization(authorizationContext);
EducationSecurityPrincipal actual = authorizationContext.HttpContext.User as EducationSecurityPrincipal;
Assert.IsNotNull(actual);
}
public void GivenAClaimsIdentityExists_AndUserIsAuthenticated_AndUserExists_AndUserIsValid_WhenIAuthorize_ThenResultIsNotRedirectResult()
{
string userKey = "whatever";
AuthorizationContext authorizationContext = CreateAuthorizationContext(false, userKey);
authorizationContext.HttpContext.Request.Expect(m => m.FilePath).Return("hsdjkfhdkjhsfkjhdkjsf");
MockAccountManager.Expect(m => m.EnsureUserEntity(authorizationContext.HttpContext.User.Identity as System.Security.Claims.ClaimsIdentity)).Return(new User {
UserKey = userKey, DisplayName = "not null", EmailAddress = "not null", FirstName = "not null", LastName = "not null"
});
Target.OnAuthorization(authorizationContext);
Assert.IsNotInstanceOfType(authorizationContext.Result, typeof(RedirectToRouteResult));
}
public void GivenAClaimsIdentityExists_AndUserIsAuthenticated_AndUserExists_WhenIAuthorize_ThenUserEntityIsSet()
{
string userKey = "whatever";
AuthorizationContext authorizationContext = CreateAuthorizationContext(false, userKey);
authorizationContext.HttpContext.Request.Expect(m => m.FilePath).Return("hsdjkfhdkjhsfkjhdkjsf");
MockAccountManager.Expect(m => m.EnsureUserEntity(authorizationContext.HttpContext.User.Identity as System.Security.Claims.ClaimsIdentity)).Return(new User {
UserKey = userKey
});
Target.OnAuthorization(authorizationContext);
Assert.IsNotNull(Target.UserEntity);
Assert.AreEqual("whatever", Target.UserEntity.UserKey);
}
public void GivenLogicManagerThrowsLicenseAgreementException_WhenAuthorizing_ThenRedirectToLicenseAgreement()
{
string userKey = "whatever";
MockHttpContext.User = CreateClaimsPrincipal(userKey);
AuthorizationContext filterContext = ControllerContextFactory.CreateAuthorizationContext(MockHttpContextBase);
MockAccountManager.Expect(m => m.EnsureUserEntity(filterContext.HttpContext.User.Identity as System.Security.Claims.ClaimsIdentity)).Throw(new LicenseAgreementException());
Target.OnAuthorization(filterContext);
var actual = filterContext.Result as RedirectToRouteResult;
actual.AssertActionRedirection("Index", "Agreement");
}
public void GivenAuditOnMapCalled_AndClaimsPrincipalMatches_WhenAuthorizing_ThenCallAuditLoginOnAccountManager()
{
User expectedUserEntity = new User {
UserKey = "whatever"
};
AuthorizationContext filterContext = CreateAuthorizationContextWithExpectations(expectedUserEntity.UserKey, expectedUserEntity);
UserIdentityMapAttribute.AuditOnMap(expectedUserEntity.UserKey);
Target.OnAuthorization(filterContext);
EducationSecurityPrincipal actual = MockHttpContext.User as EducationSecurityPrincipal;
MockAccountManager.AssertWasCalled(m => m.AuditLogin(actual));
}
public void GivenActionInvokedIsAccountLogOff_AndUserIsNotAnEducationSecurityPrincipal_AndEulaNotAccepted_WhenAuthorizing_ThenSucceed()
{
User expectedUserEntity = new User {
UserKey = "whatever"
};
MockHttpContext.User = CreateClaimsPrincipal(expectedUserEntity.UserKey);
AuthorizationContext filterContext = ControllerContextFactory.CreateAuthorizationContext(MockHttpContextBase, typeof(AccountController), "LogOff");
System.Security.Claims.ClaimsPrincipal claimsPrincipal = MockHttpContext.User as System.Security.Claims.ClaimsPrincipal;
filterContext.HttpContext.User = claimsPrincipal;
MockAccountManager.Expect(m => m.EnsureUserEntity((System.Security.Claims.ClaimsIdentity)claimsPrincipal.Identity)).Throw(new LicenseAgreementException());
Target.OnAuthorization(filterContext);
}
public void GivenAClaimsIdentityExists_AndUserIsAuthenticated_AndUserDoesNotExist_WhenIAuthorize_ThenRedirectedToProfile()
{
string userKey = "new user";
AuthorizationContext authorizationContext = CreateAuthorizationContext(false, userKey);
authorizationContext.HttpContext.Request.Expect(m => m.FilePath).Return("hsdjkfhdkjhsfkjhdkjsf");
MockAccountManager.Expect(m => m.EnsureUserEntity(authorizationContext.HttpContext.User.Identity as System.Security.Claims.ClaimsIdentity)).Return(new User {
UserKey = userKey, DisplayName = User.AnonymousValue, EmailAddress = "*****@*****.**"
});
Target.OnAuthorization(authorizationContext);
RedirectToRouteResult result = authorizationContext.Result as RedirectToRouteResult;
result.AssertActionRedirection("UserProfile", "Account");
}
public void GivenAClaimsIdentityExists_AndUserIsAuthenticated_AndUserExists_AndUserDoesNotHaveRole_WhenIAuthorize_ThenResultIsUnauthorized()
{
string userKey = "whatever";
AuthorizationContext authorizationContext = CreateAuthorizationContext(false, userKey);
authorizationContext.HttpContext.Request.Expect(m => m.FilePath).Return("hsdjkfhdkjhsfkjhdkjsf");
MockAccountManager.Expect(m => m.EnsureUserEntity(authorizationContext.HttpContext.User.Identity as System.Security.Claims.ClaimsIdentity)).Return(new User());
Target.Roles = "admin";
Target.OnAuthorization(authorizationContext);
ViewResult result = authorizationContext.Result as ViewResult;
Assert.IsNotNull(result);
Assert.AreEqual("Unauthorized", result.ViewName);
authorizationContext.HttpContext.Response.AssertWasCalled(m => m.StatusCode = 401);
}
public void GivenAuditOnMapCalled_AndClaimsPrincipalMatches_AndUserAuthorized_WhenAuthorizing_ThenDoNotRepeatCallToAuditLoginOnAccountManager()
{
User expectedUserEntity = new User {
UserKey = "whatever"
};
AuthorizationContext filterContext = CreateAuthorizationContextWithExpectations(expectedUserEntity.UserKey, expectedUserEntity);
System.Security.Claims.ClaimsPrincipal claimsPrincipal = MockHttpContext.User as System.Security.Claims.ClaimsPrincipal;
UserIdentityMapAttribute.AuditOnMap(expectedUserEntity.UserKey);
Target.OnAuthorization(filterContext);
filterContext.HttpContext.User = claimsPrincipal;
Target.OnAuthorization(filterContext);
EducationSecurityPrincipal actual = MockHttpContext.User as EducationSecurityPrincipal;
MockAccountManager.AssertWasCalled(m => m.AuditLogin(null), o => o.IgnoreArguments().Repeat.Once());
}
public void GivenAClaimsIdentityExists_AndUserIsAuthenticated_AndUserDoesNotExist_WhenIAuthorize_ThenUserIsCreatedWithValidState()
{
string userKey = "new user";
AuthorizationContext authorizationContext = CreateAuthorizationContext(false, userKey);
authorizationContext.HttpContext.Request.Expect(m => m.FilePath).Return("hsdjkfhdkjhsfkjhdkjsf");
MockAccountManager.Expect(m => m.EnsureUserEntity(authorizationContext.HttpContext.User.Identity as System.Security.Claims.ClaimsIdentity)).Return(new User {
UserKey = userKey, DisplayName = User.AnonymousValue, EmailAddress = "*****@*****.**"
});
Target.OnAuthorization(authorizationContext);
User actualUser = Target.UserEntity;
Assert.IsNotNull(actualUser);
Assert.AreEqual("new user", actualUser.UserKey);
Assert.AreEqual(User.AnonymousValue, actualUser.DisplayName);
Assert.AreEqual(User.AnonymousEmailValue, actualUser.EmailAddress);
}
public void DeleteAddresss_NotInitialized_ShouldNotReturnAllAdresses(Database db, IContactFactory contactFactory)
{
// arrange
FakeSiteContext.Database = db;
var accountManager = new MockAccountManager()
{
IsCurrentCustomerPartiesInitialized = true
};
var rep = new AccountRepository(accountManager, contactFactory, new MockOrderManager());
var model = new DeletePartyInputModelItem {
};
// act
var result = rep.DeleteAddresses(model);
// assert
result.Addresses.Count.Should().Be(0);
result.Success.Should().BeFalse();
}
