public async Task CanFindByLogin()
{
var type11 = new ElasticIdentityUserLogin("loginProvider1", "providerKey1", "Login Provider 1");
var type12 = new ElasticIdentityUserLogin("loginProvider1", "providerKey2", "Login Provider 1");
var type21 = new ElasticIdentityUserLogin("loginProvider2", "providerKey1", "Login Provider 2");
// user type 11
ElasticIdentityUser user11 = new ElasticIdentityUser(nameof(user11));
user11.Logins.Add(type11);
await _store.CreateAsync(user11, CancellationToken.None);
// user type 12
ElasticIdentityUser user12 = new ElasticIdentityUser(nameof(user12));
user12.Logins.Add(type12);
user12.Logins.Add(type21);
await _store.CreateAsync(user12, CancellationToken.None);
// user type 21
ElasticIdentityUser user21 = new ElasticIdentityUser(nameof(user21));
user21.Logins.Add(type21);
user21.Logins.Add(type12);
await _store.CreateAsync(user21, CancellationToken.None);
_elasticClient.Indices.Refresh(_indexName);
var user = await _store.FindByLoginAsync(type11.LoginProvider, type11.ProviderKey, CancellationToken.None);
Assert.Equal(nameof(user11), user.UserName);
}
public async Task CanGetUsersWithClaims()
{
var claimType11 = new Claim("claimType1", "valueType1");
var claimType12 = new Claim("claimType2", "valueType1");
var claimType21 = new Claim("claimType1", "valueType2");
// user type 11
ElasticIdentityUser noClaimsUser11 = new ElasticIdentityUser(nameof(noClaimsUser11));
noClaimsUser11.Claims.Add(new ElasticIdentityUserClaim(claimType11));
await _store.CreateAsync(noClaimsUser11, CancellationToken.None);
// user type 12
ElasticIdentityUser noClaimsUser12 = new ElasticIdentityUser(nameof(noClaimsUser12));
noClaimsUser12.Claims.Add(new ElasticIdentityUserClaim(claimType12));
noClaimsUser12.Claims.Add(new ElasticIdentityUserClaim(claimType21));
await _store.CreateAsync(noClaimsUser12, CancellationToken.None);
// user type 21
ElasticIdentityUser noClaimsUser21 = new ElasticIdentityUser(nameof(noClaimsUser21));
noClaimsUser21.Claims.Add(new ElasticIdentityUserClaim(claimType21));
noClaimsUser21.Claims.Add(new ElasticIdentityUserClaim(claimType12));
await _store.CreateAsync(noClaimsUser21, CancellationToken.None);
_elasticClient.Indices.Refresh(_indexName);
var users = await _store.GetUsersForClaimAsync(claimType11, CancellationToken.None);
Assert.Equal(nameof(noClaimsUser11), users.FirstOrDefault().UserName);
}
public async Task CanReplaceClaim()
{
ElasticIdentityUser noClaimsUser2 = new ElasticIdentityUser(nameof(noClaimsUser2));
await _store.CreateAsync(noClaimsUser2, CancellationToken.None);
var oldClaim = new Claim("testType", "testValue");
var newClaim = new Claim("newTestType", "newTestValue");
var user = await _store.FindByNameAsync(noClaimsUser2.NormalizedUserName, CancellationToken.None);
await _store.AddClaimsAsync(user, new[] { oldClaim }, CancellationToken.None);
await SaveToElastic(user);
user = await GetFromElastic(user.NormalizedUserName);
Assert.NotEmpty(user.Claims);
await _store.ReplaceClaimAsync(user, oldClaim, newClaim, CancellationToken.None);
await SaveToElastic(user);
user = await GetFromElastic(user.NormalizedUserName);
Assert.True(user.Claims.All(claim => claim.Type == newClaim.Type && claim.Value == newClaim.Value));
}
public async Task CanRemoveRoles()
{
const string roleName = "test";
ElasticIdentityUser noRolesUser = new ElasticIdentityUser(nameof(noRolesUser));
await _store.CreateAsync(noRolesUser, CancellationToken.None);
var user = await _store.FindByNameAsync(noRolesUser.NormalizedUserName, CancellationToken.None);
Assert.Empty(user.Roles);
await _store.AddToRoleAsync(user, roleName, CancellationToken.None);
await SaveToElastic(user);
//reload
user = await GetFromElastic(user.NormalizedUserName);
Assert.NotEmpty(user.Roles);
await _store.RemoveFromRoleAsync(user, roleName, CancellationToken.None);
await SaveToElastic(user);
user = await GetFromElastic(user.NormalizedUserName);
Assert.Empty(user.Roles);
}
public async Task <IActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl = null)
{
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(View("ExternalLoginFailure"));
}
var user = new ElasticIdentityUser(model.Email)
{
Email = model.Email
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation(6, "User created an account using {Name} provider.", info.LoginProvider);
return(RedirectToLocal(returnUrl));
}
}
AddErrors(result);
}
ViewData["ReturnUrl"] = returnUrl;
return(View(model));
}
public async Task <IActionResult> Register(RegisterViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
var user = new ElasticIdentityUser(model.UserName)
{
Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
// For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=532713
// Send an email with this link
//var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
//var callbackUrl = Url.Action(nameof(ConfirmEmail), "Account", new { userId = user.Id, code = code }, protocol: HttpContext.Request.Scheme);
//await _emailSender.SendEmailAsync(model.Email, "Confirm your account",
// $"Please confirm your account by clicking this link: <a href='{callbackUrl}'>link</a>");
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation(3, "User created a new account with password.");
return(RedirectToLocal(returnUrl));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task CanCreateUserWithoutConstraints()
{
ElasticIdentityUser superUser = new ElasticIdentityUser("!£$%^&*()_+\"/[]{}@~#?¬`¦|:;'ιϊνσα,.<>")
{
Email = "*****@*****.**"
};
var result = await _store.CreateAsync(superUser, CancellationToken.None);
Assert.True(result.Succeeded);
var user = await _store.FindByIdAsync(superUser.Id, CancellationToken.None);
Assert.Equal(superUser.Id, user.Id);
}
public async Task CannotCreateDuplicateUser()
{
ElasticIdentityUser deleteUser = new ElasticIdentityUser("deletedUser")
{
Email = "*****@*****.**",
DateDeleted = DateTimeOffset.UtcNow
};
await _store.CreateAsync(deleteUser, CancellationToken.None);
var result = await _store.CreateAsync(deleteUser, CancellationToken.None);
Assert.False(result.Succeeded);
}
public async Task CanRemoveLogin()
{
var loginInfo = new UserLoginInfo("loginProvider", "key-123", "Login Provider");
ElasticIdentityUser noLoginsUser = new ElasticIdentityUser(nameof(noLoginsUser));
await _store.AddLoginAsync(noLoginsUser, loginInfo, CancellationToken.None);
await _store.CreateAsync(noLoginsUser, CancellationToken.None);
var user = await _store.FindByNameAsync(noLoginsUser.NormalizedUserName, CancellationToken.None);
Assert.NotEmpty(user.Logins);
await _store.RemoveLoginAsync(user, loginInfo.LoginProvider, loginInfo.ProviderKey, CancellationToken.None);
await SaveToElastic(user);
user = await GetFromElastic(user.NormalizedUserName);
Assert.Empty(user.Logins);
}
public async Task CanRemoveClaim()
{
var claim = new Claim("testType", "testValue");
ElasticIdentityUser noClaimsUser = new ElasticIdentityUser(nameof(noClaimsUser));
await _store.AddClaimsAsync(noClaimsUser, new[] { claim }, CancellationToken.None);
await _store.CreateAsync(noClaimsUser, CancellationToken.None);
var user = await _store.FindByNameAsync(noClaimsUser.NormalizedUserName, CancellationToken.None);
Assert.NotEmpty(user.Claims);
await _store.RemoveClaimsAsync(user, new[] { claim }, CancellationToken.None);
await SaveToElastic(user);
user = await GetFromElastic(user.NormalizedUserName);
Assert.Empty(user.Claims);
}
private async Task SaveToElastic(ElasticIdentityUser user)
{
await _store.UpdateAsync(user, CancellationToken.None);
}
