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 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 Known_normalizedRoleName_returns_IdentityRole()
{
// arrange
var role = new IdentityRole("Known_normalizedRoleName_returns_IdentityRole");
role.NormalizedName = role.Name;
await _roleStore.CreateAsync(role);
// act
var result = await _roleStore.FindByNameAsync(role.NormalizedName);
// 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);
IdentityUserLoginAssert.Equal(expected.Logins, actual.Logins);
}
