public void UserStoreMethodsThrowWhenDisposedTest() { var db = UnitTestHelper.CreateDefaultDb(); var store = new UserStore<IdentityUser>(db); store.Dispose(); Assert.Throws<ObjectDisposedException>(() => AsyncHelper.RunSync(() => store.AddClaimAsync(null, null))); Assert.Throws<ObjectDisposedException>(() => AsyncHelper.RunSync(() => store.AddLoginAsync(null, null))); Assert.Throws<ObjectDisposedException>(() => AsyncHelper.RunSync(() => store.AddToRoleAsync(null, null))); Assert.Throws<ObjectDisposedException>(() => AsyncHelper.RunSync(() => store.GetClaimsAsync(null))); Assert.Throws<ObjectDisposedException>(() => AsyncHelper.RunSync(() => store.GetLoginsAsync(null))); Assert.Throws<ObjectDisposedException>(() => AsyncHelper.RunSync(() => store.GetRolesAsync(null))); Assert.Throws<ObjectDisposedException>(() => AsyncHelper.RunSync(() => store.IsInRoleAsync(null, null))); Assert.Throws<ObjectDisposedException>(() => AsyncHelper.RunSync(() => store.RemoveClaimAsync(null, null))); Assert.Throws<ObjectDisposedException>(() => AsyncHelper.RunSync(() => store.RemoveLoginAsync(null, null))); Assert.Throws<ObjectDisposedException>( () => AsyncHelper.RunSync(() => store.RemoveFromRoleAsync(null, null))); Assert.Throws<ObjectDisposedException>(() => AsyncHelper.RunSync(() => store.RemoveClaimAsync(null, null))); Assert.Throws<ObjectDisposedException>(() => AsyncHelper.RunSync(() => store.FindAsync(null))); Assert.Throws<ObjectDisposedException>(() => AsyncHelper.RunSync(() => store.FindByIdAsync(null))); Assert.Throws<ObjectDisposedException>(() => AsyncHelper.RunSync(() => store.FindByNameAsync(null))); Assert.Throws<ObjectDisposedException>(() => AsyncHelper.RunSync(() => store.UpdateAsync(null))); Assert.Throws<ObjectDisposedException>(() => AsyncHelper.RunSync(() => store.DeleteAsync(null))); Assert.Throws<ObjectDisposedException>( () => AsyncHelper.RunSync(() => store.SetEmailConfirmedAsync(null, true))); Assert.Throws<ObjectDisposedException>(() => AsyncHelper.RunSync(() => store.GetEmailConfirmedAsync(null))); Assert.Throws<ObjectDisposedException>( () => AsyncHelper.RunSync(() => store.SetPhoneNumberConfirmedAsync(null, true))); Assert.Throws<ObjectDisposedException>( () => AsyncHelper.RunSync(() => store.GetPhoneNumberConfirmedAsync(null))); }
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 void GivenHaveRoles_WhenDeleteUser_ThenDeletingCausesNoCascade() { var user = new IdentityUser("Lukz 04"); var role = new IdentityRole("ADM"); var store = new UserStore <IdentityUser>(_session); var roleStore = new RoleStore <IdentityRole>(_session); roleStore.CreateAsync(role); store.CreateAsync(user); store.AddToRoleAsync(user, "ADM"); Assert.IsTrue(_session.Query <IdentityRole>().Any(x => x.Name == "ADM")); Assert.IsTrue(_session.Query <IdentityUser>().Any(x => x.UserName == "Lukz 04")); var result = store.DeleteAsync(user); Assert.IsNull(result.Exception); Assert.IsFalse(this._session.Query <IdentityUser>().Any(x => x.UserName == "Lukz 04")); Assert.IsTrue(this._session.Query <IdentityRole>().Any(x => x.Name == "ADM")); }
public Task SeedSuperUser() { var roleStore = new RoleStore <IdentityRole>(_context); var userStore = new UserStore <ApplicationUser>(_context); var user = new ApplicationUser { UserName = "******", NormalizedUserName = "******", Email = "*****@*****.**", NormalizedEmail = "*****@*****.**", EmailConfirmed = true, LockoutEnabled = false, SecurityStamp = Guid.NewGuid().ToString() }; var hasher = new PasswordHasher <ApplicationUser>(); var hashedPassword = hasher.HashPassword(user, "admin"); user.PasswordHash = hashedPassword; var hasAdminRole = _context.Roles.Any(roles => roles.Name == "Admin"); if (!hasAdminRole) { roleStore.CreateAsync(new IdentityRole { Name = "Admin", NormalizedName = "admin" }); } var hasSuperUser = _context.Users.Any(u => u.NormalizedUserName == user.UserName); if (!hasSuperUser) { userStore.CreateAsync(user); userStore.AddToRoleAsync(user, "Admin"); } _context.SaveChangesAsync(); return(Task.CompletedTask); }
public void SeedSuperUser() { var hasher = new PasswordHasher <ApplicationUser>(); var user = new ApplicationUser { UserName = "******", NormalizedUserName = "******", Email = "*****@*****.**", NormalizedEmail = "*****@*****.**", EmailConfirmed = true, LockoutEnabled = false, SecurityStamp = Guid.NewGuid().ToString(), }; var hashedPassword = hasher.HashPassword(user, "Test12!"); user.PasswordHash = hashedPassword; var roleStore = new RoleStore <IdentityRole>(_context); var isAdminRoleExists = _context.Roles.Any(r => r.Name == "Admin"); if (!isAdminRoleExists) { roleStore.CreateAsync(new IdentityRole { Name = "Admin", NormalizedName = "Admin" }).Wait(); } var userStore = new UserStore <ApplicationUser>(_context); var isSuperAdminExists = _context.Users.Any(u => u.UserName == user.UserName); if (!isSuperAdminExists) { userStore.CreateAsync(user).Wait(); userStore.AddToRoleAsync(user, "Admin").Wait(); } _context.SaveChangesAsync().Wait(); }
public void Seed() { string[] roles = new string[] { "methodist", "teacher", "student" }; foreach (string role in roles) { var roleStore = new RoleStore <IdentityRole>(_context); if (!_context.Roles.Any(r => r.Name == role)) { roleStore.CreateAsync(new IdentityRole { Name = role, NormalizedName = role.ToUpper() }).Wait(); } } var user = new User { UserName = "******", NormalizedUserName = "******", Email = "*****@*****.**", NormalizedEmail = "*****@*****.**", EmailConfirmed = true, SecurityStamp = Guid.NewGuid().ToString(), IsConfirmed = true }; if (!_context.Users.Any(u => u.UserName == user.UserName)) { var password = new PasswordHasher <User>(); var hashed = password.HashPassword(user, "root"); user.PasswordHash = hashed; var userStore = new UserStore <User>(_context); var result = userStore.CreateAsync(user); userStore.AddToRoleAsync(user, roles[0]).Wait(); } _context.SaveChangesAsync(); }
public async void Seed() { string[] roles = new string[] { "Admin", "Staff", "Parent", "Student" }; //var roleStore = new RoleStore<IdentityRole>(db); foreach (string r in roles) { if (!db.Roles.Any(x => x.Name == r)) { db.Roles.Add(new IdentityRole { Name = r, NormalizedName = r.ToUpper() }); } } if (!db.Users.Any(x => x.UserName == "Admin")) { var userStore = new UserStore <IdentityUser>(db); var hasher = new PasswordHasher <IdentityUser>(); var user = new IdentityUser { UserName = "******", NormalizedUserName = "******" }; user.PasswordHash = hasher.HashPassword(user, "@Open1234"); await userStore.CreateAsync(user); await userStore.AddToRoleAsync(user, "Admin"); } if (!db.Users.Any(x => x.UserName == "esad")) { var userStore = new UserStore <IdentityUser>(db); var hasher = new PasswordHasher <IdentityUser>(); var user = new IdentityUser { UserName = "******", NormalizedUserName = "******" }; user.PasswordHash = hasher.HashPassword(user, "@Open1234"); await userStore.CreateAsync(user); await userStore.AddToRoleAsync(user, "Staff"); } await db.SaveChangesAsync(); }
public void WhenRemoveUserFromRole_ThenDoNotDeleteRole_BugFix() { var user = new IdentityUser("Lukz 05"); var role = new IdentityRole("ADM05"); var store = new UserStore <IdentityUser>(_session); var roleStore = new RoleStore <IdentityRole>(_session); roleStore.CreateAsync(role); store.CreateAsync(user); store.AddToRoleAsync(user, "ADM05"); Assert.IsTrue(_session.Query <IdentityRole>().Any(x => x.Name == "ADM05")); Assert.IsTrue(_session.Query <IdentityUser>().Any(x => x.UserName == "Lukz 05")); Assert.IsTrue(store.IsInRoleAsync(user, "ADM05").Result); var result = store.RemoveFromRoleAsync(user, "ADM05"); Assert.IsNull(result.Exception); Assert.IsFalse(store.IsInRoleAsync(user, "ADM05").Result); Assert.IsTrue(_session.Query <IdentityUser>().Any(x => x.UserName == "Lukz 05")); Assert.IsTrue(_session.Query <IdentityRole>().Any(x => x.Name == "ADM05")); }
void SeedPatient1() { try { var patient1 = new AppUser { UserName = "******", Surname = "Kowalska1", City = "Świecie", ZipCode = "86-100", NormalizedUserName = "******", Email = "*****@*****.**", NormalizedEmail = "*****@*****.**", EmailConfirmed = true, LockoutEnabled = false, SecurityStamp = Guid.NewGuid().ToString() }; if (!context.Users.Any(u => u.UserName == "Patient1")) { var userStore = new UserStore <AppUser>(context); var password = new PasswordHasher <AppUser>(); var hashed = password.HashPassword(patient1, "Sekret123@"); patient1.PasswordHash = hashed; userStore.CreateAsync(patient1).Wait(); userStore.AddToRoleAsync(patient1, "Pacjent").Wait(); } context.SaveChanges(); } catch (Exception ex) { } }
public async Task Seed(DatabaseContext context) { var roles = new List <string> { "Manager", "User" }; var user = new User { UserName = "******", NormalizedUserName = "******", LockoutEnabled = false, SecurityStamp = Guid.NewGuid().ToString() }; var roleStore = new RoleStore <IdentityRole>(context); foreach (var roleName in roles) { if (!roleStore.Roles.Any(e => e.Name == roleName)) { await roleStore.CreateAsync(new IdentityRole(roleName) { NormalizedName = roleName.ToUpper() }); } } if (!context.Users.Any(u => u.UserName == user.UserName)) { var password = new PasswordHasher <User>(); var hashed = password.HashPassword(user, "+"); user.PasswordHash = hashed; using var userStore = new UserStore <User>(context); await userStore.CreateAsync(user); await userStore.AddToRoleAsync(user, "Manager"); } await context.SaveChangesAsync(); }
public async void SeedAdminUser() { var user = new ApplicationUser { UserName = "******", NormalizedUserName = "******", Email = "*****@*****.**", NormalizedEmail = "*****@*****.**", FirstName = "David", LastName = "Buckley", EmailConfirmed = true, LockoutEnabled = false, SecurityStamp = Guid.NewGuid().ToString() }; var roleStore = new RoleStore <IdentityRole>(_context); if (!_context.Roles.Any(r => r.Name == "admin" || r.Name == "manager" || r.Name == "agent")) { await roleStore.CreateAsync(new IdentityRole { Name = "admin", NormalizedName = "admin" }); await roleStore.CreateAsync(new IdentityRole { Name = "manager", NormalizedName = "manager" }); await roleStore.CreateAsync(new IdentityRole { Name = "agent", NormalizedName = "agent" }); } if (!_context.Users.Any(u => u.UserName == user.UserName)) { var password = new PasswordHasher <ApplicationUser>(); var hashed = password.HashPassword(user, "Test12345!"); user.PasswordHash = hashed; var userStore = new UserStore <ApplicationUser>(_context); await userStore.CreateAsync(user); userStore.AddToRoleAsync(user, "admin"); } await _context.SaveChangesAsync(); }
public async Task SeedAdminUser() { await _context.Database.MigrateAsync(); var user = new ApplicationUser { UserName = "******", NormalizedUserName = "******", Email = "*****@*****.**", NormalizedEmail = "*****@*****.**", EmailConfirmed = true, LockoutEnabled = false, SecurityStamp = Guid.NewGuid().ToString(), UserRegisteredDate = DateTime.Now, UserFullName = "Hamid Mosalla", UserGender = "Male" }; var roleStore = new RoleStore <IdentityRole>(_context); if (!_context.Roles.Any(r => r.Name == "admin")) { await roleStore.CreateAsync(new IdentityRole { Name = "admin", NormalizedName = "admin" }); } if (!_context.Users.Any(u => u.UserName == user.UserName)) { var password = new PasswordHasher <ApplicationUser>(); var hashed = password.HashPassword(user, "Mc2^6csQ^U88H5pz"); user.PasswordHash = hashed; var userStore = new UserStore <ApplicationUser>(_context); await userStore.CreateAsync(user); await userStore.AddToRoleAsync(user, "admin"); } await _context.SaveChangesAsync(); }
public async Task Test_RemoveFromRoleAsync() { // prepare using var userStore = new UserStore(Connection); using var roleStore = new RoleStore(Connection); var role1 = new IdentityRole <long> { Name = "name" }; await roleStore.CreateAsync(role1, CancellationToken.None); var user = new IdentityUser <long> { UserName = "******" }; await userStore.CreateAsync(user, CancellationToken.None); await userStore.AddToRoleAsync(user, "name", CancellationToken.None); // act await userStore.RemoveFromRoleAsync(user, "name", CancellationToken.None); // assert Assert.False(await userStore.IsInRoleAsync(user, "name", CancellationToken.None)); }
public async System.Threading.Tasks.Task <OperationResult <Company> > CreateCompany(Company company) { return(await System.Threading.Tasks.Task.Factory.StartNew <OperationResult <Company> >(() => { OperationResult <Company> result = new OperationResult <Company>(); try { company.OwnerId = CurrentUser.Id; Company created = CompaniesRepository.CreateOrUpdate(company); if (created.Id > 0) { UserStore.AddToRoleAsync(CurrentUser, RoleNames.CompanyOwner); result.SingleResult = created; result.Result = true; } } catch (Exception ex) { LoggingService.Log(ex); } return result; })); }
public static async void Initialize(ApplicationDbContext context, UserManager <ApplicationUser> userManager) { context.Database.EnsureCreated(); //if (context.Users.Any()) //{ // return; //} var roles = new string[] { "User", "Admin" }; foreach (var role in roles) { var roleStore = new RoleStore <IdentityRole>(context); await roleStore.CreateAsync(new IdentityRole() { Name = role, NormalizedName = role.ToLower() }); var user = new ApplicationUser { UserName = string.Concat(role, "@smetko.bg").ToLower(), NormalizedUserName = string.Concat(role, "@smetko.bg").ToLower(), Email = string.Concat(role, "@smetko.bg"), NormalizedEmail = string.Concat(role, "@smetko.bg").ToLower(), EmailConfirmed = true, LockoutEnabled = false, SecurityStamp = Guid.NewGuid().ToString() }; var userStore = new UserStore <ApplicationUser>(context); await userStore.AddToRoleAsync(user, role.ToLower()); await userManager.CreateAsync(user, "parola"); } }
public async void SeedAdminUser() { var user = new ApplicationUser { Title = "Mr", FirstName = "Muhammad", LastName = "Aamir", UserName = "******", NormalizedUserName = "******", Email = "*****@*****.**", NormalizedEmail = "*****@*****.**", EmailConfirmed = true, LockoutEnabled = false, SecurityStamp = Guid.NewGuid().ToString() }; var roleStore = new RoleStore <IdentityRole>(_context); if (!_context.Roles.Any(r => r.Name == "Admin")) { await roleStore.CreateAsync(new IdentityRole { Name = "Admin", NormalizedName = "ADMIN" }); } if (!_context.Users.Any(u => u.UserName == user.UserName)) { var password = new PasswordHasher <ApplicationUser>(); var hashed = password.HashPassword(user, "Shararti14321**"); user.PasswordHash = hashed; var userStore = new UserStore <ApplicationUser>(_context); await userStore.CreateAsync(user); await userStore.AddToRoleAsync(user, "Admin"); } await _context.SaveChangesAsync(); }
private static ApplicationUser CreateUser(IdentityDatabaseContext context, string login, string password, string eMail, string role) { var user = new ApplicationUser { UserName = login, Email = eMail, NormalizedUserName = login.Normalize(), NormalizedEmail = eMail.Normalize(), EmailConfirmed = false, LockoutEnabled = false, SecurityStamp = Guid.NewGuid().ToString(), }; var passwordHasher = new PasswordHasher <ApplicationUser>(); user.PasswordHash = passwordHasher.HashPassword(user, password); var userStore = new UserStore <ApplicationUser>(context); userStore.CreateAsync(user).Wait(); userStore.AddToRoleAsync(user, role).Wait(); context.SaveChanges(); return(user); }
public async Task SeedUserAsync() { var userStore = new UserStore <ApplicationUser>(_context); var hasher = new PasswordHasher <ApplicationUser>(); for (int i = 0; i < 20; i++) { if (!_context.Users.Any(c => c.UserName == $"User{i}")) { var user = new ApplicationUser() { UserName = $"User{i}", NormalizedUserName = $"User{i}", DisplayName = $"ユーザー{i}さん" }; var hashed = hasher.HashPassword(user, $"userPass{i}"); user.PasswordHash = hashed; await userStore.CreateAsync(user); await userStore.AddToRoleAsync(user, "admin"); } } await _context.SaveChangesAsync(); }
public static async Task Seed(IdentityServerDbContext 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, ShippingAddress = new Core.SharedKernel.AddressInfo(Guid.NewGuid(), "123 Address", "HCM", "TB district", "7000", "VN") }; rootUser.PasswordHash = password.HashPassword(rootUser, "root"); await userStore.CreateAsync(rootUser); await userStore.AddToRoleAsync(rootUser, "admin"); }
public async Task ShouldThrow_WritingTo_Database() { // Deleting the role should fail because of a table lock var currentTimeOut = _appDb.DbContext.CommandTimeOut; using (var da = (DataAccessAdapter)_appDb.DbContext.GetNewAdapter()) { await da.StartTransactionAsync(IsolationLevel.Serializable, "transaction1"); da.SaveTransaction("transaction1"); // lock the table for completely await da.ExecuteSQLAsync(CancellationToken.None, $"SELECT 1 FROM [{_appDb.DbContext.Schema}].[{da.GetPersistentTableName(new IdentityRoleEntity())}] WITH (TABLOCKX)"); // Trying to update will fail because the table is locked _appDb.DbContext.CommandTimeOut = 2; Assert.ThrowsAsync <Exception>(async() => await _userStore.RemoveFromRoleAsync(_user, Constants.RoleName.TournamentManager, CancellationToken.None)); Assert.ThrowsAsync <Exception>(async() => await _userStore.AddToRoleAsync(_user, Constants.RoleName.TournamentManager, CancellationToken.None)); da.Rollback("transaction1"); } _appDb.DbContext.CommandTimeOut = currentTimeOut; }
public static void Initialize(ApplicationDbContext db, IServiceProvider serviceProvider) { var roleStore = new RoleStore <IdentityRole>(db); if (!db.Roles.Any(r => r.Name == "Admin")) { roleStore.CreateAsync(new IdentityRole { Name = "Admin", NormalizedName = "Admin" }); } db.SaveChanges(); if (!db.Roles.Any(r => r.Name == "Member")) { roleStore.CreateAsync(new IdentityRole { Name = "Member", NormalizedName = "Member" }); } db.SaveChanges(); if (!db.Users.Any(u => u.UserName == "a")) { var adminProfile = new ApplicationUser { UserName = "******", NormalizedUserName = "******", FirstName = "Admin", LastName = "User", Email = "[email protected]", NormalizedEmail = "[email protected]", EmailConfirmed = true, LockoutEnabled = false, SecurityStamp = Guid.NewGuid().ToString() }; db.Users.Add(adminProfile); var password = new PasswordHasher <ApplicationUser>(); var hashed = password.HashPassword(adminProfile, "P@ssw0rd"); adminProfile.PasswordHash = hashed; var userStore = new UserStore <ApplicationUser>(db); var result = userStore.CreateAsync(adminProfile); userStore.AddToRoleAsync(adminProfile, "Admin"); userStore.AddToRoleAsync(adminProfile, "Member"); db.SaveChanges(); } if (!db.Users.Any(u => u.UserName == "m")) { var memberProfile = new ApplicationUser { UserName = "******", NormalizedUserName = "******", FirstName = "Member", LastName = "User", Email = "[email protected]", NormalizedEmail = "[email protected]", EmailConfirmed = true, LockoutEnabled = false, SecurityStamp = Guid.NewGuid().ToString() }; db.Users.Add(memberProfile); var password = new PasswordHasher <ApplicationUser>(); var hashed = password.HashPassword(memberProfile, "P@ssw0rd"); memberProfile.PasswordHash = hashed; var userStore = new UserStore <ApplicationUser>(db); var result = userStore.CreateAsync(memberProfile); userStore.AddToRoleAsync(memberProfile, "Member"); db.SaveChanges(); } if (!db.Activities.Any()) { db.Activities.Add (new Activity() { Description = "Senior's Golf Tournament", CreationDate = DateTime.Now }); db.Activities.Add(new Activity() { Description = "Leadership General Assembly Meeting", CreationDate = DateTime.Now }); db.Activities.Add(new Activity() { Description = "Youth Bowling Tournament", CreationDate = DateTime.Now }); db.Activities.Add(new Activity() { Description = "Young ladies cooking lessons", CreationDate = DateTime.Now }); db.Activities.Add(new Activity() { Description = "Youth craft lessons", CreationDate = DateTime.Now }); db.Activities.Add(new Activity() { Description = "Youth choir practice", CreationDate = DateTime.Now }); db.Activities.Add(new Activity() { Description = "Lunch", CreationDate = DateTime.Now }); db.Activities.Add(new Activity() { Description = "Pancake Breakfast", CreationDate = DateTime.Now }); db.Activities.Add(new Activity() { Description = "Swimming Lessons for the youth", CreationDate = DateTime.Now }); db.Activities.Add(new Activity() { Description = "Swimming Exercise for parents", CreationDate = DateTime.Now }); db.Activities.Add(new Activity() { Description = "Bingo Tournament", CreationDate = DateTime.Now }); db.Activities.Add(new Activity() { Description = "BBQ Lunch", CreationDate = DateTime.Now }); db.Activities.Add(new Activity() { Description = "Garage Sale", CreationDate = DateTime.Now }); db.SaveChanges(); } ; if (!db.Events.Any()) { db.Events.Add(new Event { EventStart = new DateTime(2017, 4, 4, 8, 30, 0), EventEnd = new DateTime(2017, 4, 4, 10, 30, 0), Username = "******", CreationDate = DateTime.Now, IsActive = true, ActivityId = db.Activities.FirstOrDefault(f => f.Description == "Senior's Golf Tournament").ActivityId }); db.Events.Add(new Event { EventStart = new DateTime(2017, 4, 5, 8, 30, 0), EventEnd = new DateTime(2017, 4, 5, 10, 30, 0), Username = "******", CreationDate = DateTime.Now, IsActive = true, ActivityId = db.Activities.FirstOrDefault(f => f.Description == "Leadership General Assembly Meeting").ActivityId }); db.Events.Add(new Event { EventStart = new DateTime(2017, 4, 7, 17, 30, 0), EventEnd = new DateTime(2017, 4, 7, 19, 15, 0), Username = "******", CreationDate = DateTime.Now, IsActive = true, ActivityId = db.Activities.FirstOrDefault(f => f.Description == "Youth Bowling Tournament").ActivityId }); db.Events.Add(new Event { EventStart = new DateTime(2017, 4, 7, 19, 00, 0), EventEnd = new DateTime(2017, 4, 7, 20, 00, 0), Username = "******", CreationDate = DateTime.Now, IsActive = true, ActivityId = db.Activities.FirstOrDefault(f => f.Description == "Young ladies cooking lessons").ActivityId }); db.Events.Add(new Event { EventStart = new DateTime(2017, 4, 8, 8, 30, 0), EventEnd = new DateTime(2017, 4, 8, 10, 30, 0), Username = "******", CreationDate = DateTime.Now, IsActive = true, ActivityId = db.Activities.FirstOrDefault(f => f.Description == "Youth craft lessons").ActivityId }); } ; db.SaveChanges(); }
public async void SeedAdminUser() { var user = new IdentityUser { UserName = "******", NormalizedUserName = "******", Email = "*****@*****.**", NormalizedEmail = "*****@*****.**", EmailConfirmed = true, LockoutEnabled = false, SecurityStamp = Guid.NewGuid().ToString() }; var roleStore = new RoleStore <IdentityRole>(_context); if (!_context.Roles.Any(r => r.Name == "admin")) { await roleStore.CreateAsync(new IdentityRole { Name = "admin", NormalizedName = "admin" }); } if (!_context.Users.Any(u => u.UserName == user.UserName)) { var password = new PasswordHasher <IdentityUser>(); var hashed = password.HashPassword(user, "hola"); user.PasswordHash = hashed; var userStore2 = new UserStore <IdentityUser>(_context); await userStore2.CreateAsync(user); await userStore2.AddToRoleAsync(user, "admin"); } await _context.SaveChangesAsync(); var userStore = new UserStore <IdentityUser>(_context); var password2 = new PasswordHasher <IdentityUser>(); var hashed2 = password2.HashPassword(user, "hola"); IdentityUser user0, user1; if (_context.Users.Any(u => u.UserName == "*****@*****.**")) { user0 = _context.Users.First(u => u.UserName == "*****@*****.**"); } else { user0 = new IdentityUser { UserName = "******", Email = "*****@*****.**", PasswordHash = hashed2 }; var result = userStore.CreateAsync(user0).Result; } if (_context.Users.Any(u => u.UserName == "*****@*****.**")) { user1 = _context.Users.First(u => u.UserName == "*****@*****.**"); } else { user1 = new IdentityUser { UserName = "******", Email = "*****@*****.**", PasswordHash = hashed2 }; var result = userStore.CreateAsync(user1).Result; } }
public async void IsInRoleAsync_GivenAUserAndARole_ReturnsTrueIfUserIsInRole() { 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, "User"); var isInRole = await userStore.IsInRoleAsync(user, "User"); isInRole.Should().BeTrue(); }
private static void CreateUsers(ApplicationDbContext context) { var hasher = new PasswordHasher <ApplicationUser>(); var store = new UserStore <ApplicationUser>(context); if (!context.Users.Any()) { ApplicationUser[] users = { new ApplicationUser { Id = "1a", FName = "Stephen", LName = "King", Email = "*****@*****.**", NormalizedEmail = "*****@*****.**", UserName = "******", NormalizedUserName = "******", SecurityStamp = Guid.NewGuid().ToString() }, new ApplicationUser { Id = "2b", FName = "Jason", LName = "Voorhees", Email = "*****@*****.**", NormalizedEmail = "*****@*****.**", UserName = "******", NormalizedUserName = "******", SecurityStamp = Guid.NewGuid().ToString() }, new ApplicationUser { Id = "3c", FName = "Mike", LName = "Myers", Email = "*****@*****.**", NormalizedEmail = "*****@*****.**", UserName = "******", NormalizedUserName = "******", SecurityStamp = Guid.NewGuid().ToString() }, new ApplicationUser { Id = "4d", FName = "Freddy", LName = "Krueger", Email = "*****@*****.**", NormalizedEmail = "*****@*****.**", UserName = "******", NormalizedUserName = "******", SecurityStamp = Guid.NewGuid().ToString() }, new ApplicationUser { Id = "5e", FName = "Bubba", LName = "Sawyer", Email = "*****@*****.**", NormalizedEmail = "*****@*****.**", UserName = "******", NormalizedUserName = "******", SecurityStamp = Guid.NewGuid().ToString() } }; context.Users.AddRange(users); foreach (var user in users) { user.PasswordHash = hasher.HashPassword(user, "qwerty123!"); } store.AddToRoleAsync(users[0], "ADMIN"); store.AddToRoleAsync(users[1], "MANAGER"); store.AddToRoleAsync(users[2], "WORKER"); store.AddToRoleAsync(users[3], "WORKER"); store.AddToRoleAsync(users[4], "MANAGER"); } }
public async void Seed() { var admin = new ApplicationUser { UserName = "******", NormalizedUserName = "******", Email = "*****@*****.**", NormalizedEmail = "*****@*****.**", EmailConfirmed = true, LockoutEnabled = false, SecurityStamp = Guid.NewGuid().ToString() }; var roleStore = new RoleStore <IdentityRole>(_appContext); if (!_appContext.Roles.Any(r => r.Name == "admin")) { await roleStore.CreateAsync(new IdentityRole { Name = "admin", NormalizedName = "admin" }); } if (!_appContext.Users.Any(u => u.UserName == admin.UserName)) { var password = new PasswordHasher <ApplicationUser>(); var hashed = password.HashPassword(admin, "admin15"); admin.PasswordHash = hashed; var userStore = new UserStore <ApplicationUser>(_appContext); await userStore.CreateAsync(admin); await userStore.AddToRoleAsync(admin, "admin"); var realUser = new User { UserId = admin.Id, FullName = "Administrator", Username = "******", Email = admin.Email }; _yoctoContext.Users.Add(realUser); } if (!_yoctoContext.DeviceTypes.Any()) { var types = new List <DeviceType> { new DeviceType { Id = Guid.NewGuid().ToString(), Name = "RPi3", Description = "Raspberry Pi 3" } }; _yoctoContext.DeviceTypes.AddRange(types); } if (!_yoctoContext.ReadingTypes.Any()) { var types = new List <ReadingType> { new ReadingType { Id = Guid.NewGuid().ToString(), Name = "Temperature OneWire", Description = "Temperature sensor reading using OneWire protocol." } }; _yoctoContext.ReadingTypes.AddRange(types); } await _appContext.SaveChangesAsync(); await _yoctoContext.SaveChangesAsync(); }
public async Task<ActionResult> addRole(string userID, string roleID) { ajaxReturnData data = new ajaxReturnData(); try { using (ApplicationDbContext DB = new ApplicationDbContext()) { ApplicationUser user = new ApplicationUser(); var store = new UserStore<ApplicationUser>(DB); UserManager<ApplicationUser> um = new UserManager<ApplicationUser>(store); user = um.FindById(userID); var RoleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(DB)); IdentityRole role = RoleManager.FindById(roleID); await store.AddToRoleAsync(user, role.Name); await store.UpdateAsync(user); data.statusCode = (int)statusCodes.successRun; data.message = "Role '" + role.Name + "' added to user '" + user.UserName + "'"; } } catch(Exception ex) { data.statusCode = (int)statusCodes.fail; data.message = "Failed to add role to user; Error is: "+ ex.Message; } return Json(data); }
public async Task AddToRoleAsync([FromBody] User user, string role, [FromServices] WebStoreContext db) { await _UserStore.AddToRoleAsync(user, role); await db.SaveChangesAsync(); //сохранение изменений в БД - здесь не через UserStore.UpdateAsync ! (т.к. видимо затрагивает не только пользователя, но и другие таблицы в БД) }
public Task AddToRoleAsync(IUser user, string roleName) { return(_userStore.AddToRoleAsync((MongoApplicationUser)user, roleName)); }
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 ActionResult UpdateUser(string Id, string UserName, string RoleName, string roleId) { try { var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(dbEntity)); using (var store = new UserStore<ApplicationUser>(new ApplicationDbContext())) { var userReloaded = store.Users.Where(u => u.Id == Id).FirstOrDefault(); userReloaded.Roles.Clear(); var result = store.AddToRoleAsync(userReloaded, RoleName); var result2 = store.UpdateAsync(userReloaded); if (result.IsCompleted && result2.IsCompleted) { store.Context.SaveChanges(); } } var userVm = new { Id = Id, UserName = UserName, RoleName = RoleName }; return Json(new { Result = "OK", Data = userVm, Message = "Cambios Guardados." }); } catch (Exception e) { return Json(new { Result = "ERROR", Message = e.Message }); } }
public void WhenRemoveUserFromRole_ThenDoNotDeleteRole_BugFix() { var user = new IdentityUser("Lukz 05"); var role = new IdentityRole("ADM05"); var store = new UserStore<IdentityUser>(_session); var roleStore = new RoleStore<IdentityRole>(_session); roleStore.CreateAsync(role); store.CreateAsync(user); store.AddToRoleAsync(user, "ADM05"); Assert.IsTrue(_session.Query<IdentityRole>().Any(x => x.Name == "ADM05")); Assert.IsTrue(_session.Query<IdentityUser>().Any(x => x.UserName == "Lukz 05")); Assert.IsTrue(store.IsInRoleAsync(user, "ADM05").Result); var result = store.RemoveFromRoleAsync(user, "ADM05"); Assert.IsNull(result.Exception); Assert.IsFalse(store.IsInRoleAsync(user, "ADM05").Result); Assert.IsTrue(_session.Query<IdentityUser>().Any(x => x.UserName == "Lukz 05")); Assert.IsTrue(_session.Query<IdentityRole>().Any(x => x.Name == "ADM05")); }
public Task AddToRoleAsync(IUser user, string roleName, CancellationToken cancellationToken) { return(innerStore.AddToRoleAsync((WrappedIdentityUser)user, roleName, cancellationToken)); }
public static async Task SeedData(this IApplicationBuilder builder) { var provider = builder.ApplicationServices; var scopeFactory = provider.GetRequiredService <IServiceScopeFactory>(); using (var scope = scopeFactory.CreateScope()) using (var dbContext = scope.ServiceProvider.GetService <ApplicationDbContext>()) { var user = new ApplicationUser { UserName = "******", NormalizedUserName = "******", Email = "*****@*****.**", NormalizedEmail = "*****@*****.**", EmailConfirmed = true, LockoutEnabled = false, SecurityStamp = Guid.NewGuid().ToString() }; var adminUser = new ApplicationUser { UserName = "******", NormalizedUserName = "******", Email = "*****@*****.**", NormalizedEmail = "*****@*****.**", EmailConfirmed = true, LockoutEnabled = false, SecurityStamp = Guid.NewGuid().ToString() }; var roleStore = new RoleStore <IdentityRole>(dbContext); if (!dbContext.Roles.Any(r => r.Name == "admin")) { await roleStore.CreateAsync(new IdentityRole { Name = "admin", NormalizedName = "admin" }); } if (!dbContext.Roles.Any(r => r.Name == "user")) { await roleStore.CreateAsync(new IdentityRole { Name = "user", NormalizedName = "user" }); } if (!dbContext.Users.Any(u => u.UserName == user.UserName)) { var password = new PasswordHasher <ApplicationUser>(); var hashed = password.HashPassword(user, "password"); user.PasswordHash = hashed; var userStore = new UserStore <ApplicationUser>(dbContext); await userStore.CreateAsync(user); await userStore.AddToRoleAsync(user, "user"); } if (!dbContext.Users.Any(u => u.UserName == adminUser.UserName)) { var password = new PasswordHasher <ApplicationUser>(); var hashed = password.HashPassword(adminUser, "password"); adminUser.PasswordHash = hashed; var userStore = new UserStore <ApplicationUser>(dbContext); await userStore.CreateAsync(adminUser); await userStore.AddToRoleAsync(adminUser, "admin"); } await dbContext.SaveChangesAsync(); } }
private static async Task AddRole(ApplicationUser user, string role, ApplicationDbContext dbContext) { var userStore = new UserStore <ApplicationUser, ApplicationRole, ApplicationDbContext, int>(dbContext); await userStore.AddToRoleAsync(user, role); }
public async Task AddToRoleAsync([FromBody] User user, string roleName) { await _userStore.AddToRoleAsync(user, roleName); }
public void GivenHaveRoles_WhenDeleteUser_ThenDeletingCausesNoCascade() { var user = new IdentityUser("Lukz 04"); var role = new IdentityRole("ADM"); var store = new UserStore<IdentityUser>(_session); var roleStore = new RoleStore<IdentityRole>(_session); roleStore.CreateAsync(role); store.CreateAsync(user); store.AddToRoleAsync(user, "ADM"); Assert.IsTrue(_session.Query<IdentityRole>().Any(x => x.Name == "ADM")); Assert.IsTrue(_session.Query<IdentityUser>().Any(x => x.UserName == "Lukz 04")); var result = store.DeleteAsync(user); Assert.IsNull(result.Exception); Assert.IsFalse(this._session.Query<IdentityUser>().Any(x => x.UserName == "Lukz 04")); Assert.IsTrue(this._session.Query<IdentityRole>().Any(x => x.Name == "ADM")); }
public async Task UserStorePublicNullCheckTest() { Assert.Throws <ArgumentNullException>("factory", () => new UserStore <IdentityUser>(null)); var store = new UserStore <IdentityUser>(CreateTestContext()); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.GetUserIdAsync(null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.GetUserNameAsync(null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.SetUserNameAsync(null, null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.CreateAsync(null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.UpdateAsync(null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.DeleteAsync(null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.AddClaimsAsync(null, null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.ReplaceClaimAsync(null, null, null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.RemoveClaimsAsync(null, null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.GetClaimsAsync(null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.GetLoginsAsync(null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.GetRolesAsync(null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.AddLoginAsync(null, null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.RemoveLoginAsync(null, null, null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.AddToRoleAsync(null, null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.RemoveFromRoleAsync(null, null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.IsInRoleAsync(null, null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.GetPasswordHashAsync(null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.SetPasswordHashAsync(null, null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.GetSecurityStampAsync(null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.SetSecurityStampAsync(null, null)); await Assert.ThrowsAsync <ArgumentNullException>("login", async() => await store.AddLoginAsync(new IdentityUser("fake"), null)); await Assert.ThrowsAsync <ArgumentNullException>("claims", async() => await store.AddClaimsAsync(new IdentityUser("fake"), null)); await Assert.ThrowsAsync <ArgumentNullException>("claims", async() => await store.RemoveClaimsAsync(new IdentityUser("fake"), null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.GetEmailConfirmedAsync(null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.SetEmailConfirmedAsync(null, true)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.GetEmailAsync(null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.SetEmailAsync(null, null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.GetPhoneNumberAsync(null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.SetPhoneNumberAsync(null, null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.GetPhoneNumberConfirmedAsync(null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.SetPhoneNumberConfirmedAsync(null, true)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.GetTwoFactorEnabledAsync(null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.SetTwoFactorEnabledAsync(null, true)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.GetAccessFailedCountAsync(null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.GetLockoutEnabledAsync(null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.SetLockoutEnabledAsync(null, false)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.GetLockoutEndDateAsync(null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.SetLockoutEndDateAsync(null, new DateTimeOffset())); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.ResetAccessFailedCountAsync(null)); await Assert.ThrowsAsync <ArgumentNullException>("user", async() => await store.IncrementAccessFailedCountAsync(null)); await Assert.ThrowsAsync <ArgumentException>("normalizedRoleName", async() => await store.AddToRoleAsync(new IdentityUser("fake"), null)); await Assert.ThrowsAsync <ArgumentException>("normalizedRoleName", async() => await store.RemoveFromRoleAsync(new IdentityUser("fake"), null)); await Assert.ThrowsAsync <ArgumentException>("normalizedRoleName", async() => await store.IsInRoleAsync(new IdentityUser("fake"), null)); await Assert.ThrowsAsync <ArgumentException>("normalizedRoleName", async() => await store.AddToRoleAsync(new IdentityUser("fake"), "")); await Assert.ThrowsAsync <ArgumentException>("normalizedRoleName", async() => await store.RemoveFromRoleAsync(new IdentityUser("fake"), "")); await Assert.ThrowsAsync <ArgumentException>("normalizedRoleName", async() => await store.IsInRoleAsync(new IdentityUser("fake"), "")); }
public async Task AddToRoleAsync([FromBody] User user, string role, [FromServices] WebStoreDB db) { await _UserStore.AddToRoleAsync(user, role); await db.SaveChangesAsync(); }
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"); }