public async Task ShouldReturnAllUsersWithAdminRoleClaim()
{
DocumentDbUserStore <DocumentDbIdentityUser> store = CreateUserStore();
string adminRoleValue = Guid.NewGuid().ToString();
DocumentDbIdentityUser <DocumentDbIdentityRole> firstAdmin = DocumentDbIdentityUserBuilder.Create().WithId().AddClaim(ClaimTypes.Role, adminRoleValue).AddClaim();
DocumentDbIdentityUser <DocumentDbIdentityRole> secondAdmin = DocumentDbIdentityUserBuilder.Create().WithId().AddClaim(ClaimTypes.Role, adminRoleValue).AddClaim().AddClaim();
DocumentDbIdentityUser <DocumentDbIdentityRole> thirdAdmin = DocumentDbIdentityUserBuilder.Create().WithId().AddClaim(ClaimTypes.Role, adminRoleValue);
CreateDocument(firstAdmin);
CreateDocument(secondAdmin);
CreateDocument(DocumentDbIdentityUserBuilder.Create().AddClaim().AddClaim());
CreateDocument(DocumentDbIdentityUserBuilder.Create().AddClaim().AddClaim().AddClaim());
CreateDocument(DocumentDbIdentityUserBuilder.Create().AddClaim().AddClaim());
CreateDocument(thirdAdmin);
CreateDocument(DocumentDbIdentityUserBuilder.Create().AddClaim().AddClaim().AddClaim().AddClaim());
IList <DocumentDbIdentityUser> adminUsers = await store.GetUsersForClaimAsync(new Claim(ClaimTypes.Role, adminRoleValue), CancellationToken.None);
Assert.Collection(
adminUsers,
u => u.Id.Equals(firstAdmin.Id),
u => u.Id.Equals(secondAdmin.Id),
u => u.Id.Equals(thirdAdmin.Id));
}
public async Task ShouldReturnAllUsersWithAdminRole()
{
DocumentDbIdentityRole adminRole = DocumentDbIdentityRoleBuilder.Create().WithNormalizedRoleName();
DocumentDbUserStore <DocumentDbIdentityUser> store = CreateUserStore();
DocumentDbIdentityUser <DocumentDbIdentityRole> firstAdmin = DocumentDbIdentityUserBuilder.Create().WithId().WithNormalizedUserName().AddRole(adminRole).AddRole();
DocumentDbIdentityUser <DocumentDbIdentityRole> secondAdmin = DocumentDbIdentityUserBuilder.Create().WithId().WithNormalizedUserName().AddRole(adminRole).AddRole().AddRole();
DocumentDbIdentityUser <DocumentDbIdentityRole> thirdAdmin = DocumentDbIdentityUserBuilder.Create().WithId().WithNormalizedUserName().AddRole(adminRole);
CreateDocument(firstAdmin);
CreateDocument(secondAdmin);
CreateDocument(DocumentDbIdentityUserBuilder.Create().AddRole().AddRole());
CreateDocument(DocumentDbIdentityUserBuilder.Create().AddRole().AddRole().AddRole());
CreateDocument(thirdAdmin);
CreateDocument(DocumentDbIdentityUserBuilder.Create());
CreateDocument(DocumentDbIdentityUserBuilder.Create().AddRole());
IList <DocumentDbIdentityUser> adminUsers = await store.GetUsersInRoleAsync(adminRole.NormalizedName, CancellationToken.None);
Assert.Collection(
adminUsers,
u => u.Id.Equals(firstAdmin.Id),
u => u.Id.Equals(secondAdmin.Id),
u => u.Id.Equals(thirdAdmin.Id));
}
public async Task <UserSignInResult> CheckSignInAsync(string userName, string password)
{
DocumentDbIdentityUser user = await manager.UserManager.FindByNameAsync(userName);
SignInResult result = await manager.CheckPasswordSignInAsync(user, password, false);
return(converter.Convert(result));
}
public async Task ShouldIncreaseAccessFailedCountBy1(int accessFailedCount)
{
DocumentDbUserStore <DocumentDbIdentityUser <DocumentDbIdentityRole>, DocumentDbIdentityRole> store = CreateUserStore();
DocumentDbIdentityUser <DocumentDbIdentityRole> targetUser = DocumentDbIdentityUserBuilder.Create().WithAccessFailedCountOf(accessFailedCount);
await store.IncrementAccessFailedCountAsync(targetUser, CancellationToken.None);
Assert.Equal(++accessFailedCount, targetUser.AccessFailedCount);
}
public async Task ShouldResetAccessFailedCountToZero(int accessFailedCount)
{
DocumentDbUserStore <DocumentDbIdentityUser> store = CreateUserStore();
DocumentDbIdentityUser targetUser = DocumentDbIdentityUserBuilder.Create().WithAccessFailedCountOf(accessFailedCount);
await store.ResetAccessFailedCountAsync(targetUser, CancellationToken.None);
Assert.Equal(0, targetUser.AccessFailedCount);
}
public async Task ShouldReturnUserIsNotInRole()
{
DocumentDbUserStore <DocumentDbIdentityUser <DocumentDbIdentityRole>, DocumentDbIdentityRole> store = CreateUserStore();
DocumentDbIdentityUser <DocumentDbIdentityRole> user = DocumentDbIdentityUserBuilder.Create().WithId().AddRole().AddRole();
bool result = await store.IsInRoleAsync(user, Guid.NewGuid().ToString(), CancellationToken.None);
Assert.False(result);
}
public async Task ShouldReturnUserIsNotInRole()
{
DocumentDbUserStore <DocumentDbIdentityUser> userStore = CreateUserStore();
DocumentDbIdentityUser targetUser = DocumentDbIdentityUserBuilder.Create().AddRole().AddRole();
bool isInRole = await userStore.IsInRoleAsync(targetUser, "NonExistantRoleName", CancellationToken.None);
Assert.False(isInRole);
}
public async Task ShouldSetNormalizedUserName()
{
DocumentDbIdentityUser user = DocumentDbIdentityUserBuilder.Create().WithNormalizedUserName();
DocumentDbUserStore <DocumentDbIdentityUser> store = CreateUserStore();
string normalizedUserName = Guid.NewGuid().ToString();
await store.SetNormalizedUserNameAsync(user, normalizedUserName, CancellationToken.None);
Assert.Equal(normalizedUserName, user.NormalizedUserName);
}
public async Task ShouldReturnUserIsInRole()
{
DocumentDbUserStore <DocumentDbIdentityUser> userStore = CreateUserStore();
DocumentDbIdentityRole targetRole = DocumentDbIdentityRoleBuilder.Create().WithNormalizedRoleName();
DocumentDbIdentityUser targetUser = DocumentDbIdentityUserBuilder.Create().AddRole(targetRole).AddRole();
bool isInRole = await userStore.IsInRoleAsync(targetUser, targetRole.NormalizedName, CancellationToken.None);
Assert.True(isInRole);
}
public async Task ShouldThrowExceptionOnAddingUserToNonexistantRole()
{
DocumentDbUserStore <DocumentDbIdentityUser <DocumentDbIdentityRole>, DocumentDbIdentityRole> userStore = CreateUserStore();
DocumentDbIdentityUser <DocumentDbIdentityRole> targetUser = DocumentDbIdentityUserBuilder.Create();
DocumentDbIdentityRole targetRole = DocumentDbIdentityRoleBuilder.Create().WithId().WithNormalizedRoleName();
string roleName = Guid.NewGuid().ToString();
// Add the created sample data role to the user
await Assert.ThrowsAsync(typeof(ArgumentException), async() => await userStore.AddToRoleAsync(targetUser, targetRole.Name, CancellationToken.None));
}
public async Task ShouldReturnUserIsNotInRoleWhenPassingNotNormalizedRoleNameToIsInRole()
{
DocumentDbUserStore <DocumentDbIdentityUser> userStore = CreateUserStore();
DocumentDbIdentityRole targetRole = DocumentDbIdentityRoleBuilder.Create().WithNormalizedRoleName();
DocumentDbIdentityUser targetUser = DocumentDbIdentityUserBuilder.Create().AddRole(targetRole).AddRole();
// Pass not normalized name which should lead to not locating the target role
bool isInRole = await userStore.IsInRoleAsync(targetUser, targetRole.Name, CancellationToken.None);
Assert.False(isInRole);
}
public async Task ShouldReturnUserIsInRole()
{
DocumentDbIdentityRole role = DocumentDbIdentityRoleBuilder.Create();
DocumentDbUserStore <DocumentDbIdentityUser <DocumentDbIdentityRole>, DocumentDbIdentityRole> store = CreateUserStore();
DocumentDbIdentityUser <DocumentDbIdentityRole> user = DocumentDbIdentityUserBuilder.Create().WithId().AddRole(role).AddRole().AddRole();
bool result = await store.IsInRoleAsync(user, role.Name, CancellationToken.None);
Assert.True(result);
}
public async Task ShouldReturnNoUsersWithAdminRoleWhenPassingNotNormalizedRoleNameToGetUsersInRole()
{
DocumentDbIdentityRole adminRole = DocumentDbIdentityRoleBuilder.Create().WithNormalizedRoleName();
DocumentDbUserStore <DocumentDbIdentityUser> store = CreateUserStore();
DocumentDbIdentityUser <DocumentDbIdentityRole> firstAdmin = DocumentDbIdentityUserBuilder.Create().WithId().WithNormalizedUserName().AddRole(adminRole).AddRole();
CreateDocument(firstAdmin);
CreateDocument(DocumentDbIdentityUserBuilder.Create().AddRole().AddRole());
IList <DocumentDbIdentityUser> adminUsers = await store.GetUsersInRoleAsync(adminRole.Name, CancellationToken.None);
Assert.Empty(adminUsers);
}
public async Task ShouldAddClaimsToUser()
{
DocumentDbUserStore <DocumentDbIdentityUser> userStore = CreateUserStore();
DocumentDbIdentityUser targetUser = DocumentDbIdentityUserBuilder.Create();
Claim userCountryClaim = new Claim(ClaimTypes.Country, "Austria");
Claim userPostalCodeClaim = new Claim(ClaimTypes.PostalCode, "1010");
Claim[] claimsToAdd = new Claim[] { userCountryClaim, userPostalCodeClaim };
await userStore.AddClaimsAsync(targetUser, claimsToAdd, CancellationToken.None);
Assert.Equal(claimsToAdd, targetUser.Claims);
}
public async Task ShouldThrowExceptionOnAddingUserToNonexistantRole()
{
DocumentDbUserStore <DocumentDbIdentityUser> userStore = CreateUserStore();
DocumentDbRoleStore <DocumentDbIdentityRole> roleStore = CreateRoleStore();
DocumentDbIdentityUser targetUser = DocumentDbIdentityUserBuilder.Create();
DocumentDbIdentityRole someNotTargetedRole = DocumentDbIdentityRoleBuilder.Create().WithId().WithNormalizedRoleName();
// Create a role so there is a differently named role in the store
await roleStore.CreateAsync(someNotTargetedRole, CancellationToken.None);
// Add the user to a role name different than the role created before, expecting an exception
await Assert.ThrowsAsync(typeof(ArgumentException), async() => await userStore.AddToRoleAsync(targetUser, "NotExistantRole", CancellationToken.None));
}
public async Task ShouldThrowExceptionWhenPassingNotNormalizedNameToAddToRole()
{
DocumentDbUserStore <DocumentDbIdentityUser> userStore = CreateUserStore();
DocumentDbRoleStore <DocumentDbIdentityRole> roleStore = CreateRoleStore();
DocumentDbIdentityUser targetUser = DocumentDbIdentityUserBuilder.Create();
DocumentDbIdentityRole targetRole = DocumentDbIdentityRoleBuilder.Create().WithId().WithNormalizedRoleName();
// Create sample data role
await roleStore.CreateAsync(targetRole, CancellationToken.None);
// Add the user to the created role, but pass the not normalized name, expecting an exception
await Assert.ThrowsAsync(typeof(ArgumentException), async() => await userStore.AddToRoleAsync(targetUser, targetRole.Name, CancellationToken.None));
}
public async Task ShouldReturnUserByLoginProvider()
{
DocumentDbUserStore <DocumentDbIdentityUser> store = CreateUserStore();
DocumentDbIdentityUser <DocumentDbIdentityRole> targetUser = DocumentDbIdentityUserBuilder.Create().WithId().WithUserLoginInfo(amount: 3);
UserLoginInfo targetLogin = targetUser.Logins[1];
CreateDocument(DocumentDbIdentityUserBuilder.Create().WithId().WithUserLoginInfo(amount: 2));
CreateDocument(targetUser);
CreateDocument(DocumentDbIdentityUserBuilder.Create().WithId().WithUserLoginInfo(amount: 2));
DocumentDbIdentityUser <DocumentDbIdentityRole> foundUser = await store.FindByLoginAsync(targetLogin.LoginProvider, targetLogin.ProviderKey, CancellationToken.None);
Assert.Equal(targetUser.Id, foundUser.Id);
}
public async Task ShouldReturnUserByEmail()
{
DocumentDbUserStore <DocumentDbIdentityUser> userStore = CreateUserStore();
DocumentDbIdentityUser <DocumentDbIdentityRole> targetUser = DocumentDbIdentityUserBuilder.Create().WithId().WithNormalizedEmail();
CreateDocument(DocumentDbIdentityUserBuilder.Create().WithId().WithNormalizedEmail());
CreateDocument(DocumentDbIdentityUserBuilder.Create().WithId().WithNormalizedEmail());
CreateDocument(targetUser);
CreateDocument(DocumentDbIdentityUserBuilder.Create().WithId().WithNormalizedEmail());
DocumentDbIdentityUser <DocumentDbIdentityRole> foundUser = await userStore.FindByEmailAsync(targetUser.NormalizedEmail, CancellationToken.None);
Assert.Equal(targetUser.Id, foundUser.Id);
}
public async Task ShouldRemoveRoleFromUser()
{
DocumentDbUserStore <DocumentDbIdentityUser> userStore = CreateUserStore();
DocumentDbIdentityRole firstRole = DocumentDbIdentityRoleBuilder.Create().WithNormalizedRoleName();
DocumentDbIdentityRole secondRole = DocumentDbIdentityRoleBuilder.Create().WithNormalizedRoleName();
DocumentDbIdentityUser targetUser = DocumentDbIdentityUserBuilder.Create().AddRole(firstRole).AddRole(secondRole);
// Remove the second role
await userStore.RemoveFromRoleAsync(targetUser, secondRole.NormalizedName, CancellationToken.None);
// Assert second role has been removed while first one is still there
Assert.DoesNotContain(targetUser.Roles, r => r.NormalizedName.Equals(secondRole.NormalizedName));
Assert.Contains(targetUser.Roles, r => r.NormalizedName.Equals(firstRole.NormalizedName));
}
public async Task ShouldNotRemoveRoleFromUserWhenPassingNotNormalizedRoleNameToRemoveFromRole()
{
DocumentDbUserStore <DocumentDbIdentityUser> userStore = CreateUserStore();
DocumentDbIdentityRole firstRole = DocumentDbIdentityRoleBuilder.Create().WithNormalizedRoleName();
DocumentDbIdentityRole secondRole = DocumentDbIdentityRoleBuilder.Create().WithNormalizedRoleName();
DocumentDbIdentityUser targetUser = DocumentDbIdentityUserBuilder.Create().AddRole(firstRole).AddRole(secondRole);
// Try remove the second role with a not normalized role name
await userStore.RemoveFromRoleAsync(targetUser, secondRole.Name, CancellationToken.None);
// Assert both roles are still here, as lookup without normalized name should have failed
Assert.Collection(targetUser.Roles,
r => r.NormalizedName.Equals(firstRole.NormalizedName),
r => r.NormalizedName.Equals(secondRole.NormalizedName));
}
public async Task ShouldAddUserToRole()
{
DocumentDbUserStore <DocumentDbIdentityUser> userStore = CreateUserStore();
DocumentDbRoleStore <DocumentDbIdentityRole> roleStore = CreateRoleStore();
DocumentDbIdentityUser targetUser = DocumentDbIdentityUserBuilder.Create();
DocumentDbIdentityRole targetRole = DocumentDbIdentityRoleBuilder.Create("RoleName").WithId().WithNormalizedRoleName();
// Create sample data role
await roleStore.CreateAsync(targetRole, CancellationToken.None);
// Add the created sample data role to the user
await userStore.AddToRoleAsync(targetUser, targetRole.NormalizedName, CancellationToken.None);
Assert.Contains(targetUser.Roles, r => r.NormalizedName.Equals(targetRole.NormalizedName));
}
public async Task ShouldRemoveClaimsFromUserByPassingOriginalReferences()
{
DocumentDbUserStore <DocumentDbIdentityUser> userStore = CreateUserStore();
Claim userCountryClaim = new Claim(ClaimTypes.Country, "Austria");
Claim userPostalCodeClaim = new Claim(ClaimTypes.PostalCode, "1010");
Claim userNameClaim = new Claim(ClaimTypes.Name, "Name");
Claim[] claimsToRemove = new Claim[] { userCountryClaim, userNameClaim };
DocumentDbIdentityUser targetUser = DocumentDbIdentityUserBuilder.Create().AddClaim(userCountryClaim).AddClaim(userPostalCodeClaim);
await userStore.RemoveClaimsAsync(targetUser, claimsToRemove, CancellationToken.None);
Assert.DoesNotContain(userCountryClaim, targetUser.Claims);
Assert.DoesNotContain(userNameClaim, targetUser.Claims);
}
public void Map_WhenMappingIdentity_SetsSaveValues()
{
//Given
Person person = new Person()
{
FirstName = "First",
LastName = "Last",
Email = "*****@*****.**"
};
//When
DocumentDbIdentityUser identityUser = GetMapped <DocumentDbIdentityUser, Person>(person);
//Then
Assert.Equal(person.Id.ToString(), identityUser.Id);
Assert.Equal(person.Email, identityUser.Email);
Assert.Equal($"{person.FirstName.Substring(0,1)}{person.LastName}", identityUser.UserName);
}
public async Task <object> Register([FromBody] RegisterDto model)
{
var user = new DocumentDbIdentityUser
{
UserName = model.Email,
Email = model.Email
};
var result = await userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
throw new ApplicationException("UNKNOWN_ERROR");
}
await signInManager.SignInAsync(user, false);
return(new { token = GenerateJwtToken(model.Email, user) });
}
public async Task ShouldRemoveClaimsFromUserByValueComparison()
{
string userCountryClaimValue = "Austria";
string userPostalCodeValue = "1010";
DocumentDbUserStore <DocumentDbIdentityUser> userStore = CreateUserStore();
Claim userCountryClaim = new Claim(ClaimTypes.Country, userCountryClaimValue);
Claim userPostalCodeClaim = new Claim(ClaimTypes.PostalCode, userPostalCodeValue);
Claim userCountryClaimComparison = new Claim(ClaimTypes.Country, userCountryClaimValue);
Claim userPostalCodeClaimComparison = new Claim(ClaimTypes.PostalCode, userPostalCodeValue);
Claim[] claimsToRemove = new Claim[] { userCountryClaimComparison, userPostalCodeClaimComparison };
DocumentDbIdentityUser targetUser = DocumentDbIdentityUserBuilder.Create().AddClaim(userCountryClaim).AddClaim(userPostalCodeClaim);
await userStore.RemoveClaimsAsync(targetUser, claimsToRemove, CancellationToken.None);
Assert.DoesNotContain(userCountryClaim, targetUser.Claims);
Assert.DoesNotContain(userPostalCodeClaim, targetUser.Claims);
}
private object GenerateJwtToken(string email, DocumentDbIdentityUser user)
{
var claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.Sub, email),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(ClaimTypes.NameIdentifier, user.Id)
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(configuration["JwtKey"]));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var expires = DateTime.Parse("2017/12/31");// DateTime.Now.AddDays(Convert.ToDouble(configuration["JwtExpireDays"]));
var token = new JwtSecurityToken(
configuration["JwtIssuer"],
configuration["JwtIssuer"],
claims,
expires: expires,
signingCredentials: creds
);
return(new JwtSecurityTokenHandler().WriteToken(token));
}
public DocumentDbIdentityUserBuilder(DocumentDbIdentityUser identityUser)
{
this.identityUser = identityUser;
}
