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)); }