public async Task GivenICreateUser_AndTheUserDoesNotHaveIdentity_ThenIShouldGetAFailedResultAsync()
{
// arrange
MemberUserStore sut = CreateSut();
var fakeUser = new MemberIdentityUser();
IMemberType fakeMemberType = new MemberType(new MockShortStringHelper(), 77);
IMember mockMember = Mock.Of <IMember>(m =>
m.Name == "fakeName" &&
m.Email == "*****@*****.**" &&
m.Username == "fakeUsername" &&
m.RawPasswordValue == "fakePassword" &&
m.ContentTypeAlias == fakeMemberType.Alias &&
m.HasIdentity == false);
_mockMemberService.Setup(x => x.CreateMember(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).Returns(mockMember);
_mockMemberService.Setup(x => x.Save(mockMember));
// act
IdentityResult actual = await sut.CreateAsync(null);
// assert
Assert.IsFalse(actual.Succeeded);
Assert.IsTrue(actual.Errors.Any(x => x.Code == "IdentityErrorUserStore" && x.Description == "Value cannot be null. (Parameter 'user')"));
_mockMemberService.VerifyNoOtherCalls();
}
public async Task GivenIDeleteUser_AndTheUserIsDeletedCorrectly_ThenIShouldGetASuccessResultAsync()
{
// arrange
MemberUserStore sut = CreateSut();
var fakeUser = new MemberIdentityUser(777);
var fakeCancellationToken = new CancellationToken()
{
};
IMemberType fakeMemberType = new MemberType(new MockShortStringHelper(), 77);
IMember mockMember = new Member(fakeMemberType)
{
Id = 777,
Name = "fakeName",
Email = "*****@*****.**",
Username = "******",
RawPasswordValue = "fakePassword"
};
_mockMemberService.Setup(x => x.GetById(mockMember.Id)).Returns(mockMember);
_mockMemberService.Setup(x => x.Delete(mockMember));
// act
IdentityResult identityResult = await sut.DeleteAsync(fakeUser, fakeCancellationToken);
// assert
Assert.IsTrue(identityResult.Succeeded);
Assert.IsTrue(!identityResult.Errors.Any());
_mockMemberService.Verify(x => x.GetById(mockMember.Id));
_mockMemberService.Verify(x => x.Delete(mockMember));
_mockMemberService.VerifyNoOtherCalls();
}
public async Task GivenICreateANewUser_AndTheUserIsPopulatedCorrectly_ThenIShouldGetASuccessResultAsync()
{
// arrange
MemberUserStore sut = CreateSut();
var fakeUser = new MemberIdentityUser();
IMemberType fakeMemberType = new MemberType(new MockShortStringHelper(), 77);
IMember mockMember = Mock.Of <IMember>(m =>
m.Name == "fakeName" &&
m.Email == "*****@*****.**" &&
m.Username == "fakeUsername" &&
m.RawPasswordValue == "fakePassword" &&
m.Comments == "hello" &&
m.ContentTypeAlias == fakeMemberType.Alias &&
m.HasIdentity == true);
_mockMemberService.Setup(x => x.CreateMember(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).Returns(mockMember);
_mockMemberService.Setup(x => x.Save(mockMember));
// act
IdentityResult identityResult = await sut.CreateAsync(fakeUser, CancellationToken.None);
// assert
Assert.IsTrue(identityResult.Succeeded);
Assert.IsTrue(!identityResult.Errors.Any());
_mockMemberService.Verify(x => x.CreateMember(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()));
_mockMemberService.Verify(x => x.Save(mockMember));
}
public async Task GivenICreateUser_AndTheUserIsNull_ThenIShouldGetAFailedResultAsync()
{
// arrange
MemberUserStore sut = CreateSut();
// act
IdentityResult actual = await sut.CreateAsync(null);
// assert
Assert.IsFalse(actual.Succeeded);
Assert.IsTrue(actual.Errors.Any(x => x.Code == "IdentityErrorUserStore" && x.Description == "Value cannot be null. (Parameter 'user')"));
_mockMemberService.VerifyNoOtherCalls();
}
public async Task GivenISetNormalizedUserName_ThenIShouldGetASuccessResult()
{
// arrange
MemberUserStore sut = CreateSut();
var fakeUser = new MemberIdentityUser()
{
UserName = "******"
};
// act
await sut.SetNormalizedUserNameAsync(fakeUser, "NewName", CancellationToken.None);
// assert
Assert.AreEqual("NewName", fakeUser.UserName);
Assert.AreEqual("NewName", await sut.GetNormalizedUserNameAsync(fakeUser, CancellationToken.None));
}
public MemberManager CreateSut()
{
IScopeProvider scopeProvider = new Mock <IScopeProvider>().Object;
_mockMemberService = new Mock <IMemberService>();
var mapDefinitions = new List <IMapDefinition>()
{
new IdentityMapDefinition(
Mock.Of <ILocalizedTextService>(),
Mock.Of <IEntityService>(),
Options.Create(new GlobalSettings()),
AppCaches.Disabled),
};
_fakeMemberStore = new MemberUserStore(
_mockMemberService.Object,
new UmbracoMapper(new MapDefinitionCollection(() => mapDefinitions), scopeProvider),
scopeProvider,
new IdentityErrorDescriber(),
Mock.Of <IPublishedSnapshotAccessor>(), Mock.Of <IExternalLoginWithKeyService>());
_mockIdentityOptions = new Mock <IOptions <IdentityOptions> >();
var idOptions = new IdentityOptions {
Lockout = { AllowedForNewUsers = false }
};
_mockIdentityOptions.Setup(o => o.Value).Returns(idOptions);
_mockPasswordHasher = new Mock <IPasswordHasher <MemberIdentityUser> >();
var userValidators = new List <IUserValidator <MemberIdentityUser> >();
var validator = new Mock <IUserValidator <MemberIdentityUser> >();
userValidators.Add(validator.Object);
_mockServiceProviders = new Mock <IServiceProvider>();
_mockPasswordConfiguration = new Mock <IOptions <MemberPasswordConfigurationSettings> >();
_mockPasswordConfiguration.Setup(x => x.Value).Returns(() =>
new MemberPasswordConfigurationSettings()
{
});
var pwdValidators = new List <PasswordValidator <MemberIdentityUser> >
{
new PasswordValidator <MemberIdentityUser>()
};
var userManager = new MemberManager(
new Mock <IIpResolver>().Object,
_fakeMemberStore,
_mockIdentityOptions.Object,
_mockPasswordHasher.Object,
userValidators,
pwdValidators,
new MembersErrorDescriber(Mock.Of <ILocalizedTextService>()),
_mockServiceProviders.Object,
new Mock <ILogger <UserManager <MemberIdentityUser> > >().Object,
_mockPasswordConfiguration.Object,
Mock.Of <IPublicAccessService>(),
Mock.Of <IHttpContextAccessor>());
validator.Setup(v => v.ValidateAsync(
userManager,
It.IsAny <MemberIdentityUser>()))
.Returns(Task.FromResult(IdentityResult.Success)).Verifiable();
return(userManager);
}
public async Task GivenIUpdateAUser_ThenIShouldGetASuccessResultAsync()
{
// arrange
MemberUserStore sut = CreateSut();
var fakeUser = new MemberIdentityUser
{
Id = "123",
Name = "fakeName",
Email = "*****@*****.**",
UserName = "******",
Comments = "hello",
LastLoginDateUtc = DateTime.UtcNow,
LastPasswordChangeDateUtc = DateTime.UtcNow,
EmailConfirmed = true,
AccessFailedCount = 3,
LockoutEnd = DateTime.UtcNow.AddDays(10),
IsApproved = true,
PasswordHash = "abcde",
SecurityStamp = "abc"
};
fakeUser.Roles.Add(new IdentityUserRole <string> {
RoleId = "role1", UserId = "123"
});
fakeUser.Roles.Add(new IdentityUserRole <string> {
RoleId = "role2", UserId = "123"
});
IMemberType fakeMemberType = new MemberType(new MockShortStringHelper(), 77);
IMember mockMember = Mock.Of <IMember>(m =>
m.Id == 123 &&
m.Name == "a" &&
m.Email == "*****@*****.**" &&
m.Username == "c" &&
m.RawPasswordValue == "d" &&
m.Comments == "e" &&
m.ContentTypeAlias == fakeMemberType.Alias &&
m.HasIdentity == true &&
m.EmailConfirmedDate == DateTime.MinValue &&
m.FailedPasswordAttempts == 0 &&
m.LastLockoutDate == DateTime.MinValue &&
m.IsApproved == false &&
m.RawPasswordValue == "xyz" &&
m.SecurityStamp == "xyz");
_mockMemberService.Setup(x => x.Save(mockMember));
_mockMemberService.Setup(x => x.GetById(123)).Returns(mockMember);
// act
IdentityResult identityResult = await sut.UpdateAsync(fakeUser, CancellationToken.None);
// assert
Assert.IsTrue(identityResult.Succeeded);
Assert.IsTrue(!identityResult.Errors.Any());
Assert.AreEqual(fakeUser.Name, mockMember.Name);
Assert.AreEqual(fakeUser.Email, mockMember.Email);
Assert.AreEqual(fakeUser.UserName, mockMember.Username);
Assert.AreEqual(fakeUser.Comments, mockMember.Comments);
Assert.AreEqual(fakeUser.LastPasswordChangeDateUtc.Value.ToLocalTime(), mockMember.LastPasswordChangeDate);
Assert.AreEqual(fakeUser.LastLoginDateUtc.Value.ToLocalTime(), mockMember.LastLoginDate);
Assert.AreEqual(fakeUser.AccessFailedCount, mockMember.FailedPasswordAttempts);
Assert.AreEqual(fakeUser.IsLockedOut, mockMember.IsLockedOut);
Assert.AreEqual(fakeUser.IsApproved, mockMember.IsApproved);
Assert.AreEqual(fakeUser.PasswordHash, mockMember.RawPasswordValue);
Assert.AreEqual(fakeUser.SecurityStamp, mockMember.SecurityStamp);
Assert.AreNotEqual(DateTime.MinValue, mockMember.EmailConfirmedDate.Value);
_mockMemberService.Verify(x => x.Save(mockMember));
_mockMemberService.Verify(x => x.GetById(123));
_mockMemberService.Verify(x => x.ReplaceRoles(new[] { 123 }, new[] { "role1", "role2" }));
}
