public async Task Update_role_returns_Success()
{
// arrange
var claim1 = new IdentityClaim {
ClaimType = "ClaimType1", ClaimValue = "some value"
};
var claim2 = new IdentityClaim {
ClaimType = "ClaimType2", ClaimValue = "some other value"
};
var role = new IdentityRole("Update_role_returns_Success");
role.Claims.Add(claim1);
// initial role creation
await _roleStore.CreateAsync(role);
role.Name = role.Name + " different";
role.Claims.Add(claim2);
// act
var result = await _roleStore.UpdateAsync(role);
// assert
IdentityResultAssert.IsSuccess(result);
var roleFromDb = await _roleCollection.Find(x => x.Id == role.Id).SingleOrDefaultAsync();
IdentityRoleAssert.Equal(role, roleFromDb);
}
public static void Equal(IEnumerable <IdentityRole> expected, IEnumerable <IdentityRole> actual)
{
Assert.True((expected == null && actual == null) || (expected != null && actual != null));
Assert.Equal(expected.Count(), actual.Count());
foreach (var e in expected)
{
var act = actual.SingleOrDefault(a => a.Id == e.Id);
IdentityRoleAssert.Equal(e, act);
}
}
public async Task Case_insensitive_normalizedRoleName_returns_IdentityRole()
{
// arrange
var role = new IdentityRole("Case_insensitive_normalizedRoleName_returns_IdentityRole");
await _roleStore.CreateAsync(role);
// act
var result = await _roleStore.FindByNameAsync(role.Name.ToUpper());
// assert
IdentityRoleAssert.Equal(role, result);
}
public async Task Known_normalizedRoleName_returns_IdentityRole()
{
// arrange
var role = new IdentityRole("Known_normalizedRoleName_returns_IdentityRole");
await _roleStore.CreateAsync(role);
// act
var result = await _roleStore.FindByNameAsync(role.Name);
// assert
IdentityRoleAssert.Equal(role, result);
}
public async Task Known_roleId_returns_IdentityRole()
{
// arrange
var role = new IdentityRole("Known_roleId_returns_IdentityRole");
await _roleStore.CreateAsync(role);
// act
var result = await _roleStore.FindByIdAsync(role.Id);
// assert
IdentityRoleAssert.Equal(role, result);
}
public async Task Update_role_that_does_not_already_exists_inserts_and_returns_Success()
{
// arrange
var role = new IdentityRole("Update_role_that_does_not_already_exists_inserts_and_returns_Success");
// act
var result = await _roleStore.UpdateAsync(role);
// assert
IdentityResultAssert.IsSuccess(result);
var roleFromDb = await _roleCollection.Find(x => x.Id == role.Id).SingleOrDefaultAsync();
IdentityRoleAssert.Equal(role, roleFromDb);
}
public async Task Can_update_role_multiple_times()
{
// arrange
var role = new IdentityRole("Can_update_role_multiple_times");
await _roleStore.CreateAsync(role);
// act
role.Claims.Add(new IdentityClaim {
ClaimType = "ClaimType1", ClaimValue = "claim value"
});
var result1 = await _roleStore.UpdateAsync(role);
role.Name = role.Name + " different";
var result2 = await _roleStore.UpdateAsync(role);
// assert
IdentityResultAssert.IsSuccess(result1);
IdentityResultAssert.IsSuccess(result2);
var roleFromDb = await _roleCollection.Find(x => x.Id == role.Id).SingleOrDefaultAsync();
IdentityRoleAssert.Equal(role, roleFromDb);
}
public static void Equal(IdentityUser expected, IdentityUser actual)
{
Assert.True((expected == null && actual == null) || (expected != null && actual != null));
Assert.Equal(expected.Id, actual.Id);
Assert.Equal(expected.UserName, actual.UserName);
Assert.Equal(expected.NormalizedUserName, actual.NormalizedUserName);
Assert.Equal(expected.Email, actual.Email);
Assert.Equal(expected.NormalizedEmail, actual.NormalizedEmail);
Assert.Equal(expected.EmailConfirmed, actual.EmailConfirmed);
Assert.Equal(expected.PasswordHash, actual.PasswordHash);
Assert.Equal(expected.SecurityStamp, actual.SecurityStamp);
Assert.Equal(expected.PhoneNumber, actual.PhoneNumber);
Assert.Equal(expected.PhoneNumberConfirmed, actual.PhoneNumberConfirmed);
Assert.Equal(expected.TwoFactorEnabled, actual.TwoFactorEnabled);
Assert.Equal(expected.LockoutEnd, actual.LockoutEnd);
Assert.Equal(expected.LockoutEnabled, actual.LockoutEnabled);
Assert.Equal(expected.AccessFailedCount, actual.AccessFailedCount);
IdentityRoleAssert.Equal(expected.Roles.Cast <IdentityRole>(), actual.Roles.Cast <IdentityRole>());
IdentityClaimAssert.Equal(expected.Claims, actual.Claims);
IdentityClaimAssert.Equal(expected.AllClaims, actual.AllClaims);
UserLoginInfoAssert.Equal(expected.Logins, actual.Logins);
}
public async Task When_User_has_Role_and_Role_is_deleted_should_remove_User_Role_as_well()
{
// arrange
var identityClaim1 = new IdentityClaim {
ClaimType = "ClaimType1", ClaimValue = "val"
};
var role1 = new IdentityRole {
Name = "Role1", Claims = new List <IdentityClaim> {
identityClaim1
}
};
var role2 = new IdentityRole {
Name = "Role2", Claims = new List <IdentityClaim> {
identityClaim1
}
};
await _roleStore.CreateAsync(role1);
await _roleStore.CreateAsync(role2);
var user1 = new IdentityUser {
UserName = "******", Roles = new List <IdentityRole <string> > {
role1, role2
}
};
var user2 = new IdentityUser {
UserName = "******", Roles = new List <IdentityRole <string> > {
role1
}
};
var user3 = new IdentityUser {
UserName = "******", Roles = new List <IdentityRole <string> > {
role2
}
};
await _userStore.CreateAsync(user1);
await _userStore.CreateAsync(user2);
await _userStore.CreateAsync(user3);
// act
await _roleStore.DeleteAsync(role1);
// assert
var user1FromDb = await _userCollection.Find(x => x.Id == user1.Id).SingleOrDefaultAsync();
var user2FromDb = await _userCollection.Find(x => x.Id == user2.Id).SingleOrDefaultAsync();
var user3FromDb = await _userCollection.Find(x => x.Id == user3.Id).SingleOrDefaultAsync();
// USER 1
Assert.Equal(1, user1FromDb.Roles.Count);
var user1FromDbRole2 = user1FromDb.Roles.Single(x => x.Id == role2.Id);
IdentityRoleAssert.Equal(role2, (IdentityRole)user1FromDbRole2);
// USER 2
Assert.Equal(0, user2FromDb.Roles.Count);
// USER 3
Assert.Equal(1, user3FromDb.Roles.Count);
var user3FromDbRole2 = user3FromDb.Roles.Single();
IdentityRoleAssert.Equal(role2, (IdentityRole)user3FromDbRole2);
}
