public async Task UserLockedOutWithDateTimeNowPlus30()
{
var db = UnitTestHelper.CreateDefaultDb();
var mgr = TestUtil.CreateManager(db);
mgr.UserLockoutEnabledByDefault = true;
var user = new IdentityUser("LockoutTest");
UnitTestHelper.IsSuccess(mgr.Create(user));
Assert.True(mgr.GetLockoutEnabled(user.Id));
Assert.True(user.LockoutEnabled);
var lockoutEnd = new DateTimeOffset(DateTime.Now.AddMinutes(30));
UnitTestHelper.IsSuccess(await mgr.SetLockoutEndDateAsync(user.Id, lockoutEnd));
// Create a new db to ensure the user entities are recreated
db = new IdentityDbContext();
mgr = TestUtil.CreateManager(db);
Assert.True(await mgr.IsLockedOutAsync(user.Id));
var end = await mgr.GetLockoutEndDateAsync(user.Id);
Assert.True(lockoutEnd.Subtract(end) < TimeSpan.FromSeconds(1)); // Conversions are slightly lossy
}
public async Task GetAllUsersTest()
{
var db = UnitTestHelper.CreateDefaultDb();
var store = new UserStore <IdentityUser>(db);
var users = new[]
{
new IdentityUser("user1"),
new IdentityUser("user2"),
new IdentityUser("user3")
};
foreach (IdentityUser u in users)
{
await store.CreateAsync(u);
}
IQueryable <IUser> usersQ = store.Users;
Assert.Equal(3, usersQ.Count());
Assert.NotNull(usersQ.Where(u => u.UserName == "user1").FirstOrDefault());
Assert.NotNull(usersQ.Where(u => u.UserName == "user2").FirstOrDefault());
Assert.NotNull(usersQ.Where(u => u.UserName == "user3").FirstOrDefault());
Assert.Null(usersQ.Where(u => u.UserName == "bogus").FirstOrDefault());
}
public async Task OnValidateRejectsUnknownUserIdentityTest()
{
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);
UnitTestHelper.IsSuccess(await manager.DeleteAsync(user));
var ticket = new AuthenticationTicket(id, new AuthenticationProperties {
IssuedUtc = DateTimeOffset.UtcNow
});
var context = new CookieValidateIdentityContext(owinContext, ticket, new CookieAuthenticationOptions());
await
SecurityStampValidator.OnValidateIdentity <UserManager <IdentityUser>, IdentityUser>(TimeSpan.Zero, SignIn)
.Invoke(context);
Assert.Null(context.Identity);
}
public async Task CustomGuidEmailTokenFactorWithFormatTest()
{
var owinContext = new OwinContext();
await CreateManager(owinContext);
var manager = owinContext.GetUserManager <UserManager <GuidUser, Guid> >();
var messageService = new TestMessageService();
manager.EmailService = messageService;
var factorId = "EmailCode";
manager.RegisterTwoFactorProvider(factorId, new EmailTokenProvider <GuidUser, Guid>
{
Subject = "Security Code",
BodyFormat = "Your code is: {0}"
});
var user = new GuidUser("EmailCodeTest");
user.Email = "*****@*****.**";
var password = "******";
UnitTestHelper.IsSuccess(await manager.CreateAsync(user, password));
var stamp = user.SecurityStamp;
Assert.NotNull(stamp);
var token = await manager.GenerateTwoFactorTokenAsync(user.Id, factorId);
Assert.NotNull(token);
Assert.Null(messageService.Message);
await manager.NotifyTwoFactorTokenAsync(user.Id, factorId, token);
Assert.NotNull(messageService.Message);
Assert.Equal("Security Code", messageService.Message.Subject);
Assert.Equal("Your code is: " + token, messageService.Message.Body);
Assert.True(await manager.VerifyTwoFactorTokenAsync(user.Id, factorId, token));
}
public void RemoveUserFromRolesSync()
{
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("1");
IdentityRole[] roles =
{
new IdentityRole("r1"), new IdentityRole("r2"), new IdentityRole("r3"),
new IdentityRole("r4")
};
foreach (var r in roles)
{
UnitTestHelper.IsSuccess(roleManager.Create(r));
}
UnitTestHelper.IsSuccess(userManager.Create(user));
UnitTestHelper.IsSuccess(userManager.AddToRoles(user.Id, roles.Select(ro => ro.Name).ToArray()));
Assert.Equal(roles.Count(), db.Set <IdentityUserRole>().Count());
Assert.True(userManager.IsInRole(user.Id, "r1"));
Assert.True(userManager.IsInRole(user.Id, "r2"));
Assert.True(userManager.IsInRole(user.Id, "r3"));
Assert.True(userManager.IsInRole(user.Id, "r4"));
var rs = userManager.GetRoles(user.Id);
UnitTestHelper.IsSuccess(userManager.RemoveFromRoles(user.Id, "r1", "r3"));
rs = userManager.GetRoles(user.Id);
Assert.False(userManager.IsInRole(user.Id, "r1"));
Assert.False(userManager.IsInRole(user.Id, "r3"));
Assert.True(userManager.IsInRole(user.Id, "r2"));
Assert.True(userManager.IsInRole(user.Id, "r4"));
UnitTestHelper.IsSuccess(userManager.RemoveFromRoles(user.Id, "r2", "r4"));
Assert.False(userManager.IsInRole(user.Id, "r2"));
Assert.False(userManager.IsInRole(user.Id, "r4"));
Assert.Equal(0, db.Set <IdentityUserRole>().Count());
}
public void EnableLockoutManuallySync()
{
var mgr = CreateManager();
mgr.DefaultAccountLockoutTimeSpan = TimeSpan.FromHours(1);
mgr.MaxFailedAccessAttemptsBeforeLockout = 2;
var user = new InMemoryUser("manualLockout");
UnitTestHelper.IsSuccess(mgr.Create(user));
Assert.False(mgr.GetLockoutEnabled(user.Id));
Assert.False(user.LockoutEnabled);
UnitTestHelper.IsSuccess(mgr.SetLockoutEnabled(user.Id, true));
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.AccessFailed(user.Id));
Assert.True(mgr.IsLockedOut(user.Id));
Assert.True(mgr.GetLockoutEndDate(user.Id) > DateTimeOffset.UtcNow.AddMinutes(55));
Assert.Equal(0, mgr.GetAccessFailedCount(user.Id));
}
public void AddRemoveUserClaimSyncTest()
{
var manager = CreateManager();
var user = new InMemoryUser("ClaimsAddRemove");
UnitTestHelper.IsSuccess(manager.Create(user));
Claim[] claims = { new Claim("c", "v"), new Claim("c2", "v2"), new Claim("c2", "v3") };
foreach (Claim c in claims)
{
UnitTestHelper.IsSuccess(manager.AddClaim(user.Id, c));
}
var userClaims = manager.GetClaims(user.Id);
Assert.Equal(3, userClaims.Count);
UnitTestHelper.IsSuccess(manager.RemoveClaim(user.Id, claims[0]));
userClaims = manager.GetClaims(user.Id);
Assert.Equal(2, userClaims.Count);
UnitTestHelper.IsSuccess(manager.RemoveClaim(user.Id, claims[1]));
userClaims = manager.GetClaims(user.Id);
Assert.Equal(1, userClaims.Count);
UnitTestHelper.IsSuccess(manager.RemoveClaim(user.Id, claims[2]));
userClaims = manager.GetClaims(user.Id);
Assert.Equal(0, userClaims.Count);
}
public async Task EnableLockoutManually()
{
var mgr = TestUtil.CreateManager();
mgr.DefaultAccountLockoutTimeSpan = TimeSpan.FromHours(1);
mgr.MaxFailedAccessAttemptsBeforeLockout = 2;
var user = new IdentityUser("manualLockout");
UnitTestHelper.IsSuccess(await mgr.CreateAsync(user));
Assert.False(await mgr.GetLockoutEnabledAsync(user.Id));
Assert.False(user.LockoutEnabled);
UnitTestHelper.IsSuccess(await mgr.SetLockoutEnabledAsync(user.Id, true));
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.AccessFailedAsync(user.Id));
Assert.True(await mgr.IsLockedOutAsync(user.Id));
Assert.True(await mgr.GetLockoutEndDateAsync(user.Id) > DateTimeOffset.UtcNow.AddMinutes(55));
Assert.Equal(0, await mgr.GetAccessFailedCountAsync(user.Id));
}
public async Task AddUserToRoleTest()
{
var db = UnitTestHelper.CreateDefaultDb();
var manager = new UserManager <IdentityUser>(new UserStore <IdentityUser>(db));
var roleManager =
new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(UnitTestHelper.CreateDefaultDb()));
var role = new IdentityRole("addUserTest");
UnitTestHelper.IsSuccess(await roleManager.CreateAsync(role));
IdentityUser[] users =
{
new IdentityUser("1"), new IdentityUser("2"), new IdentityUser("3"),
new IdentityUser("4")
};
foreach (IdentityUser u in users)
{
UnitTestHelper.IsSuccess(await manager.CreateAsync(u));
UnitTestHelper.IsSuccess(await manager.AddToRoleAsync(u.Id, role.Name));
Assert.Equal(1, u.Roles.Count(ur => ur.RoleId == role.Id));
Assert.True(await manager.IsInRoleAsync(u.Id, role.Name));
}
Clear(db);
}
public async Task MixedRequiredTest()
{
var alphaError = "Passwords must have at least one non letter or digit character.";
var upperError = "Passwords must have at least one uppercase ('A'-'Z').";
var lowerError = "Passwords must have at least one lowercase ('a'-'z').";
var digitError = "Passwords must have at least one digit ('0'-'9').";
var lengthError = "Passwords must be at least 6 characters.";
var valid = new PasswordValidator
{
RequireNonLetterOrDigit = true,
RequireDigit = true,
RequireLowercase = true,
RequireUppercase = true,
RequiredLength = 6
};
UnitTestHelper.IsFailure(await valid.ValidateAsync("abcde"),
string.Join(" ", lengthError, alphaError, digitError, upperError));
UnitTestHelper.IsFailure(await valid.ValidateAsync("a@B@cd"), digitError);
UnitTestHelper.IsFailure(await valid.ValidateAsync("___"),
string.Join(" ", lengthError, digitError, lowerError, upperError));
UnitTestHelper.IsFailure(await valid.ValidateAsync("a_b9de"), upperError);
UnitTestHelper.IsSuccess(await valid.ValidateAsync("abcd@e!ld!kaj9Fd"));
}
public static UserManager <IdentityUser> CreateManager()
{
return(CreateManager(UnitTestHelper.CreateDefaultDb()));
}
public async Task DeleteRoleUnknownFailsTest()
{
var manager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(UnitTestHelper.CreateDefaultDb()));
var role = new IdentityRole("bogus");
Assert.False(await manager.RoleExistsAsync(role.Name));
Assert.Throws <InvalidOperationException>(() => AsyncHelper.RunSync(() => manager.DeleteAsync(role)));
}
public async Task RoleFindByNameTest()
{
var db = UnitTestHelper.CreateDefaultDb();
var manager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(UnitTestHelper.CreateDefaultDb()));
var role = new IdentityRole("FindByName");
Assert.Null(await manager.FindByNameAsync(role.Name));
Assert.False(await manager.RoleExistsAsync(role.Name));
UnitTestHelper.IsSuccess(await manager.CreateAsync(role));
Assert.Equal(role, await manager.FindByNameAsync(role.Name));
Clear(db);
}
public void DeleteFailWithUnknownRoleTest()
{
var manager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(UnitTestHelper.CreateDefaultDb()));
Assert.Throws <InvalidOperationException>(
() => AsyncHelper.RunSync(() => manager.DeleteAsync(new IdentityRole("bogus"))));
}
public void DeleteRoleSyncTest()
{
var manager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(UnitTestHelper.CreateDefaultDb()));
var role = new IdentityRole("delete");
Assert.False(manager.RoleExists(role.Name));
UnitTestHelper.IsSuccess(manager.Create(role));
UnitTestHelper.IsSuccess(manager.Delete(role));
Assert.False(manager.RoleExists(role.Name));
}
public async Task DeleteRoleTest()
{
var manager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(UnitTestHelper.CreateDefaultDb()));
var role = new IdentityRole("delete");
Assert.False(await manager.RoleExistsAsync(role.Name));
UnitTestHelper.IsSuccess(await manager.CreateAsync(role));
UnitTestHelper.IsSuccess(await manager.DeleteAsync(role));
Assert.False(await manager.RoleExistsAsync(role.Name));
}
public async Task RoleFindByIdTest()
{
var manager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(UnitTestHelper.CreateDefaultDb()));
var role = new IdentityRole("FindById");
Assert.Null(await manager.FindByIdAsync(role.Id));
UnitTestHelper.IsSuccess(await manager.CreateAsync(role));
Assert.Equal(role, await manager.FindByIdAsync(role.Id));
}
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));
}
public async Task UnknownRoleThrowsTest()
{
var manager = new UserManager <IdentityUser>(new UserStore <IdentityUser>(UnitTestHelper.CreateDefaultDb()));
var u = new IdentityUser("u1");
UnitTestHelper.IsSuccess(await manager.CreateAsync(u));
Assert.Throws <InvalidOperationException>(
() => AsyncHelper.RunSync(() => manager.AddToRoleAsync(u.Id, "bogus")));
// CONSIDER: should these other methods also throw if role doesn't exist?
//ExceptionHelper.ExpectException<InvalidOperationException>(() => AsyncHelper.RunSync(() => manager.RemoveFromRoleAsync(u.Id, "bogus")));
//ExceptionHelper.ExpectException<InvalidOperationException>(() => AsyncHelper.RunSync(() => manager.IsInRoleAsync(u.Id, "whatever")));
}
public async Task UpdateRoleNameTest()
{
var manager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(UnitTestHelper.CreateDefaultDb()));
var role = new IdentityRole("update");
Assert.False(await manager.RoleExistsAsync(role.Name));
UnitTestHelper.IsSuccess(await manager.CreateAsync(role));
Assert.True(await manager.RoleExistsAsync(role.Name));
role.Name = "Changed";
UnitTestHelper.IsSuccess(await manager.UpdateAsync(role));
Assert.False(await manager.RoleExistsAsync("update"));
Assert.Equal(role, await manager.FindByNameAsync(role.Name));
}
public async Task CreateRoleFailsIfExistsTest()
{
var manager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(UnitTestHelper.CreateDefaultDb()));
var role = new IdentityRole("dupeRole");
Assert.False(await manager.RoleExistsAsync(role.Name));
UnitTestHelper.IsSuccess(await manager.CreateAsync(role));
Assert.True(await manager.RoleExistsAsync(role.Name));
var role2 = new IdentityRole("dupeRole");
UnitTestHelper.IsFailure(await manager.CreateAsync(role2));
}
public void UpdateRoleNameSyncTest()
{
var manager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(UnitTestHelper.CreateDefaultDb()));
var role = new IdentityRole("update");
Assert.False(manager.RoleExists(role.Name));
UnitTestHelper.IsSuccess(manager.Create(role));
Assert.True(manager.RoleExists(role.Name));
role.Name = "Changed";
UnitTestHelper.IsSuccess(manager.Update(role));
Assert.False(manager.RoleExists("update"));
Assert.Equal(role, manager.FindByName(role.Name));
}
