public static async Task Seed(BlogCoreDbContext dbContext) { var roleStore = new RoleStore <IdentityRole>(dbContext); await roleStore.CreateAsync(new IdentityRole { Id = Guid.NewGuid().ToString(), Name = "user", NormalizedName = "user" }); await roleStore.CreateAsync(new IdentityRole { Id = Guid.NewGuid().ToString(), Name = "admin", NormalizedName = "admin" }); var userStore = new UserStore <AppUser>(dbContext); var password = new PasswordHasher <AppUser>(); var rootUser = new AppUser { Id = Guid.NewGuid().ToString(), UserName = "******", Email = "*****@*****.**", NormalizedEmail = "*****@*****.**", NormalizedUserName = "******", SecurityStamp = Guid.NewGuid().ToString("D"), LockoutEnabled = true }; var normalUser = new AppUser { Id = Guid.NewGuid().ToString(), UserName = "******", Email = "*****@*****.**", NormalizedEmail = "*****@*****.**", NormalizedUserName = "******", SecurityStamp = Guid.NewGuid().ToString("D"), LockoutEnabled = true }; rootUser.PasswordHash = password.HashPassword(rootUser, "r00t"); normalUser.PasswordHash = password.HashPassword(normalUser, "user1"); // add users await userStore.CreateAsync(rootUser); await userStore.CreateAsync(normalUser); // assign roles await userStore.AddToRoleAsync(rootUser, "admin"); await userStore.AddToRoleAsync(normalUser, "user"); }
public void GetAllRoles() { var user1 = new IdentityUser("Lukz 04"); var user2 = new IdentityUser("Moa 01"); var user3 = new IdentityUser("Win 02"); var user4 = new IdentityUser("Andre 03"); var role = new IdentityRole("ADM"); var role2 = new IdentityRole("USR"); var store = new UserStore <IdentityUser>(this._session); var roleStore = new RoleStore <IdentityRole>(this._session); roleStore.CreateAsync(role); roleStore.CreateAsync(role2); store.CreateAsync(user1); store.CreateAsync(user2); store.CreateAsync(user3); store.CreateAsync(user4); store.AddToRoleAsync(user1, "ADM"); store.AddToRoleAsync(user2, "ADM"); store.AddToRoleAsync(user3, "ADM"); store.AddToRoleAsync(user4, "ADM"); store.AddToRoleAsync(user1, "USR"); store.AddToRoleAsync(user4, "USR"); Assert.IsTrue(this._session.Query <IdentityRole>().Any(x => x.Name == "ADM")); Assert.IsTrue(this._session.Query <IdentityUser>().Any(x => x.UserName == "Lukz 04")); Assert.IsTrue(this._session.Query <IdentityUser>().Any(x => x.UserName == "Andre 03")); var resul = roleStore.Roles; Assert.AreEqual(2, resul.Count()); }
public void CreateUsers() { UserStore <MockUser, MockRole, MockUserToken> userStore = TestInit.GetEmptyUserStore(); String emailAddress1 = "*****@*****.**"; String userName1 = "MisterTest1"; IdentityResult result = userStore.CreateAsync(new MockUser { Email = emailAddress1, UserName = userName1 }, new System.Threading.CancellationToken()).Result; Assert.True(result.Succeeded); String emailAddress2 = "*****@*****.**"; String userName2 = "MisterTest2"; result = userStore.CreateAsync(new MockUser { Email = emailAddress2, UserName = userName2 }, new System.Threading.CancellationToken()).Result; Assert.True(result.Succeeded); String emailAddress3 = "*****@*****.**"; String userName3 = "MisterTest3"; result = userStore.CreateAsync(new MockUser { Email = emailAddress3, UserName = userName3 }, new System.Threading.CancellationToken()).Result; Assert.True(result.Succeeded == true); Assert.Equal(3, userStore.Users.Count()); }
public async Task UserNameValidationExceptionAsync() { // Arrange var user = GenerateUser(); user.Email = string.Empty; await userStore.CreateAsync(user); try { // Act await Context.SaveChangesAsync(); } catch (Exception ex) { var entityException = (DbEntityValidationException)ex.InnerException; var errors = entityException.EntityValidationErrors; var error = errors.First(); var validationError = error.ValidationErrors.First(); // Assert Assert.IsTrue(validationError.PropertyName == "UserName"); Assert.IsTrue(validationError.ErrorMessage == "The UserName field is required."); } }
public async Task CreateAsync_CompleteUser_UserPropertiesAreSet() { var userModel = mMembershipFakeFactory.GetNewUser(); await mUserStore.CreateAsync(userModel); var userFromDB = await mUserStore.FindByIdAsync(userModel.Id); CMSAssert.All( () => Assert.AreEqual(userModel.Email, userFromDB.Email), () => Assert.AreEqual(userModel.Enabled, userFromDB.Enabled), () => Assert.AreEqual(userModel.LastName, userFromDB.LastName), () => Assert.AreEqual(userModel.UserName, userFromDB.UserName), () => Assert.AreEqual(userModel.FirstName, userFromDB.FirstName)); }
public async void SeedAdminUser() { var admin = new ApplicationUser { Id = Guid.NewGuid().ToString(), UserName = "******", NormalizedUserName = "******", Email = "*****@*****.**", NormalizedEmail = "*****@*****.**", SecurityStamp = Guid.NewGuid().ToString() }; var user = new ApplicationUser { Id = Guid.NewGuid().ToString(), UserName = "******", NormalizedUserName = "******", Email = "*****@*****.**", NormalizedEmail = "*****@*****.**", SecurityStamp = Guid.NewGuid().ToString() }; var roleStore = new RoleStore <IdentityRole>(context); if (!context.Roles.Any()) { await roleStore.CreateAsync(new IdentityRole { Name = Roles.Admin, NormalizedName = Roles.Admin }); await roleStore.CreateAsync(new IdentityRole { Name = Roles.User, NormalizedName = Roles.User }); } if (!context.Users.Any()) { var password = new PasswordHasher <ApplicationUser>(); var hashedAdmin = password.HashPassword(admin, "12345"); admin.PasswordHash = hashedAdmin; var userStore = new UserStore <ApplicationUser>(context); await userStore.CreateAsync(admin); await userStore.AddToRoleAsync(admin, Roles.Admin); var hashedUser = password.HashPassword(user, "12345"); user.PasswordHash = hashedUser; await userStore.CreateAsync(user); await userStore.AddToRoleAsync(user, Roles.User); } await context.SaveChangesAsync(); }
public async Task CreateUserAsync() { var testUser = new SuperIdentityUser { UserName = "******", Email = "*****@*****.**" }; await _userStore.CreateAsync(testUser); var savedUser = await _userStore.FindByEmailAsync(testUser.Email); Assert.IsNotNull(savedUser); Assert.AreEqual(testUser.Email, savedUser.Email); }
public static async void SeedMemberUser(ApplicationDbContext _context) { var user = new ApplicationUser { UserName = "******", Email = "[email protected]", EmailConfirmed = true, NormalizedEmail = "[email protected]", NormalizedUserName = "******", LockoutEnabled = false, SecurityStamp = Guid.NewGuid().ToString() }; var roleStore = new RoleStore <IdentityRole>(_context); if (!_context.Roles.Any(r => r.Name == "Member")) { await roleStore.CreateAsync(new IdentityRole { Name = "Member", NormalizedName = "MEMBER" }); } if (!_context.Users.Any(u => u.UserName == "[email protected]")) { var password = new PasswordHasher <ApplicationUser>(); var hashed = password.HashPassword(user, "P@$$w0rd"); user.PasswordHash = hashed; var userStore = new UserStore <ApplicationUser>(_context); await userStore.CreateAsync(user); await userStore.AddToRoleAsync(user, "MEMBER"); } await _context.SaveChangesAsync(); }
private ApplicationUser Create( string username, string password, string email, UserStore <ApplicationUser> store) { IPasswordHasher hasher = new PasswordHasher(); string passwordHash = hasher.HashPassword(password); ApplicationUser applicationUser = new ApplicationUser { Email = email, EmailConfirmed = true, LockoutEnabled = true, IsApproved = true, UserName = username, PasswordHash = passwordHash, SecurityStamp = Guid.NewGuid().ToString() }; store.CreateAsync(applicationUser) .GetAwaiter() .GetResult(); return(store.FindByNameAsync(username) .GetAwaiter() .GetResult()); }
public async void AddToRoleAsync_GivenAUserAndRole_AddsTheUserToTheRole() { var applicationDatabaseConfiguration = new ApplicationDatabaseConfiguration(); var userStore = new UserStore<User>(applicationDatabaseConfiguration); var user = new User { Email = "*****@*****.**", IsEmailConfirmed = true, PasswordHash = "PasswordHash", PhoneNumber = "PhoneNumber", IsPhoneNumberConfirmed = true, IsTwoFactorEnabled = false, LockoutEndDateUtc = null, IsLockoutEnabled = true, AccessFailedCount = 0, UserName = "******", IsAccountActive = true }; await userStore.CreateAsync(user); await userStore.AddToRoleAsync(user, "Admin"); var roles = await userStore.GetRolesAsync(user); roles.Should().HaveCount(1); roles[0].Should().Be("Admin"); }
public async void SetLockoutEndDateAsync_GivenAUserAndLockoutDate_LockoutDateIsSet() { var applicationDatabaseConfiguration = new ApplicationDatabaseConfiguration(); var userStore = new UserStore<User>(applicationDatabaseConfiguration); var user = new User { Email = "*****@*****.**", IsEmailConfirmed = true, PasswordHash = "PasswordHash", PhoneNumber = "PhoneNumber", IsPhoneNumberConfirmed = true, IsTwoFactorEnabled = false, LockoutEndDateUtc = null, IsLockoutEnabled = false, AccessFailedCount = 0, UserName = "******", IsAccountActive = true }; await userStore.CreateAsync(user); await userStore.SetLockoutEndDateAsync(user, Convert.ToDateTime("01/01/2014")); var lockoutDate = await userStore.GetLockoutEndDateAsync(user); lockoutDate.Should().Be(Convert.ToDateTime("01/01/2014")); }
public async void SetLockoutEnabledAsync_GivenAUserAndATrueFlag_LockoutEnabledIsSetToTrue() { var applicationDatabaseConfiguration = new ApplicationDatabaseConfiguration(); var userStore = new UserStore<User>(applicationDatabaseConfiguration); var user = new User { Email = "*****@*****.**", IsEmailConfirmed = true, PasswordHash = "PasswordHash", PhoneNumber = "PhoneNumber", IsPhoneNumberConfirmed = true, IsTwoFactorEnabled = false, LockoutEndDateUtc = null, IsLockoutEnabled = false, AccessFailedCount = 0, UserName = "******", IsAccountActive = true }; await userStore.CreateAsync(user); await userStore.SetLockoutEnabledAsync(user, true); var isLockedOut = await userStore.GetLockoutEnabledAsync(user); isLockedOut.Should().BeTrue(); }
public async Task AddRemoveUserClaimTest() { var db = UnitTestHelper.CreateDefaultDb(); var store = new UserStore<IdentityUser>(db); ; var user = new IdentityUser("ClaimsAddRemove"); await store.CreateAsync(user); Claim[] claims = {new Claim("c", "v"), new Claim("c2", "v2"), new Claim("c2", "v3")}; foreach (Claim c in claims) { await store.AddClaimAsync(user, c); } await store.UpdateAsync(user); var userClaims = await store.GetClaimsAsync(user); Assert.Equal(3, userClaims.Count); await store.RemoveClaimAsync(user, claims[0]); Assert.Equal(3, userClaims.Count); // No effect until save changes db.SaveChanges(); userClaims = await store.GetClaimsAsync(user); Assert.Equal(2, userClaims.Count); await store.RemoveClaimAsync(user, claims[1]); Assert.Equal(2, userClaims.Count); // No effect until save changes db.SaveChanges(); userClaims = await store.GetClaimsAsync(user); Assert.Equal(1, userClaims.Count); await store.RemoveClaimAsync(user, claims[2]); Assert.Equal(1, userClaims.Count); // No effect until save changes db.SaveChanges(); userClaims = await store.GetClaimsAsync(user); Assert.Equal(0, userClaims.Count); //Assert.Equal(0, user.Claims.Count); }
public async void SetEmailAsync_GivenAUserAndEmail_SetTheUsersEmail() { var applicationDatabaseConfiguration = new ApplicationDatabaseConfiguration(); var userStore = new UserStore <User>(applicationDatabaseConfiguration); var user = new User { Email = "*****@*****.**", IsEmailConfirmed = true, PasswordHash = "PasswordHash", PhoneNumber = "PhoneNumber", IsPhoneNumberConfirmed = true, IsTwoFactorEnabled = false, LockoutEndDateUtc = null, IsLockoutEnabled = true, AccessFailedCount = 0, UserName = "******", IsAccountActive = true }; await userStore.CreateAsync(user); await userStore.SetEmailAsync(user, "*****@*****.**"); var emailAddress = await userStore.GetEmailAsync(user); emailAddress.Should().Be("*****@*****.**"); }
public async void CreateAsync_GivenNewUser_CreatesNewUserAndAssignsUserId() { var applicationDatabaseConfiguration = new ApplicationDatabaseConfiguration(); var userStore = new UserStore<User>(applicationDatabaseConfiguration); var user = new User { Email = "*****@*****.**", IsEmailConfirmed = true, PasswordHash = "PasswordHash", PhoneNumber = "PhoneNumber", IsPhoneNumberConfirmed = true, IsTwoFactorEnabled = false, LockoutEndDateUtc = null, IsLockoutEnabled = true, AccessFailedCount = 0, UserName = "******", IsAccountActive = true }; await userStore.CreateAsync(user); var insertedUser = await userStore.FindByIdAsync(user.Id); insertedUser.Should().NotBeNull(); insertedUser.Email.Should().Be("*****@*****.**"); }
public void AddUserWithNoUserNameFailsTest() { var db = UnitTestHelper.CreateDefaultDb(); var store = new UserStore<IdentityUser>(db); Assert.Throws<DbEntityValidationException>( () => AsyncHelper.RunSync(() => store.CreateAsync(new IdentityUser()))); }
public async void RemoveClaimAsync_GivenAUserAndClaim_RemovesTheClaim() { var applicationDatabaseConfiguration = new ApplicationDatabaseConfiguration(); var userStore = new UserStore<User>(applicationDatabaseConfiguration); var user = new User { Email = "*****@*****.**", IsEmailConfirmed = true, PasswordHash = "PasswordHash", PhoneNumber = "PhoneNumber", IsPhoneNumberConfirmed = true, IsTwoFactorEnabled = false, LockoutEndDateUtc = null, IsLockoutEnabled = true, AccessFailedCount = 0, UserName = "******", IsAccountActive = true }; await userStore.CreateAsync(user); var insertedUser = await userStore.FindByIdAsync(user.Id); await userStore.AddClaimAsync(insertedUser, new Claim("ClaimType2", "ClaimValue2")); await userStore.RemoveClaimAsync(insertedUser, new Claim("ClaimType2", "ClaimValue2")); IList<Claim> claims = await userStore.GetClaimsAsync(user); claims.Should().HaveCount(0); }
public async void UpdateAsync_GivenAnUpdate_UpdatesTheUser() { var applicationDatabaseConfiguration = new ApplicationDatabaseConfiguration(); var userStore = new UserStore<User>(applicationDatabaseConfiguration); var user = new User { Email = "*****@*****.**", IsEmailConfirmed = true, PasswordHash = "PasswordHash", PhoneNumber = "PhoneNumber", IsPhoneNumberConfirmed = true, IsTwoFactorEnabled = false, LockoutEndDateUtc = null, IsLockoutEnabled = true, AccessFailedCount = 0, UserName = "******", IsAccountActive = true }; await userStore.CreateAsync(user); var existingUser = await userStore.FindByNameAsync("UserName"); existingUser.Email = "*****@*****.**"; existingUser.PhoneNumber = "1234"; await userStore.UpdateAsync(existingUser); var updatedUser = await userStore.FindByNameAsync("UserName"); updatedUser.Should().NotBeNull(); updatedUser.Email.Should().Be("*****@*****.**"); updatedUser.PhoneNumber.Should().Be("1234"); }
public bool crearUsuario(LoginModel model) { try { var manager = new UserStore <Usuario>(BDContext); Usuario usuario = new Usuario { Email = "*****@*****.**", Apellidos = "Agudelo", Contrasena = "1234567890", Correo = "*****@*****.**", Nombre = "Juan Jose", UserName = "******" }; IdentityResult result = manager.CreateAsync(usuario).GetAwaiter().GetResult(); if (!result.Succeeded) { throw new ArgumentException("Mensaje El usuario no se registró correctamente o ya existe en la base de datos"); } manager.SetPasswordHashAsync(usuario, "123456789"); return(result.Succeeded); } catch (Exception ex) { throw new ArgumentException("Se presentó un error al momento de realizar el login"); } }
public async Task AddUserResourcePool_IdShouldBeBiggerThanZero() { // Arrange var userStore = new UserStore(Context); userStore.AutoSaveChanges = false; var user = new User("User"); await userStore.CreateAsync(user); await Context.SaveChangesAsync(); LoginAs(user); var resourcePool = new ResourcePool(user, "ResourcePool"); var userResourcePool = resourcePool.AddUserResourcePool(100); // Act resourcePoolRepository.Insert(resourcePool); await Context.SaveChangesAsync(); // Assert Assert.IsTrue(user.Id > 0); Assert.IsTrue(resourcePool.Id > 0); //Assert.IsTrue(userResourcePool.Id > 0); }
public void When_Not_Success_CreateAsync_Throws_CouchbaseException() { var mockBucket = new Mock<IBucket>(); mockBucket.SetupGet(e => e.Name).Returns("default"); var mockResult = new Mock<IOperationResult<IdentityUser>>(); mockResult.SetupGet(x => x.Success).Returns(false); mockResult.SetupGet(x => x.Status).Returns(ResponseStatus.KeyExists); mockBucket.Setup(x => x.InsertAsync(It.IsAny<string>(), It.IsAny<IdentityUser>())) .ReturnsAsync(mockResult.Object); var mockResult2 = new Mock<IOperationResult<string>>(); mockResult2.SetupGet(x => x.Success).Returns(false); mockResult2.SetupGet(x => x.Status).Returns(ResponseStatus.KeyExists); mockBucket.Setup(x => x.InsertAsync(It.IsAny<string>(), It.IsAny<string>())) .ReturnsAsync(mockResult2.Object); var mockResult3 = new Mock<IOperationResult<string>>(); mockResult3.SetupGet(x => x.Success).Returns(false); mockResult3.SetupGet(x => x.Status).Returns(ResponseStatus.KeyExists); mockBucket.Setup(x => x.InsertAsync(It.IsAny<string>(), It.IsAny<string>())) .ReturnsAsync(mockResult3.Object); var user = new IdentityUser("foo") { Email = "*****@*****.**" }; var store = new UserStore<IdentityUser>(new ThrowableBucket(mockBucket.Object)); Assert.Throws<CouchbaseException>(async () => await store.CreateAsync(user)); }
public async void SetPasswordHashAsync_GivenAUserAndPasswordHash_SetsTheHashForTheUser() { var applicationDatabaseConfiguration = new ApplicationDatabaseConfiguration(); var userStore = new UserStore<User>(applicationDatabaseConfiguration); var user = new User { Email = "*****@*****.**", IsEmailConfirmed = true, PasswordHash = "PasswordHash", PhoneNumber = "PhoneNumber", IsPhoneNumberConfirmed = true, IsTwoFactorEnabled = false, LockoutEndDateUtc = null, IsLockoutEnabled = true, AccessFailedCount = 0, UserName = "******", IsAccountActive = true }; await userStore.CreateAsync(user); await userStore.SetPasswordHashAsync(user, "1234"); var passwordHash = await userStore.GetPasswordHashAsync(user); passwordHash.Should().Be("1234"); }
public async void HasPasswordAsync_GivenAUserWithAPasswordHash_ReturnsTrue() { var applicationDatabaseConfiguration = new ApplicationDatabaseConfiguration(); var userStore = new UserStore<User>(applicationDatabaseConfiguration); var user = new User { Email = "*****@*****.**", IsEmailConfirmed = true, PasswordHash = "PasswordHash", PhoneNumber = "PhoneNumber", IsPhoneNumberConfirmed = true, IsTwoFactorEnabled = false, LockoutEndDateUtc = null, IsLockoutEnabled = true, AccessFailedCount = 0, UserName = "******", IsAccountActive = true }; await userStore.CreateAsync(user); var hasPasswordHash = await userStore.HasPasswordAsync(user); hasPasswordHash.Should().BeTrue(); }
public async void FindByEmailAsync_GivenAnEmailAddress_ReturnsAUser() { var applicationDatabaseConfiguration = new ApplicationDatabaseConfiguration(); var userStore = new UserStore <User>(applicationDatabaseConfiguration); var user = new User { Email = "*****@*****.**", IsEmailConfirmed = false, PasswordHash = "PasswordHash", PhoneNumber = "PhoneNumber", IsPhoneNumberConfirmed = true, IsTwoFactorEnabled = false, LockoutEndDateUtc = null, IsLockoutEnabled = true, AccessFailedCount = 0, UserName = "******", IsAccountActive = true }; await userStore.CreateAsync(user); var foundUser = await userStore.FindByEmailAsync("*****@*****.**"); foundUser.Should().NotBeNull(); }
public async void SetSecurityStampAsync_GivenAUserAndASecurityStamp_SetsTheStampForTheUser() { var applicationDatabaseConfiguration = new ApplicationDatabaseConfiguration(); var userStore = new UserStore <User>(applicationDatabaseConfiguration); var user = new User { Email = "*****@*****.**", IsEmailConfirmed = true, PasswordHash = "PasswordHash", PhoneNumber = "PhoneNumber", IsPhoneNumberConfirmed = true, IsTwoFactorEnabled = false, LockoutEndDateUtc = null, IsLockoutEnabled = true, AccessFailedCount = 0, UserName = "******", IsAccountActive = true }; await userStore.CreateAsync(user); await userStore.SetSecurityStampAsync(user, "stamp"); var stamp = await userStore.GetSecurityStampAsync(user); stamp.Should().Be("stamp"); }
public async Task AddDupeUserIdWithStoreFailsTest() { var db = UnitTestHelper.CreateDefaultDb(); var store = new UserStore<IdentityUser>(db); var user = new IdentityUser("dupemgmt"); await store.CreateAsync(user); var u2 = new IdentityUser {Id = user.Id, UserName = "******"}; try { await store.CreateAsync(u2); Assert.False(true); } catch (Exception e) { Assert.True(e.InnerException.InnerException.Message.Contains("duplicate key")); } }
public async Task CreateAutoSavesTest() { var db = new NoopIdentityDbContext(); db.Configuration.ValidateOnSaveEnabled = false; var store = new UserStore<IdentityUser>(db); var user = new IdentityUser("test"); await store.CreateAsync(user); Assert.True(db.SaveChangesCalled); }
public async Task CanDisableAutoSaveChangesTest() { var db = new NoopIdentityDbContext(); var store = new UserStore<IdentityUser>(db); store.AutoSaveChanges = false; var user = new IdentityUser("test"); await store.CreateAsync(user); Assert.False(db.SaveChangesCalled); }
public async Task CanCreateUser() { string username = "******"; var userstore = new UserStore<IdentityUser>(new Uri(endpoint), key, userdb, usercoll); await userstore.CreateAsync(new IdentityUser("test_user")); IdentityUser user = await userstore.FindByNameAsync(username); Assert.IsNotNull(user); Assert.AreEqual(username, user.UserName); }
public async Task FindByNameAsyncAsyncTest() { var database = CreateDatabase(); var store = new UserStore<ApplicationUser>(database); var user = new ApplicationUser() { UserName = "******" }; await store.CreateAsync(user); var userFromDb = await store.FindByNameAsync("testuser"); Assert.IsTrue(userFromDb.Id.Length > 0); Assert.AreEqual(user.Id, userFromDb.Id); await store.DeleteAsync(user); }
async public Task ThenItIsAddedToTheList() { var store = new UserStore<TestUser>(); var user = new TestUser() { Id = "1", UserName = "******" }; await store.CreateAsync(user); var output = await store.FindByIdAsync("1"); Assert.IsNotNull(output); Assert.AreEqual("FStallone", output.UserName); }
public async Task CreateAsyncTest() { var database = CreateDatabase(); var store = new UserStore<ApplicationUser>(database); var user = new ApplicationUser() { UserName = "******" }; await store.CreateAsync(user); Assert.IsTrue(user.Id.Length > 0); var userFromDb = await store.FindByIdAsync(user.Id); Assert.IsNotNull(userFromDb); Assert.AreEqual("TestUser", userFromDb.UserName); database.GetCollection<ApplicationUser>("users").Remove(Query<ApplicationUser>.EQ(u => u.Id, user.Id)); }
/// <summary> /// 注册账号 /// </summary> /// <param name="userDto">账号注册信息</param> /// <returns></returns> public MethodResult RegisterAccount(RegisterDTO userDto) { var userStore = new UserStore<IdentityUser<int>, IdentityRole<int>, CrossContext, int>(_db); var user = new IdentityUser<int>(); user.UserName = userDto.UserName; user.PasswordHash = userDto.Password; var result = new MethodResult(); try { result.State = userStore.CreateAsync(user).Result.Succeeded; } catch (Exception ex) { result.State = false; result.Data = ex; } return result; }
public void Should_insert_user_into_custom_user_table() { var target = new UserStore<IdentityUser>(); target.Tables.SetUsersTable("MyUsers"); var newUser = new IdentityUser("Kathy"); var task = target.CreateAsync(newUser); task.Wait(); var db = Database.Open(); var user = (IdentityUser)db.MyUsers.FindAllByUserName("Kathy").FirstOrDefault(); Assert.That(user, Is.Not.Null); Assert.That(user.UserName, Is.EqualTo("Kathy")); }
public void When_Success_CreateAsync_Does_Not_Throw_Exception() { var mockBucket = new Mock<IBucket>(); mockBucket.SetupGet(e => e.Name).Returns("default"); var mockResult = new Mock<IOperationResult<IdentityUser>>(); mockResult.SetupGet(x => x.Success).Returns(true); mockBucket.Setup(x => x.InsertAsync(It.IsAny<string>(), It.IsAny<IdentityUser>())) .ReturnsAsync(mockResult.Object); var mockResult2 = new Mock<IOperationResult<string>>(); mockResult2.SetupGet(x => x.Success).Returns(true); mockBucket.Setup(x => x.InsertAsync(It.IsAny<string>(), It.IsAny<string>())) .ReturnsAsync(mockResult2.Object); var mockResult3 = new Mock<IOperationResult<string>>(); mockResult3.SetupGet(x => x.Success).Returns(true); mockBucket.Setup(x => x.InsertAsync(It.IsAny<string>(), It.IsAny<string>())) .ReturnsAsync(mockResult3.Object); var store = new UserStore<IdentityUser>(new ThrowableBucket(mockBucket.Object)); Assert.DoesNotThrow(async () => await store.CreateAsync(new IdentityUser(Guid.NewGuid().ToString()))); }
public async Task DeleteUserTest() { var db = UnitTestHelper.CreateDefaultDb(); var store = new UserStore<IdentityUser>(db); var mgmt = new IdentityUser("deletemgmttest"); await store.CreateAsync(mgmt); Assert.NotNull(await store.FindByIdAsync(mgmt.Id)); await store.DeleteAsync(mgmt); Assert.Null(await store.FindByIdAsync(mgmt.Id)); }
public async void Users_GivenAUserStore_ReturnsAllActiveUsers() { var applicationDatabaseConfiguration = new ApplicationDatabaseConfiguration(); var userStore = new UserStore<User>(applicationDatabaseConfiguration); var user = new User { Email = "*****@*****.**", IsEmailConfirmed = true, PasswordHash = "PasswordHash", PhoneNumber = "PhoneNumber", IsPhoneNumberConfirmed = true, IsTwoFactorEnabled = false, LockoutEndDateUtc = null, IsLockoutEnabled = true, AccessFailedCount = 0, UserName = "******", IsAccountActive = true }; await userStore.CreateAsync(user); var users = userStore.Users; users.Should().NotBeNullOrEmpty(); }
public void UserStorePublicNullCheckTest() { var store = new UserStore<IdentityUser>(); ExceptionHelper.ThrowsArgumentNull(() => AsyncHelper.RunSync(() => store.CreateAsync(null)), "user"); ExceptionHelper.ThrowsArgumentNull(() => AsyncHelper.RunSync(() => store.UpdateAsync(null)), "user"); ExceptionHelper.ThrowsArgumentNull(() => AsyncHelper.RunSync(() => store.DeleteAsync(null)), "user"); ExceptionHelper.ThrowsArgumentNull(() => AsyncHelper.RunSync(() => store.AddClaimAsync(null, null)), "user"); ExceptionHelper.ThrowsArgumentNull(() => AsyncHelper.RunSync(() => store.RemoveClaimAsync(null, null)), "user"); ExceptionHelper.ThrowsArgumentNull(() => AsyncHelper.RunSync(() => store.GetClaimsAsync(null)), "user"); ExceptionHelper.ThrowsArgumentNull(() => AsyncHelper.RunSync(() => store.GetLoginsAsync(null)), "user"); ExceptionHelper.ThrowsArgumentNull(() => AsyncHelper.RunSync(() => store.GetRolesAsync(null)), "user"); ExceptionHelper.ThrowsArgumentNull(() => AsyncHelper.RunSync(() => store.AddLoginAsync(null, null)), "user"); ExceptionHelper.ThrowsArgumentNull(() => AsyncHelper.RunSync(() => store.RemoveLoginAsync(null, null)), "user"); ExceptionHelper.ThrowsArgumentNull(() => AsyncHelper.RunSync(() => store.AddToRoleAsync(null, null)), "user"); ExceptionHelper.ThrowsArgumentNull(() => AsyncHelper.RunSync(() => store.RemoveFromRoleAsync(null, null)), "user"); ExceptionHelper.ThrowsArgumentNull(() => AsyncHelper.RunSync(() => store.IsInRoleAsync(null, null)), "user"); ExceptionHelper.ThrowsArgumentNull(() => AsyncHelper.RunSync(() => store.GetPasswordHashAsync(null)), "user"); ExceptionHelper.ThrowsArgumentNull(() => AsyncHelper.RunSync(() => store.SetPasswordHashAsync(null, null)), "user"); ExceptionHelper.ThrowsArgumentNull(() => AsyncHelper.RunSync(() => store.GetSecurityStampAsync(null)), "user"); ExceptionHelper.ThrowsArgumentNull( () => AsyncHelper.RunSync(() => store.SetSecurityStampAsync(null, null)), "user"); ExceptionHelper.ThrowsArgumentNull( () => AsyncHelper.RunSync(() => store.AddClaimAsync(new IdentityUser("fake"), null)), "claim"); ExceptionHelper.ThrowsArgumentNull( () => AsyncHelper.RunSync(() => store.RemoveClaimAsync(new IdentityUser("fake"), null)), "claim"); ExceptionHelper.ThrowsArgumentNull( () => AsyncHelper.RunSync(() => store.AddLoginAsync(new IdentityUser("fake"), null)), "login"); ExceptionHelper.ThrowsArgumentNull( () => AsyncHelper.RunSync(() => store.RemoveLoginAsync(new IdentityUser("fake"), null)), "login"); ExceptionHelper.ThrowsArgumentNull(() => AsyncHelper.RunSync(() => store.FindAsync(null)), "login"); ExceptionHelper.ThrowsArgumentNull(() => AsyncHelper.RunSync(() => store.GetEmailConfirmedAsync(null)), "user"); ExceptionHelper.ThrowsArgumentNull( () => AsyncHelper.RunSync(() => store.SetEmailConfirmedAsync(null, true)), "user"); ExceptionHelper.ThrowsArgumentNull(() => AsyncHelper.RunSync(() => store.GetEmailAsync(null)), "user"); ExceptionHelper.ThrowsArgumentNull(() => AsyncHelper.RunSync(() => store.SetEmailAsync(null, null)), "user"); ExceptionHelper.ThrowsArgumentNull(() => AsyncHelper.RunSync(() => store.GetPhoneNumberAsync(null)), "user"); ExceptionHelper.ThrowsArgumentNull(() => AsyncHelper.RunSync(() => store.SetPhoneNumberAsync(null, null)), "user"); ExceptionHelper.ThrowsArgumentNull( () => AsyncHelper.RunSync(() => store.GetPhoneNumberConfirmedAsync(null)), "user"); ExceptionHelper.ThrowsArgumentNull( () => AsyncHelper.RunSync(() => store.SetPhoneNumberConfirmedAsync(null, true)), "user"); ExceptionHelper.ThrowsArgumentNull(() => AsyncHelper.RunSync(() => store.GetTwoFactorEnabledAsync(null)), "user"); ExceptionHelper.ThrowsArgumentNull( () => AsyncHelper.RunSync(() => store.SetTwoFactorEnabledAsync(null, true)), "user"); ExceptionHelper.ThrowsArgumentNullOrEmpty( () => AsyncHelper.RunSync(() => store.AddToRoleAsync(new IdentityUser("fake"), null)), "roleName"); ExceptionHelper.ThrowsArgumentNullOrEmpty( () => AsyncHelper.RunSync(() => store.RemoveFromRoleAsync(new IdentityUser("fake"), null)), "roleName"); ExceptionHelper.ThrowsArgumentNullOrEmpty( () => AsyncHelper.RunSync(() => store.IsInRoleAsync(new IdentityUser("fake"), null)), "roleName"); }
public async Task AddDupeUserNameWithStoreFailsTest() { var db = UnitTestHelper.CreateDefaultDb(); var mgr = new UserManager<IdentityUser>(new UserStore<IdentityUser>(db)); var store = new UserStore<IdentityUser>(db); var user = new IdentityUser("dupe"); UnitTestHelper.IsSuccess(await mgr.CreateAsync(user)); var u2 = new IdentityUser("DUPe"); Assert.Throws<DbEntityValidationException>(() => AsyncHelper.RunSync(() => store.CreateAsync(u2))); }
public async Task AddDupeEmailWithStoreFailsTest() { var db = UnitTestHelper.CreateDefaultDb(); db.RequireUniqueEmail = true; var mgr = new UserManager<IdentityUser>(new UserStore<IdentityUser>(db)); var store = new UserStore<IdentityUser>(db); var user = new IdentityUser("u1") {Email = "email"}; UnitTestHelper.IsSuccess(await mgr.CreateAsync(user)); var u2 = new IdentityUser("u2") {Email = "email"}; Assert.Throws<DbEntityValidationException>(() => AsyncHelper.RunSync(() => store.CreateAsync(u2))); }
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 CreateLoadDeleteUserTest() { var db = UnitTestHelper.CreateDefaultDb(); var store = new UserStore<IdentityUser>(db); var user = new IdentityUser("Test"); Assert.Null(await store.FindByIdAsync(user.Id)); await store.CreateAsync(user); var loadUser = await store.FindByIdAsync(user.Id); Assert.NotNull(loadUser); Assert.Equal(user.Id, loadUser.Id); await store.DeleteAsync(loadUser); loadUser = await store.FindByIdAsync(user.Id); Assert.Null(loadUser); }
public async Task FindByUserName() { var db = UnitTestHelper.CreateDefaultDb(); var store = new UserStore<IdentityUser>(db); var user = new IdentityUser("Hao"); await store.CreateAsync(user); var found = await store.FindByNameAsync("hao"); Assert.NotNull(found); Assert.Equal(user.Id, found.Id); found = await store.FindByNameAsync("HAO"); Assert.NotNull(found); Assert.Equal(user.Id, found.Id); found = await store.FindByNameAsync("Hao"); Assert.NotNull(found); Assert.Equal(user.Id, found.Id); }