public async Task RemoveUserClaimTest()
{
var db = UnitTestHelper.CreateDefaultDb();
var manager = new UserManager <IdentityUser>(new UserStore <IdentityUser>(db));
var user = new IdentityUser("u1");
var result = await manager.CreateAsync(user);
Assert.NotNull(user);
var claims = new[]
{
new Claim("c1", "v1"),
new Claim("c2", "v2"),
new Claim("c3", "v3")
};
foreach (Claim c in claims)
{
UnitTestHelper.IsSuccess(await manager.AddClaimAsync(user.Id, c));
}
var userClaims = new List <Claim>(await manager.GetClaimsAsync(user.Id));
Assert.Equal(3, userClaims.Count);
foreach (Claim c in claims)
{
Assert.True(userClaims.Exists(u => u.Type == c.Type && u.Value == c.Value));
UnitTestHelper.IsSuccess(await manager.RemoveClaimAsync(user.Id, c));
}
var cs = await manager.GetClaimsAsync(user.Id);
Assert.Equal(0, cs.Count());
Assert.Equal(0, db.Set <IdentityUserClaim>().Count());
}
public async Task ResetLockoutTest()
{
var mgr = TestUtil.CreateManager();
mgr.DefaultAccountLockoutTimeSpan = TimeSpan.FromHours(1);
mgr.UserLockoutEnabledByDefault = true;
mgr.MaxFailedAccessAttemptsBeforeLockout = 2;
var user = new IdentityUser("resetLockout");
UnitTestHelper.IsSuccess(await mgr.CreateAsync(user));
Assert.True(await mgr.GetLockoutEnabledAsync(user.Id));
Assert.True(user.LockoutEnabled);
Assert.False(await mgr.IsLockedOutAsync(user.Id));
UnitTestHelper.IsSuccess(await mgr.AccessFailedAsync(user.Id));
Assert.False(await mgr.IsLockedOutAsync(user.Id));
Assert.False(await mgr.GetLockoutEndDateAsync(user.Id) > DateTimeOffset.UtcNow.AddMinutes(55));
Assert.Equal(1, await mgr.GetAccessFailedCountAsync(user.Id));
UnitTestHelper.IsSuccess(await mgr.ResetAccessFailedCountAsync(user.Id));
Assert.Equal(0, await mgr.GetAccessFailedCountAsync(user.Id));
Assert.False(await mgr.IsLockedOutAsync(user.Id));
Assert.False(await mgr.GetLockoutEndDateAsync(user.Id) > DateTimeOffset.UtcNow.AddMinutes(55));
UnitTestHelper.IsSuccess(await mgr.AccessFailedAsync(user.Id));
Assert.False(await mgr.IsLockedOutAsync(user.Id));
Assert.False(await mgr.GetLockoutEndDateAsync(user.Id) > DateTimeOffset.UtcNow.AddMinutes(55));
Assert.Equal(1, await mgr.GetAccessFailedCountAsync(user.Id));
}
public void GetUserClaimSyncTest()
{
var db = UnitTestHelper.CreateDefaultDb();
var manager = new UserManager <IdentityUser>(new UserStore <IdentityUser>(db));
var user = new IdentityUser("u1");
var result = manager.Create(user);
UnitTestHelper.IsSuccess(result);
Assert.NotNull(user);
var claims = new[]
{
new Claim("c1", "v1"),
new Claim("c2", "v2"),
new Claim("c3", "v3")
};
foreach (Claim c in claims)
{
UnitTestHelper.IsSuccess(manager.AddClaim(user.Id, c));
}
var userClaims = new List <Claim>(manager.GetClaims(user.Id));
Assert.Equal(3, userClaims.Count);
foreach (Claim c in claims)
{
Assert.True(userClaims.Exists(u => u.Type == c.Type && u.Value == c.Value));
}
}
public async Task OnValidateIdentityDoesNotRejectRightAwayTest()
{
var owinContext = new OwinContext();
await CreateManager(owinContext);
var manager = owinContext.GetUserManager <UserManager <IdentityUser> >();
var user = new IdentityUser("test");
UnitTestHelper.IsSuccess(await manager.CreateAsync(user));
var id = await SignIn(manager, user);
var ticket = new AuthenticationTicket(id, new AuthenticationProperties {
IssuedUtc = DateTimeOffset.UtcNow
});
var context = new CookieValidateIdentityContext(owinContext, ticket, new CookieAuthenticationOptions());
// change stamp does not fail validation when not enough time elapsed
UnitTestHelper.IsSuccess(await manager.UpdateSecurityStampAsync(user.Id));
await
SecurityStampValidator.OnValidateIdentity <UserManager <IdentityUser>, IdentityUser>(
TimeSpan.FromDays(1), SignIn).Invoke(context);
Assert.NotNull(context.Identity);
Assert.Equal(user.Id, id.GetUserId());
}
public async Task CreateUserAddRemoveLoginTest()
{
var manager = CreateManager();
var user = new InMemoryUser("CreateUserAddRemoveLoginTest");
var login = new UserLoginInfo("Provider", "key");
const string password = "******";
var result = await manager.CreateAsync(user, password);
Assert.NotNull(user);
UnitTestHelper.IsSuccess(result);
UnitTestHelper.IsSuccess(await manager.AddLoginAsync(user.Id, login));
Assert.Equal(user, await manager.FindAsync(login));
var logins = await manager.GetLoginsAsync(user.Id);
Assert.NotNull(logins);
Assert.Equal(1, logins.Count());
Assert.Equal(login.LoginProvider, logins.Last().LoginProvider);
Assert.Equal(login.ProviderKey, logins.Last().ProviderKey);
var stamp = user.SecurityStamp;
UnitTestHelper.IsSuccess(await manager.RemoveLoginAsync(user.Id, login));
Assert.Null(await manager.FindAsync(login));
logins = await manager.GetLoginsAsync(user.Id);
Assert.NotNull(logins);
Assert.Equal(0, logins.Count());
Assert.NotEqual(stamp, user.SecurityStamp);
}
public void RemoveUserFromRoleSyncTest()
{
var db = UnitTestHelper.CreateDefaultDb();
var store = new UserManager <IdentityUser>(new UserStore <IdentityUser>(db));
var roleManager =
new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(UnitTestHelper.CreateDefaultDb()));
IdentityUser[] users =
{
new IdentityUser("1"), new IdentityUser("2"), new IdentityUser("3"),
new IdentityUser("4")
};
foreach (var u in users)
{
UnitTestHelper.IsSuccess(store.Create(u, "password"));
}
var r = new IdentityRole("r1");
UnitTestHelper.IsSuccess(roleManager.Create(r));
foreach (var u in users)
{
UnitTestHelper.IsSuccess(store.AddToRole(u.Id, r.Name));
Assert.True(store.IsInRole(u.Id, r.Name));
}
foreach (var u in users)
{
UnitTestHelper.IsSuccess(store.RemoveFromRole(u.Id, r.Name));
Assert.False(store.IsInRole(u.Id, r.Name));
}
Assert.Equal(0, db.Set <IdentityUserRole>().Count());
Clear(db);
}
public async Task QuerableRolesTest()
{
var db = UnitTestHelper.CreateDefaultDb();
var manager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(db));
//string[] users = { "u1", "u2", "u3", "u4" };
IdentityRole[] roles =
{
new IdentityRole("r1"), new IdentityRole("r2"), new IdentityRole("r3"),
new IdentityRole("r4")
};
//foreach (var u in users) {
// UnitTestHelper.IsSuccess(await store.CreateAsync(u, "password"));
//}
foreach (IdentityRole r in roles)
{
UnitTestHelper.IsSuccess(await manager.CreateAsync(r));
//foreach (var u in users) {
// UnitTestHelper.IsSuccess(await store.Roles.AddUserToRoleAsync(u, r.Name));
// Assert.True(await store.Roles.IsUserInRoleAsync(u, r.Name));
//}
}
Assert.Equal(roles.Length, manager.Roles.Count());
var r1 = manager.Roles.FirstOrDefault(r => r.Name == "r1");
Assert.Equal(roles[0], r1);
}
public async Task AddRemoveUserClaimTest()
{
var manager = CreateManager();
var user = new InMemoryUser("ClaimsAddRemove");
UnitTestHelper.IsSuccess(await manager.CreateAsync(user));
Claim[] claims = { new Claim("c", "v"), new Claim("c2", "v2"), new Claim("c2", "v3") };
foreach (Claim c in claims)
{
UnitTestHelper.IsSuccess(await manager.AddClaimAsync(user.Id, c));
}
var userClaims = await manager.GetClaimsAsync(user.Id);
Assert.Equal(3, userClaims.Count);
UnitTestHelper.IsSuccess(await manager.RemoveClaimAsync(user.Id, claims[0]));
userClaims = await manager.GetClaimsAsync(user.Id);
Assert.Equal(2, userClaims.Count);
UnitTestHelper.IsSuccess(await manager.RemoveClaimAsync(user.Id, claims[1]));
userClaims = await manager.GetClaimsAsync(user.Id);
Assert.Equal(1, userClaims.Count);
UnitTestHelper.IsSuccess(await manager.RemoveClaimAsync(user.Id, claims[2]));
userClaims = await manager.GetClaimsAsync(user.Id);
Assert.Equal(0, userClaims.Count);
}
public async Task RemoveUserFromRoleWithMultipleRoles()
{
var db = UnitTestHelper.CreateDefaultDb();
var userManager = new UserManager <IdentityUser>(new UserStore <IdentityUser>(db));
var roleManager =
new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(UnitTestHelper.CreateDefaultDb()));
var user = new IdentityUser("MultiRoleUser");
UnitTestHelper.IsSuccess(await userManager.CreateAsync(user));
IdentityRole[] roles =
{
new IdentityRole("r1"), new IdentityRole("r2"), new IdentityRole("r3"),
new IdentityRole("r4")
};
foreach (var r in roles)
{
UnitTestHelper.IsSuccess(await roleManager.CreateAsync(r));
UnitTestHelper.IsSuccess(await userManager.AddToRoleAsync(user.Id, r.Name));
Assert.Equal(1, user.Roles.Count(ur => ur.RoleId == r.Id));
Assert.True(await userManager.IsInRoleAsync(user.Id, r.Name));
}
UnitTestHelper.IsSuccess(await userManager.RemoveFromRoleAsync(user.Id, roles[2].Name));
Assert.Equal(0, user.Roles.Count(ur => ur.RoleId == roles[2].Id));
Assert.False(await userManager.IsInRoleAsync(user.Id, roles[2].Name));
Clear(db);
}
public async Task RemoveUserFromRoleTest()
{
var db = UnitTestHelper.CreateDefaultDb();
var userManager = new UserManager <IdentityUser>(new UserStore <IdentityUser>(db));
var roleManager =
new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(UnitTestHelper.CreateDefaultDb()));
IdentityUser[] users =
{
new IdentityUser("1"), new IdentityUser("2"), new IdentityUser("3"),
new IdentityUser("4")
};
foreach (var u in users)
{
UnitTestHelper.IsSuccess(await userManager.CreateAsync(u, "password"));
}
var r = new IdentityRole("r1");
UnitTestHelper.IsSuccess(await roleManager.CreateAsync(r));
foreach (var u in users)
{
UnitTestHelper.IsSuccess(await userManager.AddToRoleAsync(u.Id, r.Name));
Assert.True(await userManager.IsInRoleAsync(u.Id, r.Name));
}
foreach (var u in users)
{
UnitTestHelper.IsSuccess(await userManager.RemoveFromRoleAsync(u.Id, r.Name));
Assert.Equal(0, u.Roles.Count(ur => ur.RoleId == r.Id));
Assert.False(await userManager.IsInRoleAsync(u.Id, r.Name));
}
Assert.Equal(0, db.Set <IdentityUserRole>().Count());
Clear(db);
}
public async Task CustomUserIntKeyTest()
{
Database.SetInitializer(new DropCreateDatabaseAlways <CustomUserContext>());
var db = new CustomUserContext();
db.Database.Initialize(true);
var manager = new UserManager <CustomUser, int>(new CustomUserStore(db));
CustomUser[] users =
{
new CustomUser {
UserName = "******"
},
new CustomUser {
UserName = "******"
},
new CustomUser {
UserName = "******"
},
new CustomUser {
UserName = "******"
}
};
foreach (CustomUser user in users)
{
UnitTestHelper.IsSuccess(await manager.CreateAsync(user));
}
foreach (CustomUser user in users)
{
var u = await manager.FindByIdAsync(user.Id);
Assert.NotNull(u);
Assert.Equal(u.UserName, user.UserName);
}
}
public async Task ApplicationUserCreateTest()
{
var owinContext = new OwinContext();
await CreateManager(owinContext);
var manager = owinContext.GetUserManager <ApplicationUserManager>();
ApplicationUser[] users =
{
new ApplicationUser {
UserName = "******", Email = "*****@*****.**"
},
new ApplicationUser {
UserName = "******", Email = "*****@*****.**"
},
new ApplicationUser {
UserName = "******", Email = "*****@*****.**"
},
new ApplicationUser {
UserName = "******", Email = "*****@*****.**"
}
};
foreach (ApplicationUser user in users)
{
UnitTestHelper.IsSuccess(await manager.CreateAsync(user));
}
foreach (ApplicationUser user in users)
{
var u = await manager.FindByIdAsync(user.Id);
Assert.NotNull(u);
Assert.Equal(u.UserName, user.UserName);
}
}
public async Task OnValidateIdentityResetsContextPropertiesDatesTest()
{
// Arrange
var owinContext = new OwinContext();
await CreateManager(owinContext);
var manager = owinContext.GetUserManager <UserManager <IdentityUser> >();
var user = new IdentityUser(string.Format("{0}{1}", "test", new Random().Next()));
UnitTestHelper.IsSuccess(await manager.CreateAsync(user));
var id = await SignIn(manager, user);
var ticket = new AuthenticationTicket(id, new AuthenticationProperties {
IssuedUtc = DateTimeOffset.UtcNow, ExpiresUtc = DateTimeOffset.UtcNow.Add(TimeSpan.FromHours(1)), IsPersistent = true
});
var context = new CookieValidateIdentityContext(owinContext, ticket, new CookieAuthenticationOptions());
await
SecurityStampValidator.OnValidateIdentity <UserManager <IdentityUser>, IdentityUser>(
TimeSpan.Zero, SignIn).Invoke(context);
// Assert
Assert.NotNull(context.Identity);
Assert.NotNull(context.Properties);
Assert.Null(context.Properties.IssuedUtc);
Assert.Null(context.Properties.ExpiresUtc);
Assert.True(context.Properties.IsPersistent);
}
public async Task RemoveUserFromRoleTest()
{
var userManager = CreateManager();
var roleManager = CreateRoleManager();
InMemoryUser[] users =
{
new InMemoryUser("1"), new InMemoryUser("2"), new InMemoryUser("3"),
new InMemoryUser("4")
};
foreach (var u in users)
{
UnitTestHelper.IsSuccess(await userManager.CreateAsync(u, "password"));
}
var r = new InMemoryRole("r1");
UnitTestHelper.IsSuccess(await roleManager.CreateAsync(r));
foreach (var u in users)
{
UnitTestHelper.IsSuccess(await userManager.AddToRoleAsync(u.Id, r.Name));
Assert.True(await userManager.IsInRoleAsync(u.Id, r.Name));
}
foreach (var u in users)
{
UnitTestHelper.IsSuccess(await userManager.RemoveFromRoleAsync(u.Id, r.Name));
Assert.False(await userManager.IsInRoleAsync(u.Id, r.Name));
}
}
public async Task OnValidateIdentityRejectsWithNoIssuedUtcTest()
{
var owinContext = new OwinContext();
await CreateManager(owinContext);
var manager = owinContext.GetUserManager <UserManager <IdentityUser> >();
var user = new IdentityUser("test");
UnitTestHelper.IsSuccess(await manager.CreateAsync(user));
var id = await SignIn(manager, user);
var ticket = new AuthenticationTicket(id, new AuthenticationProperties());
var context = new CookieValidateIdentityContext(owinContext, ticket, new CookieAuthenticationOptions());
await
SecurityStampValidator.OnValidateIdentity <UserManager <IdentityUser>, IdentityUser>(TimeSpan.Zero, SignIn)
.Invoke(context);
Assert.NotNull(context.Identity);
Assert.Equal(user.Id, id.GetUserId());
// change stamp does fail validation when no utc
UnitTestHelper.IsSuccess(await manager.UpdateSecurityStampAsync(user.Id));
await
SecurityStampValidator.OnValidateIdentity <UserManager <IdentityUser>, IdentityUser>(TimeSpan.Zero, SignIn)
.Invoke(context);
Assert.Null(context.Identity);
}
public void ResetLockoutSync()
{
var mgr = CreateManager();
mgr.DefaultAccountLockoutTimeSpan = TimeSpan.FromHours(1);
mgr.UserLockoutEnabledByDefault = true;
mgr.MaxFailedAccessAttemptsBeforeLockout = 2;
var user = new InMemoryUser("resetLockout");
UnitTestHelper.IsSuccess(mgr.Create(user));
Assert.True(mgr.GetLockoutEnabled(user.Id));
Assert.True(user.LockoutEnabled);
Assert.False(mgr.IsLockedOut(user.Id));
UnitTestHelper.IsSuccess(mgr.AccessFailed(user.Id));
Assert.False(mgr.IsLockedOut(user.Id));
Assert.False(mgr.GetLockoutEndDate(user.Id) > DateTimeOffset.UtcNow.AddMinutes(55));
Assert.Equal(1, mgr.GetAccessFailedCount(user.Id));
UnitTestHelper.IsSuccess(mgr.ResetAccessFailedCount(user.Id));
Assert.Equal(0, mgr.GetAccessFailedCount(user.Id));
Assert.False(mgr.IsLockedOut(user.Id));
Assert.False(mgr.GetLockoutEndDate(user.Id) > DateTimeOffset.UtcNow.AddMinutes(55));
UnitTestHelper.IsSuccess(mgr.AccessFailed(user.Id));
Assert.False(mgr.IsLockedOut(user.Id));
Assert.False(mgr.GetLockoutEndDate(user.Id) > DateTimeOffset.UtcNow.AddMinutes(55));
Assert.Equal(1, mgr.GetAccessFailedCount(user.Id));
}
public async Task LinkUnlinkDeletesTest()
{
var db = UnitTestHelper.CreateDefaultDb();
var mgr = new UserManager <IdentityUser>(new UserStore <IdentityUser>(db));
var user = new IdentityUser("linkunlinktest");
UnitTestHelper.IsSuccess(await mgr.CreateAsync(user));
var userLogin1 = new UserLoginInfo("provider1", "p1-1");
var userLogin2 = new UserLoginInfo("provider2", "p2-1");
Assert.Empty((await mgr.GetLoginsAsync(user.Id)));
UnitTestHelper.IsSuccess(await mgr.AddLoginAsync(user.Id, userLogin1));
Assert.Single(user.Logins.Where(l => l.ProviderKey == "p1-1"));
Assert.Single((await mgr.GetLoginsAsync(user.Id)));
UnitTestHelper.IsSuccess(await mgr.AddLoginAsync(user.Id, userLogin2));
Assert.Single(user.Logins.Where(l => l.ProviderKey == "p2-1"));
Assert.Equal(2, (await mgr.GetLoginsAsync(user.Id)).Count);
UnitTestHelper.IsSuccess(await mgr.RemoveLoginAsync(user.Id, userLogin1));
Assert.Empty(user.Logins.Where(l => l.ProviderKey == "p1-1"));
Assert.Single(user.Logins.Where(l => l.ProviderKey == "p2-1"));
Assert.Single((await mgr.GetLoginsAsync(user.Id)));
UnitTestHelper.IsSuccess(await mgr.RemoveLoginAsync(user.Id, userLogin2));
Assert.Empty((await mgr.GetLoginsAsync(user.Id)));
Assert.Empty(db.Set <IdentityUserLogin>());
}
public async Task CustomGuidGetRolesForUserTest()
{
var db = GuidUserContext.Create();
var userManager = new UserManager <GuidUser, Guid>(new GuidUserStore(db));
var roleManager = new RoleManager <GuidRole, Guid>(new GuidRoleStore(db));
GuidUser[] users = { new GuidUser("u1"), new GuidUser("u2"), new GuidUser("u3"), new GuidUser("u4") };
GuidRole[] roles = { new GuidRole("r1"), new GuidRole("r2"), new GuidRole("r3"), new GuidRole("r4") };
foreach (GuidUser u in users)
{
UnitTestHelper.IsSuccess(await userManager.CreateAsync(u));
}
foreach (GuidRole r in roles)
{
UnitTestHelper.IsSuccess(await roleManager.CreateAsync(r));
foreach (GuidUser u in users)
{
UnitTestHelper.IsSuccess(await userManager.AddToRoleAsync(u.Id, r.Name));
Assert.True(await userManager.IsInRoleAsync(u.Id, r.Name));
}
Assert.Equal(users.Length, r.Users.Count());
}
foreach (GuidUser u in users)
{
var rs = await userManager.GetRolesAsync(u.Id);
Assert.Equal(roles.Length, rs.Count);
foreach (GuidRole r in roles)
{
Assert.True(rs.Any(role => role == r.Name));
}
}
}
public async Task CustomUserGuidKeyTest()
{
var manager = new UserManager <GuidUser, Guid>(new GuidUserStore(GuidUserContext.Create()));
GuidUser[] users =
{
new GuidUser {
UserName = "******"
},
new GuidUser {
UserName = "******"
},
new GuidUser {
UserName = "******"
},
new GuidUser {
UserName = "******"
}
};
foreach (GuidUser user in users)
{
UnitTestHelper.IsSuccess(await manager.CreateAsync(user));
}
foreach (GuidUser user in users)
{
var u = await manager.FindByIdAsync(user.Id);
Assert.NotNull(u);
Assert.Equal(u.UserName, user.UserName);
}
}
public async Task OnValidateIdentityWithGuidTest()
{
var owinContext = new OwinContext();
await CreateManager(owinContext);
var manager = owinContext.GetUserManager <UserManager <GuidUser, Guid> >();
var user = new GuidUser {
UserName = "******"
};
UnitTestHelper.IsSuccess(await manager.CreateAsync(user));
var id = await SignIn(manager, user);
var ticket = new AuthenticationTicket(id, new AuthenticationProperties {
IssuedUtc = DateTimeOffset.UtcNow
});
var context = new CookieValidateIdentityContext(owinContext, ticket, new CookieAuthenticationOptions());
await
SecurityStampValidator.OnValidateIdentity <UserManager <GuidUser, Guid>, GuidUser, Guid>(TimeSpan.Zero,
SignIn, claimId => new Guid(claimId.GetUserId())).Invoke(context);
Assert.NotNull(context.Identity);
Assert.Equal(user.Id.ToString(), id.GetUserId());
// change stamp and make sure it fails
UnitTestHelper.IsSuccess(await manager.UpdateSecurityStampAsync(user.Id));
await
SecurityStampValidator.OnValidateIdentity <UserManager <GuidUser, Guid>, GuidUser, Guid>(TimeSpan.Zero,
SignIn, claimId => new Guid(claimId.GetUserId())).Invoke(context);
Assert.Null(context.Identity);
}
public async Task FindRoleWithManagerTest()
{
var roleMgr = CreateRoleManager();
var role = new InMemoryRole("findRoleTest");
UnitTestHelper.IsSuccess(await roleMgr.CreateAsync(role));
Assert.Equal(role.Name, (await roleMgr.FindByIdAsync(role.Id)).Name);
}
public async Task RoleFindByIdTest()
{
var manager = CreateRoleManager();
var role = new InMemoryRole("FindById");
Assert.Null(await manager.FindByIdAsync(role.Id));
UnitTestHelper.IsSuccess(await manager.CreateAsync(role));
Assert.Equal(role, await manager.FindByIdAsync(role.Id));
}
public async Task CreateRoleTest()
{
var manager = CreateRoleManager();
var role = new InMemoryRole("create");
Assert.False(await manager.RoleExistsAsync(role.Name));
UnitTestHelper.IsSuccess(await manager.CreateAsync(role));
Assert.True(await manager.RoleExistsAsync(role.Name));
}
public async Task AddToBogusRolesFails()
{
var db = UnitTestHelper.CreateDefaultDb();
var userManager = new UserManager <IdentityUser>(new UserStore <IdentityUser>(db));
var user = new IdentityUser("1");
UnitTestHelper.IsSuccess(await userManager.CreateAsync(user));
Assert.Throws <InvalidOperationException>(() => userManager.AddToRoles(user.Id, "bogus"));
}
public async Task DeleteUserTest()
{
var manager = CreateManager();
var user = new InMemoryUser("Delete");
UnitTestHelper.IsSuccess(await manager.CreateAsync(user));
UnitTestHelper.IsSuccess(await manager.DeleteAsync(user));
Assert.Null(await manager.FindByIdAsync(user.Id));
}
public async Task FindRoleWithManagerTest()
{
var db = UnitTestHelper.CreateDefaultDb();
var roleMgr = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(db));
var role = new IdentityRole("findRoleTest");
UnitTestHelper.IsSuccess(await roleMgr.CreateAsync(role));
Assert.Equal(role.Name, (await roleMgr.FindByIdAsync(role.Id)).Name);
}
public void RoleFindByNameSyncTest()
{
var manager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(UnitTestHelper.CreateDefaultDb()));
var role = new IdentityRole("FindByName");
Assert.False(manager.RoleExists(role.Name));
UnitTestHelper.IsSuccess(manager.Create(role));
Assert.Equal(role, manager.FindByName(role.Name));
}
public async Task RemoveUserFromBogusRolesFails()
{
var db = UnitTestHelper.CreateDefaultDb();
var userManager = new UserManager <IdentityUser>(new UserStore <IdentityUser>(db));
var user = new IdentityUser("1");
UnitTestHelper.IsSuccess(await userManager.CreateAsync(user));
UnitTestHelper.IsFailure(await userManager.RemoveFromRolesAsync(user.Id, "bogus"), "User is not in role.");
}
public async Task AddDupeUserFailsTest()
{
var manager = CreateManager();
var user = new InMemoryUser("dupe");
var user2 = new InMemoryUser("dupe");
UnitTestHelper.IsSuccess(await manager.CreateAsync(user));
UnitTestHelper.IsFailure(await manager.CreateAsync(user2), "Name dupe is already taken.");
}
public void RoleFindByIdSyncTest()
{
var manager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(UnitTestHelper.CreateDefaultDb()));
var role = new IdentityRole("FindById");
Assert.Null(manager.FindById(role.Id));
UnitTestHelper.IsSuccess(manager.Create(role));
Assert.Equal(role, manager.FindById(role.Id));
}
