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