public async Task FindByEmailThrowsWithTwoUsersWithSameEmail()
{
var userStore = _builder.ApplicationServices.GetRequiredService <IUserStore <IdentityUser> >();
var manager = _builder.ApplicationServices.GetRequiredService <UserManager <IdentityUser> >();
Assert.NotNull(userStore);
Assert.NotNull(manager);
var userA = new IdentityUser(Guid.NewGuid().ToString());
userA.Email = "*****@*****.**";
const string password = "******";
IdentityResultAssert.IsSuccess(await manager.CreateAsync(userA, password));
var userB = new IdentityUser(Guid.NewGuid().ToString());
userB.Email = "*****@*****.**";
IdentityResultAssert.IsSuccess(await manager.CreateAsync(userB, password));
await Assert.ThrowsAsync <InvalidOperationException>(async() => await manager.FindByEmailAsync("*****@*****.**"));
}
public async Task EnsureStartupUsageWorks()
{
var context = CreateContext(true);
var builder = CreateBuilder();
var userStore = builder.ApplicationServices.GetRequiredService <IUserStore <IdentityUser> >();
var userManager = builder.ApplicationServices.GetRequiredService <UserManager <IdentityUser> >();
Assert.NotNull(userStore);
Assert.NotNull(userManager);
const string userName = "******";
const string password = "******";
var user = new IdentityUser {
UserName = userName
};
IdentityResultAssert.IsSuccess(await userManager.CreateAsync(user, password));
IdentityResultAssert.IsSuccess(await userManager.DeleteAsync(user));
}
public async Task CanIncludeUserRolesTest()
{
// Arrange
var userManager = _builder.ApplicationServices.GetRequiredService <UserManager <IdentityUser> >();
var roleManager = _builder.ApplicationServices.GetRequiredService <RoleManager <IdentityRole> >();
var dbContext = _builder.ApplicationServices.GetRequiredService <IdentityDbContext>();
const string roleName = "Admin";
for (var i = 0; i < 10; i++)
{
IdentityResultAssert.IsSuccess(await roleManager.CreateAsync(new IdentityRole(roleName + i)));
}
var username = "******" + new Random().Next();
var user = new IdentityUser()
{
UserName = username
};
IdentityResultAssert.IsSuccess(await userManager.CreateAsync(user));
for (var i = 0; i < 10; i++)
{
IdentityResultAssert.IsSuccess(await userManager.AddToRoleAsync(user, roleName + i));
}
user = dbContext.Users.Include(x => x.Roles).FirstOrDefault(x => x.UserName == username);
// Assert
Assert.NotNull(user);
Assert.NotNull(user.Roles);
Assert.Equal(10, user.Roles.Count());
for (var i = 0; i < 10; i++)
{
var role = dbContext.Roles.Include(r => r.Users).FirstOrDefault(r => r.Name == (roleName + i));
Assert.NotNull(role);
Assert.NotNull(role.Users);
Assert.Equal(1, role.Users.Count());
}
}
public async Task VerifyAccountControllerSignIn(bool isPersistent)
{
IBuilder app = new Builder.Builder(new ServiceCollection().BuildServiceProvider());
app.UseCookieAuthentication(new CookieAuthenticationOptions
{
AuthenticationType = ClaimsIdentityOptions.DefaultAuthenticationType
});
var context = new Mock <HttpContext>();
var response = new Mock <HttpResponse>();
context.Setup(c => c.Response).Returns(response.Object).Verifiable();
response.Setup(r => r.SignIn(It.IsAny <ClaimsIdentity>(), It.Is <AuthenticationProperties>(v => v.IsPersistent == isPersistent))).Verifiable();
var contextAccessor = new Mock <IContextAccessor <HttpContext> >();
contextAccessor.Setup(a => a.Value).Returns(context.Object);
app.UseServices(services =>
{
services.AddInstance(contextAccessor.Object);
services.AddIdentity <ApplicationUser, IdentityRole>().AddInMemory().AddAuthentication();
});
// Act
var user = new ApplicationUser
{
UserName = "******"
};
const string password = "******";
var userManager = app.ApplicationServices.GetService <UserManager <ApplicationUser> >();
var signInManager = app.ApplicationServices.GetService <SignInManager <ApplicationUser> >();
IdentityResultAssert.IsSuccess(await userManager.CreateAsync(user, password));
var result = await signInManager.PasswordSignInAsync(user.UserName, password, isPersistent, false);
// Assert
Assert.Equal(SignInStatus.Success, result);
context.VerifyAll();
response.VerifyAll();
contextAccessor.VerifyAll();
}
public async Task DeleteAModifiedRoleWillFail()
{
var role = new IdentityRole(Guid.NewGuid().ToString());
var factory = CreateContext();
var manager = CreateRoleManager(factory);
IdentityResultAssert.IsSuccess(await manager.CreateAsync(role));
var manager1 = CreateRoleManager(factory);
var manager2 = CreateRoleManager(factory);
var role1 = await manager1.FindByIdAsync(role.Id);
var role2 = await manager2.FindByIdAsync(role.Id);
Assert.NotNull(role1);
Assert.NotNull(role2);
Assert.NotSame(role1, role2);
role1.Name = Guid.NewGuid().ToString();
IdentityResultAssert.IsSuccess(await manager1.UpdateAsync(role1));
IdentityResultAssert.IsFailure(await manager2.DeleteAsync(role2),
new IdentityErrorDescriber().ConcurrencyFailure());
}
public async Task DeleteAModifiedUserWillFail()
{
var user = CreateTestUser();
var factory = CreateContext();
var manager = CreateManager(factory);
IdentityResultAssert.IsSuccess(await manager.CreateAsync(user));
var manager1 = CreateManager(factory);
var manager2 = CreateManager(factory);
var user1 = await manager1.FindByIdAsync(user.Id);
var user2 = await manager2.FindByIdAsync(user.Id);
Assert.NotNull(user1);
Assert.NotNull(user2);
Assert.NotSame(user1, user2);
user1.UserName = Guid.NewGuid().ToString();
IdentityResultAssert.IsSuccess(await manager1.UpdateAsync(user1));
IdentityResultAssert.IsFailure(await manager2.DeleteAsync(user2),
new IdentityErrorDescriber().ConcurrencyFailure());
}
public async Task VerifyAccountControllerSignIn(bool isPersistent)
{
var context = new DefaultHttpContext();
var auth = MockAuth(context);
auth.Setup(a => a.SignInAsync(context, IdentityConstants.ApplicationScheme,
It.IsAny<ClaimsPrincipal>(),
It.IsAny<AuthenticationProperties>())).Returns(Task.FromResult(0)).Verifiable();
// REVIEW: is persistant mocking broken
//It.Is<AuthenticationProperties>(v => v.IsPersistent == isPersistent))).Returns(Task.FromResult(0)).Verifiable();
var contextAccessor = new Mock<IHttpContextAccessor>();
contextAccessor.Setup(a => a.HttpContext).Returns(context);
var services = new ServiceCollection()
.AddSingleton<IConfiguration>(new ConfigurationBuilder().Build())
.AddLogging()
.AddSingleton(contextAccessor.Object);
services.AddIdentity<PocoUser, PocoRole>();
services.AddSingleton<IUserStore<PocoUser>, InMemoryStore<PocoUser, PocoRole>>();
services.AddSingleton<IRoleStore<PocoRole>, InMemoryStore<PocoUser, PocoRole>>();
var app = new ApplicationBuilder(services.BuildServiceProvider());
// Act
var user = new PocoUser
{
UserName = "******"
};
const string password = "******";
var userManager = app.ApplicationServices.GetRequiredService<UserManager<PocoUser>>();
var signInManager = app.ApplicationServices.GetRequiredService<SignInManager<PocoUser>>();
IdentityResultAssert.IsSuccess(await userManager.CreateAsync(user, password));
var result = await signInManager.PasswordSignInAsync(user, password, isPersistent, false);
// Assert
Assert.True(result.Succeeded);
auth.VerifyAll();
contextAccessor.VerifyAll();
}
public async Task VerifyAccountControllerSignIn(bool isPersistent)
{
var app = new ApplicationBuilder(CallContextServiceLocator.Locator.ServiceProvider);
app.UseCookieAuthentication();
var context = new Mock <HttpContext>();
var response = new Mock <HttpResponse>();
context.Setup(c => c.Response).Returns(response.Object).Verifiable();
response.Setup(r => r.SignIn(It.Is <AuthenticationProperties>(v => v.IsPersistent == isPersistent), It.IsAny <ClaimsIdentity>())).Verifiable();
var contextAccessor = new Mock <IHttpContextAccessor>();
contextAccessor.Setup(a => a.Value).Returns(context.Object);
app.UseServices(services =>
{
services.AddInstance(contextAccessor.Object);
services.AddIdentity <ApplicationUser, IdentityRole>();
services.AddSingleton <IUserStore <ApplicationUser>, InMemoryUserStore <ApplicationUser> >();
services.AddSingleton <IRoleStore <IdentityRole>, InMemoryRoleStore <IdentityRole> >();
});
// Act
var user = new ApplicationUser
{
UserName = "******"
};
const string password = "******";
var userManager = app.ApplicationServices.GetRequiredService <UserManager <ApplicationUser> >();
var signInManager = app.ApplicationServices.GetRequiredService <SignInManager <ApplicationUser> >();
IdentityResultAssert.IsSuccess(await userManager.CreateAsync(user, password));
var result = await signInManager.PasswordSignInAsync(user, password, isPersistent, false);
// Assert
Assert.True(result.Succeeded);
context.VerifyAll();
response.VerifyAll();
contextAccessor.VerifyAll();
}
public async Task CanIncludeRoleClaimsTest()
{
// Arrange
var roleManager = _builder.ApplicationServices.GetRequiredService <RoleManager <IdentityRole> >();
var dbContext = _builder.ApplicationServices.GetRequiredService <IdentityDataConnection>();
var role = new IdentityRole("Admin");
IdentityResultAssert.IsSuccess(await roleManager.CreateAsync(role));
for (var i = 0; i < 10; i++)
{
IdentityResultAssert.IsSuccess(await roleManager.AddClaimAsync(role, new Claim("foo" + i, "bar" + i)));
}
role = dbContext.Roles.LoadWith(x => x.Claims).FirstOrDefault(x => x.Name == "Admin");
// Assert
Assert.NotNull(role);
Assert.NotNull(role.Claims);
Assert.Equal(10, role.Claims.Count());
}
public async Task DefaultAlphaNumericOnlyUserNameValidation(string userName, bool expectSuccess)
{
// Setup
var manager = MockHelpers.TestUserManager(new NoopUserStore());
var validator = new UserValidator <PocoUser>();
var user = new PocoUser {
UserName = userName
};
// Act
var result = await validator.ValidateAsync(manager, user);
// Assert
if (expectSuccess)
{
IdentityResultAssert.IsSuccess(result);
}
else
{
IdentityResultAssert.IsFailure(result);
}
}
public async Task RemoveClaimWithIssuerOnlyAffectsUser()
{
if (ShouldSkipDbTests())
{
return;
}
var manager = CreateManager();
var user = CreateTestUser();
var user2 = CreateTestUser();
IdentityResultAssert.IsSuccess(await manager.CreateAsync(user));
IdentityResultAssert.IsSuccess(await manager.CreateAsync(user2));
Claim[] claims =
{ new Claim("c", "v", null, "i1"), new Claim("c2", "v2", null, "i2"), new Claim("c2", "v3", null, "i3") };
foreach (var c in claims)
{
IdentityResultAssert.IsSuccess(await manager.AddClaimAsync(user, c));
IdentityResultAssert.IsSuccess(await manager.AddClaimAsync(user2, c));
}
var userClaims = await manager.GetClaimsAsync(user);
Assert.Equal(3, userClaims.Count);
IdentityResultAssert.IsSuccess(await manager.RemoveClaimAsync(user, claims[0]));
userClaims = await manager.GetClaimsAsync(user);
Assert.Equal(2, userClaims.Count);
IdentityResultAssert.IsSuccess(await manager.RemoveClaimAsync(user, claims[1]));
userClaims = await manager.GetClaimsAsync(user);
Assert.Equal(1, userClaims.Count);
IdentityResultAssert.IsSuccess(await manager.RemoveClaimAsync(user, claims[2]));
userClaims = await manager.GetClaimsAsync(user);
Assert.Equal(0, userClaims.Count);
var userClaims2 = await manager.GetClaimsAsync(user2);
Assert.Equal(3, userClaims2.Count);
}
public async Task CanReplaceUserClaimWithIssuer()
{
var manager = CreateManager();
var user = CreateTestUser();
IdentityResultAssert.IsSuccess(await manager.CreateAsync(user));
IdentityResultAssert.IsSuccess(await manager.AddClaimAsync(user, new Claim("c", "a", "i")));
var userClaims = await manager.GetClaimsAsync(user);
Assert.Equal(1, userClaims.Count);
Claim claim = new Claim("c", "b", "i");
Claim oldClaim = userClaims.FirstOrDefault();
IdentityResultAssert.IsSuccess(await manager.ReplaceClaimAsync(user, oldClaim, claim));
var newUserClaims = await manager.GetClaimsAsync(user);
Assert.Equal(1, newUserClaims.Count);
Claim newClaim = newUserClaims.FirstOrDefault();
Assert.Equal(claim.Type, newClaim.Type);
Assert.Equal(claim.Value, newClaim.Value);
Assert.Equal(claim.Issuer, newClaim.Issuer);
}
private async Task LazyLoadTestSetup(TUser user)
{
var manager = CreateManager();
var role = CreateRoleManager();
var admin = CreateTestRole("Admin" + Guid.NewGuid().ToString());
var local = CreateTestRole("Local" + Guid.NewGuid().ToString());
IdentityResultAssert.IsSuccess(await manager.CreateAsync(user));
IdentityResultAssert.IsSuccess(await manager.AddLoginAsync(user, new UserLoginInfo("provider", user.Id.ToString(), "display")));
IdentityResultAssert.IsSuccess(await role.CreateAsync(admin));
IdentityResultAssert.IsSuccess(await role.CreateAsync(local));
IdentityResultAssert.IsSuccess(await manager.AddToRoleAsync(user, admin.Name));
IdentityResultAssert.IsSuccess(await manager.AddToRoleAsync(user, local.Name));
Claim[] userClaims =
{
new Claim("Whatever", "Value"),
new Claim("Whatever2", "Value2")
};
foreach (var c in userClaims)
{
IdentityResultAssert.IsSuccess(await manager.AddClaimAsync(user, c));
}
}
public async Task CanAddRemoveUserClaimWithIssuer()
{
if (ShouldSkipDbTests())
{
return;
}
var manager = CreateManager();
var user = CreateTestUser();
IdentityResultAssert.IsSuccess(await manager.CreateAsync(user));
Claim[] claims =
{ new Claim("c1", "v1", null, "i1"), new Claim("c2", "v2", null, "i2"), new Claim("c2", "v3", null, "i3") };
foreach (var c in claims)
{
IdentityResultAssert.IsSuccess(await manager.AddClaimAsync(user, c));
}
var userId = await manager.GetUserIdAsync(user);
var userClaims = await manager.GetClaimsAsync(user);
Assert.Equal(3, userClaims.Count);
Assert.Equal(3, userClaims.Intersect(claims, ClaimEqualityComparer.Default).Count());
IdentityResultAssert.IsSuccess(await manager.RemoveClaimAsync(user, claims[0]));
userClaims = await manager.GetClaimsAsync(user);
Assert.Equal(2, userClaims.Count);
IdentityResultAssert.IsSuccess(await manager.RemoveClaimAsync(user, claims[1]));
userClaims = await manager.GetClaimsAsync(user);
Assert.Equal(1, userClaims.Count);
IdentityResultAssert.IsSuccess(await manager.RemoveClaimAsync(user, claims[2]));
userClaims = await manager.GetClaimsAsync(user);
Assert.Equal(0, userClaims.Count);
}
public async Task EnsureStartupOptionsChangeWorks()
{
EnsureDatabase();
var builder = new ApplicationBuilder(CallContextServiceLocator.Locator.ServiceProvider);
builder.UseServices(services =>
{
services.AddHosting();
services.AddEntityFramework()
.AddSqlServer()
.AddDbContext <ApplicationDbContext>(options => options.UseSqlServer(ConnectionString));
services.AddIdentity <ApplicationUser, IdentityRole>(null, options =>
{
options.Password.RequiredLength = 1;
options.Password.RequireLowercase = false;
options.Password.RequireNonLetterOrDigit = false;
options.Password.RequireUppercase = false;
options.Password.RequireDigit = false;
}).AddEntityFrameworkStores <ApplicationDbContext>();
});
var userStore = builder.ApplicationServices.GetRequiredService <IUserStore <ApplicationUser> >();
var userManager = builder.ApplicationServices.GetRequiredService <UserManager <ApplicationUser> >();
Assert.NotNull(userStore);
Assert.NotNull(userManager);
const string userName = "******";
const string password = "******";
var user = new ApplicationUser {
UserName = userName
};
IdentityResultAssert.IsSuccess(await userManager.CreateAsync(user, password));
IdentityResultAssert.IsSuccess(await userManager.DeleteAsync(user));
}
public async Task ConcurrentUpdatesWillFailWithDetachedUser()
{
var user = CreateTestUser();
using (var db = CreateContext())
{
var manager = CreateUserManager(db);
IdentityResultAssert.IsSuccess(await manager.CreateAsync(user));
}
using (var db = CreateContext())
using (var db2 = CreateContext())
{
var manager1 = CreateUserManager(db);
var manager2 = CreateUserManager(db2);
var user2 = await manager2.FindByIdAsync(user.Id);
Assert.NotNull(user2);
Assert.NotSame(user, user2);
user.UserName = Guid.NewGuid().ToString();
user2.UserName = Guid.NewGuid().ToString();
IdentityResultAssert.IsSuccess(await manager1.UpdateAsync(user));
IdentityResultAssert.IsFailure(await manager2.UpdateAsync(user2), new IdentityErrorDescriber().ConcurrencyFailure());
}
}
public async Task CanAllowNonAlphaNumericUserName(string userName, bool expectSuccess)
{
// Setup
var manager = MockHelpers.TestUserManager(new NoopUserStore());
manager.Options.User.AllowedUserNameCharacters = null;
var validator = new UserValidator <PocoUser>();
var user = new PocoUser {
UserName = userName
};
// Act
var result = await validator.ValidateAsync(manager, user);
// Assert
if (expectSuccess)
{
IdentityResultAssert.IsSuccess(result);
}
else
{
IdentityResultAssert.IsFailure(result);
}
}
public async Task DeleteRoleNonEmptySucceedsTest()
{
var userMgr = CreateManager();
var roleMgr = CreateRoleManager();
var roleName = "delete" + Guid.NewGuid().ToString();
var role = CreateTestRole(roleName, useRoleNamePrefixAsRoleName: true);
Assert.False(await roleMgr.RoleExistsAsync(roleName));
IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role));
var user = CreateTestUser();
IdentityResultAssert.IsSuccess(await userMgr.CreateAsync(user));
IdentityResultAssert.IsSuccess(await userMgr.AddToRoleAsync(user, roleName));
var roles = await userMgr.GetRolesAsync(user);
Assert.Single(roles);
IdentityResultAssert.IsSuccess(await roleMgr.DeleteAsync(role));
Assert.Null(await roleMgr.FindByNameAsync(roleName));
Assert.False(await roleMgr.RoleExistsAsync(roleName));
// REVIEW: We should throw if deleteing a non empty role?
roles = await userMgr.GetRolesAsync(user);
Assert.Empty(roles);
}
public async Task EnsureStartupUsageWorks()
{
EnsureDatabase();
var builder = new ApplicationBuilder(CallContextServiceLocator.Locator.ServiceProvider);
builder.UseServices(services =>
{
DbUtil.ConfigureDbServices <TestDbContext>(ConnectionString, services);
services.AddIdentity <TUser, TRole>().AddEntityFrameworkStores <TestDbContext, TKey>();
});
var userStore = builder.ApplicationServices.GetRequiredService <IUserStore <TUser> >();
var userManager = builder.ApplicationServices.GetRequiredService <UserManager <TUser> >();
Assert.NotNull(userStore);
Assert.NotNull(userManager);
const string password = "******";
var user = CreateTestUser();
user.UserName = "******";
IdentityResultAssert.IsSuccess(await userManager.CreateAsync(user, password));
IdentityResultAssert.IsSuccess(await userManager.DeleteAsync(user));
}
