public async Task ConcurrentUpdatesWillFailWithDetachedUser()
{
var options = new DbContextOptionsBuilder().UseSqlite($"Data Source=D{Guid.NewGuid()}.db").Options;
var user = CreateTestUser();
using (var db = new IdentityDbContext(options))
{
db.Database.EnsureCreated();
var manager = CreateManager(db);
IdentityResultAssert.IsSuccess(await manager.CreateAsync(user));
}
using (var db = new IdentityDbContext(options))
using (var db2 = new IdentityDbContext(options))
{
var manager1 = CreateManager(db);
var manager2 = CreateManager(db2);
var user2 = await manager2.FindByIdAsync(user.Id);
Assert.NotNull(user2);
Assert.NotSame(user, user2);
user.UserName = Guid.NewGuid().ToString();
user2.UserName = Guid.NewGuid().ToString();
IdentityResultAssert.IsSuccess(await manager1.UpdateAsync(user));
IdentityResultAssert.IsFailure(await manager2.UpdateAsync(user2), new IdentityErrorDescriber().ConcurrencyFailure());
db.Database.EnsureDeleted();
}
}
public async Task DeleteAModifiedRoleWillFail()
{
var options = new DbContextOptionsBuilder().UseSqlite($"Data Source=D{Guid.NewGuid()}.db").Options;
var role = new IdentityRole(Guid.NewGuid().ToString());
using (var db = new IdentityDbContext(options))
{
db.Database.EnsureCreated();
var manager = CreateRoleManager(db);
IdentityResultAssert.IsSuccess(await manager.CreateAsync(role));
}
using (var db = new IdentityDbContext(options))
using (var db2 = new IdentityDbContext(options))
{
var manager1 = CreateRoleManager(db);
var manager2 = CreateRoleManager(db2);
var role1 = await manager1.FindByIdAsync(role.Id);
var role2 = await manager2.FindByIdAsync(role.Id);
Assert.NotNull(role1);
Assert.NotNull(role2);
Assert.NotSame(role1, role2);
role1.Name = Guid.NewGuid().ToString();
IdentityResultAssert.IsSuccess(await manager1.UpdateAsync(role1));
IdentityResultAssert.IsFailure(await manager2.DeleteAsync(role2), new IdentityErrorDescriber().ConcurrencyFailure());
db.Database.EnsureDeleted();
}
}
public async Task DeleteAModifiedUserWillFail()
{
var user = CreateTestUser();
using (var db = CreateContext())
{
var manager = CreateUserManager(db);
IdentityResultAssert.IsSuccess(await manager.CreateAsync(user));
}
using (var db = CreateContext())
using (var db2 = CreateContext())
{
var manager1 = CreateUserManager(db);
var manager2 = CreateUserManager(db2);
var user1 = await manager1.FindByIdAsync(user.Id);
var user2 = await manager2.FindByIdAsync(user.Id);
Assert.NotNull(user1);
Assert.NotNull(user2);
Assert.NotSame(user1, user2);
user1.UserName = Guid.NewGuid().ToString();
IdentityResultAssert.IsSuccess(await manager1.UpdateAsync(user1));
IdentityResultAssert.IsFailure(await manager2.DeleteAsync(user2), new IdentityErrorDescriber().ConcurrencyFailure());
}
}
public async Task DeleteAModifiedRoleWillFail()
{
var role = new IdentityRole(Guid.NewGuid().ToString());
using (var db = CreateContext())
{
var manager = CreateRoleManager(db);
IdentityResultAssert.IsSuccess(await manager.CreateAsync(role));
}
using (var db = CreateContext())
using (var db2 = CreateContext())
{
var manager1 = CreateRoleManager(db);
var manager2 = CreateRoleManager(db2);
var role1 = await manager1.FindByIdAsync(role.Id);
var role2 = await manager2.FindByIdAsync(role.Id);
Assert.NotNull(role1);
Assert.NotNull(role2);
Assert.NotSame(role1, role2);
role1.Name = Guid.NewGuid().ToString();
IdentityResultAssert.IsSuccess(await manager1.UpdateAsync(role1));
IdentityResultAssert.IsFailure(await manager2.DeleteAsync(role2), new IdentityErrorDescriber().ConcurrencyFailure());
}
}
public async Task ConcurrentRoleUpdatesWillFailWithDetachedRole()
{
var role = new IdentityRole(Guid.NewGuid().ToString());
using (var db = CreateContext())
{
var manager = CreateRoleManager(db);
IdentityResultAssert.IsSuccess(await manager.CreateAsync(role));
}
using (var db = CreateContext())
using (var db2 = CreateContext())
{
var manager1 = CreateRoleManager(db);
var manager2 = CreateRoleManager(db2);
var role2 = await manager2.FindByIdAsync(role.Id);
Assert.NotNull(role);
Assert.NotNull(role2);
Assert.NotSame(role, role2);
role.Name = Guid.NewGuid().ToString();
role2.Name = Guid.NewGuid().ToString();
IdentityResultAssert.IsSuccess(await manager1.UpdateAsync(role));
IdentityResultAssert.IsFailure(await manager2.UpdateAsync(role2), IdentityErrorDescriber.Default.ConcurrencyFailure());
}
}
public async Task FailsIfContained(string password, params string[] phrases)
{
var manager = MockHelpers.TestUserManager <TestUser>();
var validator = new InvalidPhraseValidator <TestUser>(phrases);
var user = new TestUser();
var error = $"You cannot use '{password}' as your password";
IdentityResultAssert.IsFailure(await validator.ValidateAsync(manager, user, password), error);
}
public async Task FailsIfCommon1000(string input)
{
var passwordLists = new PasswordLists(
MockHelpers.MockOptions().Object,
MockHelpers.MockILogger <PasswordLists>().Object);
var manager = MockHelpers.TestUserManager <TestUser>();
var valid = new Top1000PasswordValidator <TestUser>(passwordLists);
IdentityResultAssert.IsFailure(await valid.ValidateAsync(manager, null, input), _error);
}
public async Task FailsIfSame(string email, string password)
{
var manager = MockHelpers.TestUserManager <IdentityUser>();
var validator = new EmailAsPasswordValidator <IdentityUser>();
var user = new IdentityUser {
Email = email
};
IdentityResultAssert.IsFailure(await validator.ValidateAsync(manager, user, password), _error);
}
public async Task FailsIfZeroLengthPassword()
{
var service = new Mock <IPwnedPasswordService>();
var input = string.Empty;
var manager = MockHelpers.TestUserManager <TestUser>();
var validator = new PwnedPasswordValidator <TestUser>(service.Object);
IdentityResultAssert.IsFailure(await validator.ValidateAsync(manager, null, input), _error);
}
public async Task FailsIfServiceIndicatesPasswordIsPwned()
{
var service = new Mock <IPwnedPasswordService>();
service.Setup(x => x.HasPasswordBeenPwned(It.IsAny <string>())).ReturnsAsync(true);
var input = "password";
var manager = MockHelpers.TestUserManager <TestUser>();
var validator = new PwnedPasswordValidator <TestUser>(service.Object);
IdentityResultAssert.IsFailure(await validator.ValidateAsync(manager, null, input), _error);
}
public async Task FailsIfTooShortTests(string input)
{
const string error = "Passwords must be at least 6 characters.";
var manager = MockHelpers.TestUserManager <PocoUser>();
var valid = new PasswordValidator <PocoUser>();
manager.Options.Password.RequireUppercase = false;
manager.Options.Password.RequireNonAlphanumeric = false;
manager.Options.Password.RequireLowercase = false;
manager.Options.Password.RequireDigit = false;
IdentityResultAssert.IsFailure(await valid.ValidateAsync(manager, null, input), error);
}
public async Task FailsIfclientIndicatesPasswordIsPwned()
{
var client = new Mock <IPwnedPasswordsClient>();
client.Setup(x => x.HasPasswordBeenPwned(It.IsAny <string>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(true);
var input = "password";
var manager = MockHelpers.TestUserManager <TestUser>();
var validator = new PwnedPasswordValidator <TestUser>(client.Object, Describer);
IdentityResultAssert.IsFailure(await validator.ValidateAsync(manager, null, input), _error);
}
public async Task FailsWithoutRequiredNonAlphanumericTests(string input)
{
var manager = MockHelpers.TestUserManager <PocoUser>();
var valid = new PasswordValidator <PocoUser>();
manager.Options.Password.RequireUppercase = false;
manager.Options.Password.RequireNonAlphanumeric = true;
manager.Options.Password.RequireLowercase = false;
manager.Options.Password.RequireDigit = false;
manager.Options.Password.RequiredLength = 0;
IdentityResultAssert.IsFailure(await valid.ValidateAsync(manager, null, input),
"Passwords must have at least one non alphanumeric character.");
}
public async Task FailsIfUserWithIdAndPasswordHash()
{
var manager = MockHelpers.TestUserManager <IdentityUser>();
var validator = new PreventPasswordChangeValidator <IdentityUser>();
var user = new IdentityUser
{
UserName = "******",
Id = Guid.NewGuid().ToString(),
PasswordHash = "not null",
};
var password = "******";
IdentityResultAssert.IsFailure(await validator.ValidateAsync(manager, user, password), _error);
}
public async Task ReturnsMessageFromOverriddenDescriber()
{
var client = new Mock <IPwnedPasswordsClient>();
client.Setup(x => x.HasPasswordBeenPwned(It.IsAny <string>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(true);
var input = "password";
var manager = MockHelpers.TestUserManager <TestUser>();
var validator = new PwnedPasswordValidator <TestUser>(client.Object, new OverriddenErrorDescriber());
IdentityResultAssert.IsFailure(await validator.ValidateAsync(manager, null, input),
OverriddenErrorDescriber.OverriddenDescription);
}
public async Task FailsWithoutRequiredUniqueCharsTests(string input, int uniqueChars)
{
var manager = MockHelpers.TestUserManager <PocoUser>();
var valid = new PasswordValidator <PocoUser>();
manager.Options.Password.RequireUppercase = false;
manager.Options.Password.RequireNonAlphanumeric = false;
manager.Options.Password.RequireLowercase = false;
manager.Options.Password.RequireDigit = false;
manager.Options.Password.RequiredLength = 0;
manager.Options.Password.RequiredUniqueChars = uniqueChars;
IdentityResultAssert.IsFailure(await valid.ValidateAsync(manager, null, input),
$"Passwords must use at least {uniqueChars} different characters.");
}
public async Task ValidateFailsWithTooShortUserNames(string input)
{
// Setup
var manager = MockHelpers.TestUserManager(new NoopUserStore());
var validator = new UserValidator <PocoUser>();
var user = new PocoUser {
UserName = input
};
// Act
var result = await validator.ValidateAsync(manager, user);
// Assert
IdentityResultAssert.IsFailure(result, new IdentityErrorDescriber().InvalidUserName(input));
}
public async Task ValidateFailsWithTooShortRoleName(string input)
{
// Setup
var validator = new RoleValidator <PocoRole>();
var manager = MockHelpers.TestRoleManager <PocoRole>();
var user = new PocoRole {
Name = input
};
// Act
var result = await validator.ValidateAsync(manager, user);
// Assert
IdentityResultAssert.IsFailure(result, new IdentityErrorDescriber().InvalidRoleName(input));
}
public async Task ConcurrentUpdatesWillFailWithDetachedUser()
{
var user = CreateTestUser();
var manager = CreateManager();
IdentityResultAssert.IsSuccess(await manager.CreateAsync(user));
var manager1 = CreateManager();
var manager2 = CreateManager();
var user2 = await manager2.FindByIdAsync(user.Id);
Assert.NotNull(user2);
Assert.NotSame(user, user2);
user.UserName = Guid.NewGuid().ToString();
user2.UserName = Guid.NewGuid().ToString();
IdentityResultAssert.IsSuccess(await manager1.UpdateAsync(user));
IdentityResultAssert.IsFailure(await manager2.UpdateAsync(user2), new IdentityErrorDescriber().ConcurrencyFailure());
}
public async Task UberMixedRequiredTests(string input, Errors errorMask)
{
const string alphaError = "Passwords must have at least one non alphanumeric character.";
const string upperError = "Passwords must have at least one uppercase ('A'-'Z').";
const string lowerError = "Passwords must have at least one lowercase ('a'-'z').";
const string digitError = "Passwords must have at least one digit ('0'-'9').";
const string lengthError = "Passwords must be at least 6 characters.";
var manager = MockHelpers.TestUserManager <PocoUser>();
var valid = new PasswordValidator <PocoUser>();
var errors = new List <string>();
if ((errorMask & Errors.Length) != Errors.None)
{
errors.Add(lengthError);
}
if ((errorMask & Errors.Alpha) != Errors.None)
{
errors.Add(alphaError);
}
if ((errorMask & Errors.Digit) != Errors.None)
{
errors.Add(digitError);
}
if ((errorMask & Errors.Lower) != Errors.None)
{
errors.Add(lowerError);
}
if ((errorMask & Errors.Upper) != Errors.None)
{
errors.Add(upperError);
}
var result = await valid.ValidateAsync(manager, null, input);
if (errors.Count == 0)
{
IdentityResultAssert.IsSuccess(result);
}
else
{
IdentityResultAssert.IsFailure(result);
foreach (var error in errors)
{
Assert.Contains(result.Errors, e => e.Description == error);
}
}
}
public async Task CanReplaceErrorMessage()
{
var error = "Oops, no good!";
var options = new OptionsStub();
options.Value.ErrorMessage = error;
var input = "qwerty";
var passwordLists = new PasswordLists(
MockHelpers.MockOptions().Object,
MockHelpers.MockILogger <PasswordLists>().Object);
var manager = MockHelpers.TestUserManager <TestUser>();
var validator = new Top100PasswordValidator <TestUser>(passwordLists, options);
var result = await validator.ValidateAsync(manager, null, input);
IdentityResultAssert.IsFailure(result, error);
}
public async Task ConcurrentRoleUpdatesWillFailWithDetachedRole()
{
var role = new Role(Guid.NewGuid().ToString());
RoleManager <Role> manager = CreateRoleManager();
IdentityResultAssert.IsSuccess(await manager.CreateAsync(role));
RoleManager <Role> manager1 = CreateRoleManager();
RoleManager <Role> manager2 = CreateRoleManager();
Role role2 = await manager2.FindByIdAsync(role.Name);
Assert.NotNull(role);
Assert.NotNull(role2);
Assert.NotSame(role, role2);
role.Name = Guid.NewGuid().ToString();
role2.Name = Guid.NewGuid().ToString();
IdentityResultAssert.IsSuccess(await manager1.UpdateAsync(role));
IdentityResultAssert.IsFailure(await manager2.UpdateAsync(role2), new IdentityErrorDescriber().ConcurrencyFailure());
}
public async Task DefaultAlphaNumericOnlyUserNameValidation(string userName, bool expectSuccess)
{
// Setup
var manager = MockHelpers.TestUserManager(new NoopUserStore());
var validator = new UserValidator <PocoUser>();
var user = new PocoUser {
UserName = userName
};
// Act
var result = await validator.ValidateAsync(manager, user);
// Assert
if (expectSuccess)
{
IdentityResultAssert.IsSuccess(result);
}
else
{
IdentityResultAssert.IsFailure(result);
}
}
public async Task ConcurrentRoleUpdatesWillFail()
{
var role = new IdentityRole(Guid.NewGuid().ToString());
var factory = CreateContext();
var manager = CreateRoleManager(factory);
IdentityResultAssert.IsSuccess(await manager.CreateAsync(role));
var manager1 = CreateRoleManager(factory);
var manager2 = CreateRoleManager(factory);
var role1 = await manager1.FindByIdAsync(role.Id);
var role2 = await manager2.FindByIdAsync(role.Id);
Assert.NotNull(role1);
Assert.NotNull(role2);
Assert.NotSame(role1, role2);
role1.Name = Guid.NewGuid().ToString();
role2.Name = Guid.NewGuid().ToString();
IdentityResultAssert.IsSuccess(await manager1.UpdateAsync(role1));
IdentityResultAssert.IsFailure(await manager2.UpdateAsync(role2),
new IdentityErrorDescriber().ConcurrencyFailure());
}
public async Task CanAllowNonAlphaNumericUserName(string userName, bool expectSuccess)
{
// Setup
var manager = MockHelpers.TestUserManager(new NoopUserStore());
manager.Options.User.AllowedUserNameCharacters = null;
var validator = new UserValidator <PocoUser>();
var user = new PocoUser {
UserName = userName
};
// Act
var result = await validator.ValidateAsync(manager, user);
// Assert
if (expectSuccess)
{
IdentityResultAssert.IsSuccess(result);
}
else
{
IdentityResultAssert.IsFailure(result);
}
}
