huahaofeng
/
aspnetcore
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove user id from logs in order to comply GDPR (#17491)

This commit is contained in:
Kahbazi 2020-07-01 00:57:53 +04:30 committed by GitHub
parent 9abbf4e113
commit 71fef28e47
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
26 changed files with 111 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/Identity/Core/ref/Microsoft.AspNetCore.Identity.netcoreapp.cs
View File

@ -137,7 +137,6 @@ namespace Microsoft.AspNetCore.Identity
public virtual bool IsSignedIn(System.Security.Claims.ClaimsPrincipal principal) { throw null; } public virtual bool IsSignedIn(System.Security.Claims.ClaimsPrincipal principal) { throw null; }
[System.Diagnostics.DebuggerStepThroughAttribute] [System.Diagnostics.DebuggerStepThroughAttribute]
public virtual System.Threading.Tasks.Task<bool> IsTwoFactorClientRememberedAsync(TUser user) { throw null; } public virtual System.Threading.Tasks.Task<bool> IsTwoFactorClientRememberedAsync(TUser user) { throw null; }
[System.Diagnostics.DebuggerStepThroughAttribute]
protected virtual System.Threading.Tasks.Task<Microsoft.AspNetCore.Identity.SignInResult> LockedOut(TUser user) { throw null; } protected virtual System.Threading.Tasks.Task<Microsoft.AspNetCore.Identity.SignInResult> LockedOut(TUser user) { throw null; }
[System.Diagnostics.DebuggerStepThroughAttribute] [System.Diagnostics.DebuggerStepThroughAttribute]
public virtual System.Threading.Tasks.Task<Microsoft.AspNetCore.Identity.SignInResult> PasswordSignInAsync(string userName, string password, bool isPersistent, bool lockoutOnFailure) { throw null; } public virtual System.Threading.Tasks.Task<Microsoft.AspNetCore.Identity.SignInResult> PasswordSignInAsync(string userName, string password, bool isPersistent, bool lockoutOnFailure) { throw null; }

14
src/Identity/Core/src/SignInManager.cs
View File

@ -144,17 +144,17 @@ namespace Microsoft.AspNetCore.Identity
{ {
if (Options.SignIn.RequireConfirmedEmail && !(await UserManager.IsEmailConfirmedAsync(user))) if (Options.SignIn.RequireConfirmedEmail && !(await UserManager.IsEmailConfirmedAsync(user)))
{ {
Logger.LogWarning(0, "User {userId} cannot sign in without a confirmed email.", await UserManager.GetUserIdAsync(user)); Logger.LogWarning(0, "User cannot sign in without a confirmed email.");
return false; return false;
} }
if (Options.SignIn.RequireConfirmedPhoneNumber && !(await UserManager.IsPhoneNumberConfirmedAsync(user))) if (Options.SignIn.RequireConfirmedPhoneNumber && !(await UserManager.IsPhoneNumberConfirmedAsync(user)))
{ {
Logger.LogWarning(1, "User {userId} cannot sign in without a confirmed phone number.", await UserManager.GetUserIdAsync(user)); Logger.LogWarning(1, "User cannot sign in without a confirmed phone number.");
return false; return false;
} }
if (Options.SignIn.RequireConfirmedAccount && !(await _confirmation.IsConfirmedAsync(UserManager, user))) if (Options.SignIn.RequireConfirmedAccount && !(await _confirmation.IsConfirmedAsync(UserManager, user)))
{ {
Logger.LogWarning(4, "User {userId} cannot sign in without a confirmed account.", await UserManager.GetUserIdAsync(user)); Logger.LogWarning(4, "User cannot sign in without a confirmed account.");
return false; return false;
} }
return true; return true;
@ -386,7 +386,7 @@ namespace Microsoft.AspNetCore.Identity
return SignInResult.Success; return SignInResult.Success;
} }
Logger.LogWarning(2, "User {userId} failed to provide the correct password.", await UserManager.GetUserIdAsync(user)); Logger.LogWarning(2, "User failed to provide the correct password.");
if (UserManager.SupportsUserLockout && lockoutOnFailure) if (UserManager.SupportsUserLockout && lockoutOnFailure)
{ {
@ -840,10 +840,10 @@ namespace Microsoft.AspNetCore.Identity
/// </summary> /// </summary>
/// <param name="user">The user.</param> /// <param name="user">The user.</param>
/// <returns>A locked out SignInResult</returns> /// <returns>A locked out SignInResult</returns>
protected virtual async Task<SignInResult> LockedOut(TUser user) protected virtual Task<SignInResult> LockedOut(TUser user)
{ {
Logger.LogWarning(3, "User {userId} is currently locked out.", await UserManager.GetUserIdAsync(user)); Logger.LogWarning(3, "User is currently locked out.");
return SignInResult.LockedOut; return Task.FromResult(SignInResult.LockedOut);
} }
/// <summary> /// <summary>

46
src/Identity/Extensions.Core/src/UserManager.cs
View File

@ -610,7 +610,7 @@ namespace Microsoft.AspNetCore.Identity
/// <param name="name">The name to normalize.</param> /// <param name="name">The name to normalize.</param>
/// <returns>A normalized value representing the specified <paramref name="name"/>.</returns> /// <returns>A normalized value representing the specified <paramref name="name"/>.</returns>
public virtual string NormalizeName(string name) public virtual string NormalizeName(string name)
=> (KeyNormalizer == null) ? name : KeyNormalizer.NormalizeName(name); => (KeyNormalizer == null) ? name : KeyNormalizer.NormalizeName(name);
/// <summary> /// <summary>
/// Normalize email for consistent comparisons. /// Normalize email for consistent comparisons.
@ -618,7 +618,7 @@ namespace Microsoft.AspNetCore.Identity
/// <param name="email">The email to normalize.</param> /// <param name="email">The email to normalize.</param>
/// <returns>A normalized value representing the specified <paramref name="email"/>.</returns> /// <returns>A normalized value representing the specified <paramref name="email"/>.</returns>
public virtual string NormalizeEmail(string email) public virtual string NormalizeEmail(string email)
=> (KeyNormalizer == null) ? email : KeyNormalizer.NormalizeEmail(email); => (KeyNormalizer == null) ? email : KeyNormalizer.NormalizeEmail(email);
private string ProtectPersonalData(string data) private string ProtectPersonalData(string data)
{ {
@ -716,7 +716,7 @@ namespace Microsoft.AspNetCore.Identity
var success = result != PasswordVerificationResult.Failed; var success = result != PasswordVerificationResult.Failed;
if (!success) if (!success)
{ {
Logger.LogWarning(0, "Invalid password for user {userId}.", await GetUserIdAsync(user)); Logger.LogWarning(0, "Invalid password for user.");
} }
return success; return success;
} }
@ -763,7 +763,7 @@ namespace Microsoft.AspNetCore.Identity
var hash = await passwordStore.GetPasswordHashAsync(user, CancellationToken); var hash = await passwordStore.GetPasswordHashAsync(user, CancellationToken);
if (hash != null) if (hash != null)
{ {
Logger.LogWarning(1, "User {userId} already has a password.", await GetUserIdAsync(user)); Logger.LogWarning(1, "User already has a password.");
return IdentityResult.Failed(ErrorDescriber.UserAlreadyHasPassword()); return IdentityResult.Failed(ErrorDescriber.UserAlreadyHasPassword());
} }
var result = await UpdatePasswordHash(passwordStore, user, password); var result = await UpdatePasswordHash(passwordStore, user, password);
@ -804,7 +804,7 @@ namespace Microsoft.AspNetCore.Identity
} }
return await UpdateUserAsync(user); return await UpdateUserAsync(user);
} }
Logger.LogWarning(2, "Change password failed for user {userId}.", await GetUserIdAsync(user)); Logger.LogWarning(2, "Change password failed for user.");
return IdentityResult.Failed(ErrorDescriber.PasswordMismatch()); return IdentityResult.Failed(ErrorDescriber.PasswordMismatch());
} }
@ -865,7 +865,7 @@ namespace Microsoft.AspNetCore.Identity
var stamp = await securityStore.GetSecurityStampAsync(user, CancellationToken); var stamp = await securityStore.GetSecurityStampAsync(user, CancellationToken);
if (stamp == null) if (stamp == null)
{ {
Logger.LogWarning(15, "GetSecurityStampAsync for user {userId} failed because stamp was null.", await GetUserIdAsync(user)); Logger.LogWarning(15, "GetSecurityStampAsync for user failed because stamp was null.");
throw new InvalidOperationException(Resources.NullSecurityStamp); throw new InvalidOperationException(Resources.NullSecurityStamp);
} }
return stamp; return stamp;
@ -1021,7 +1021,7 @@ namespace Microsoft.AspNetCore.Identity
var existingUser = await FindByLoginAsync(login.LoginProvider, login.ProviderKey); var existingUser = await FindByLoginAsync(login.LoginProvider, login.ProviderKey);
if (existingUser != null) if (existingUser != null)
{ {
Logger.LogWarning(4, "AddLogin for user {userId} failed because it was already associated with another user.", await GetUserIdAsync(user)); Logger.LogWarning(4, "AddLogin for user failed because it was already associated with another user.");
return IdentityResult.Failed(ErrorDescriber.LoginAlreadyAssociated()); return IdentityResult.Failed(ErrorDescriber.LoginAlreadyAssociated());
} }
await loginStore.AddLoginAsync(user, login, CancellationToken); await loginStore.AddLoginAsync(user, login, CancellationToken);
@ -1216,7 +1216,7 @@ namespace Microsoft.AspNetCore.Identity
var normalizedRole = NormalizeName(role); var normalizedRole = NormalizeName(role);
if (await userRoleStore.IsInRoleAsync(user, normalizedRole, CancellationToken)) if (await userRoleStore.IsInRoleAsync(user, normalizedRole, CancellationToken))
{ {
return await UserAlreadyInRoleError(user, role); return UserAlreadyInRoleError(role);
} }
await userRoleStore.AddToRoleAsync(user, normalizedRole, CancellationToken); await userRoleStore.AddToRoleAsync(user, normalizedRole, CancellationToken);
return await UpdateUserAsync(user); return await UpdateUserAsync(user);
@ -1249,7 +1249,7 @@ namespace Microsoft.AspNetCore.Identity
var normalizedRole = NormalizeName(role); var normalizedRole = NormalizeName(role);
if (await userRoleStore.IsInRoleAsync(user, normalizedRole, CancellationToken)) if (await userRoleStore.IsInRoleAsync(user, normalizedRole, CancellationToken))
{ {
return await UserAlreadyInRoleError(user, role); return UserAlreadyInRoleError(role);
} }
await userRoleStore.AddToRoleAsync(user, normalizedRole, CancellationToken); await userRoleStore.AddToRoleAsync(user, normalizedRole, CancellationToken);
} }
@ -1277,21 +1277,21 @@ namespace Microsoft.AspNetCore.Identity
var normalizedRole = NormalizeName(role); var normalizedRole = NormalizeName(role);
if (!await userRoleStore.IsInRoleAsync(user, normalizedRole, CancellationToken)) if (!await userRoleStore.IsInRoleAsync(user, normalizedRole, CancellationToken))
{ {
return await UserNotInRoleError(user, role); return UserNotInRoleError(role);
} }
await userRoleStore.RemoveFromRoleAsync(user, normalizedRole, CancellationToken); await userRoleStore.RemoveFromRoleAsync(user, normalizedRole, CancellationToken);
return await UpdateUserAsync(user); return await UpdateUserAsync(user);
} }
private async Task<IdentityResult> UserAlreadyInRoleError(TUser user, string role) private IdentityResult UserAlreadyInRoleError(string role)
{ {
Logger.LogWarning(5, "User {userId} is already in role {role}.", await GetUserIdAsync(user), role); Logger.LogWarning(5, "User is already in role {role}.", role);
return IdentityResult.Failed(ErrorDescriber.UserAlreadyInRole(role)); return IdentityResult.Failed(ErrorDescriber.UserAlreadyInRole(role));
} }
private async Task<IdentityResult> UserNotInRoleError(TUser user, string role) private IdentityResult UserNotInRoleError(string role)
{ {
Logger.LogWarning(6, "User {userId} is not in role {role}.", await GetUserIdAsync(user), role); Logger.LogWarning(6, "User is not in role {role}.", role);
return IdentityResult.Failed(ErrorDescriber.UserNotInRole(role)); return IdentityResult.Failed(ErrorDescriber.UserNotInRole(role));
} }
@ -1322,7 +1322,7 @@ namespace Microsoft.AspNetCore.Identity
var normalizedRole = NormalizeName(role); var normalizedRole = NormalizeName(role);
if (!await userRoleStore.IsInRoleAsync(user, normalizedRole, CancellationToken)) if (!await userRoleStore.IsInRoleAsync(user, normalizedRole, CancellationToken))
{ {
return await UserNotInRoleError(user, role); return UserNotInRoleError(role);
} }
await userRoleStore.RemoveFromRoleAsync(user, normalizedRole, CancellationToken); await userRoleStore.RemoveFromRoleAsync(user, normalizedRole, CancellationToken);
} }
@ -1627,7 +1627,7 @@ namespace Microsoft.AspNetCore.Identity
if (!await VerifyChangePhoneNumberTokenAsync(user, token, phoneNumber)) if (!await VerifyChangePhoneNumberTokenAsync(user, token, phoneNumber))
{ {
Logger.LogWarning(7, "Change phone number for user {userId} failed with invalid token.", await GetUserIdAsync(user)); Logger.LogWarning(7, "Change phone number for user failed with invalid token.");
return IdentityResult.Failed(ErrorDescriber.InvalidToken()); return IdentityResult.Failed(ErrorDescriber.InvalidToken());
} }
await store.SetPhoneNumberAsync(user, phoneNumber, CancellationToken); await store.SetPhoneNumberAsync(user, phoneNumber, CancellationToken);
@ -1689,7 +1689,7 @@ namespace Microsoft.AspNetCore.Identity
} }
// Make sure the token is valid and the stamp matches // Make sure the token is valid and the stamp matches
return VerifyUserTokenAsync(user, Options.Tokens.ChangePhoneNumberTokenProvider, ChangePhoneNumberTokenPurpose+":"+ phoneNumber, token); return VerifyUserTokenAsync(user, Options.Tokens.ChangePhoneNumberTokenProvider, ChangePhoneNumberTokenPurpose + ":" + phoneNumber, token);
} }
/// <summary> /// <summary>
@ -1725,7 +1725,7 @@ namespace Microsoft.AspNetCore.Identity
if (!result) if (!result)
{ {
Logger.LogWarning(9, "VerifyUserTokenAsync() failed with purpose: {purpose} for user {userId}.", purpose, await GetUserIdAsync(user)); Logger.LogWarning(9, "VerifyUserTokenAsync() failed with purpose: {purpose} for user.", purpose);
} }
return result; return result;
} }
@ -1827,7 +1827,7 @@ namespace Microsoft.AspNetCore.Identity
var result = await _tokenProviders[tokenProvider].ValidateAsync("TwoFactor", token, this, user); var result = await _tokenProviders[tokenProvider].ValidateAsync("TwoFactor", token, this, user);
if (!result) if (!result)
{ {
Logger.LogWarning(10, $"{nameof(VerifyTwoFactorTokenAsync)}() failed for user {await GetUserIdAsync(user)}."); Logger.LogWarning(10, $"{nameof(VerifyTwoFactorTokenAsync)}() failed for user.");
} }
return result; return result;
} }
@ -2000,7 +2000,7 @@ namespace Microsoft.AspNetCore.Identity
if (!await store.GetLockoutEnabledAsync(user, CancellationToken)) if (!await store.GetLockoutEnabledAsync(user, CancellationToken))
{ {
Logger.LogWarning(11, "Lockout for user {userId} failed because lockout is not enabled for this user.", await GetUserIdAsync(user)); Logger.LogWarning(11, "Lockout for user failed because lockout is not enabled for this user.");
return IdentityResult.Failed(ErrorDescriber.UserLockoutNotEnabled()); return IdentityResult.Failed(ErrorDescriber.UserLockoutNotEnabled());
} }
await store.SetLockoutEndDateAsync(user, lockoutEnd, CancellationToken); await store.SetLockoutEndDateAsync(user, lockoutEnd, CancellationToken);
@ -2029,7 +2029,7 @@ namespace Microsoft.AspNetCore.Identity
{ {
return await UpdateUserAsync(user); return await UpdateUserAsync(user);
} }
Logger.LogWarning(12, "User {userId} is locked out.", await GetUserIdAsync(user)); Logger.LogWarning(12, "User is locked out.");
await store.SetLockoutEndDateAsync(user, DateTimeOffset.UtcNow.Add(Options.Lockout.DefaultLockoutTimeSpan), await store.SetLockoutEndDateAsync(user, DateTimeOffset.UtcNow.Add(Options.Lockout.DefaultLockoutTimeSpan),
CancellationToken); CancellationToken);
await store.ResetAccessFailedCountAsync(user, CancellationToken); await store.ResetAccessFailedCountAsync(user, CancellationToken);
@ -2503,7 +2503,7 @@ namespace Microsoft.AspNetCore.Identity
} }
if (errors.Count > 0) if (errors.Count > 0)
{ {
Logger.LogWarning(13, "User {userId} validation failed: {errors}.", await GetUserIdAsync(user), string.Join(";", errors.Select(e => e.Code))); Logger.LogWarning(13, "User validation failed: {errors}.", string.Join(";", errors.Select(e => e.Code)));
return IdentityResult.Failed(errors.ToArray()); return IdentityResult.Failed(errors.ToArray());
} }
return IdentityResult.Success; return IdentityResult.Success;
@ -2535,7 +2535,7 @@ namespace Microsoft.AspNetCore.Identity
} }
if (!isValid) if (!isValid)
{ {
Logger.LogWarning(14, "User {userId} password validation failed: {errors}.", await GetUserIdAsync(user), string.Join(";", errors.Select(e => e.Code))); Logger.LogWarning(14, "User password validation failed: {errors}.", string.Join(";", errors.Select(e => e.Code)));
return IdentityResult.Failed(errors.ToArray()); return IdentityResult.Failed(errors.ToArray());
} }
return IdentityResult.Success; return IdentityResult.Success;

4
src/Identity/Specification.Tests/src/IdentitySpecificationTestBase.cs
View File

@ -486,7 +486,7 @@ namespace Microsoft.AspNetCore.Identity.Test
IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role)); IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role));
var result = await userMgr.RemoveFromRoleAsync(user, roleName); var result = await userMgr.RemoveFromRoleAsync(user, roleName);
IdentityResultAssert.IsFailure(result, _errorDescriber.UserNotInRole(roleName)); IdentityResultAssert.IsFailure(result, _errorDescriber.UserNotInRole(roleName));
IdentityResultAssert.VerifyLogMessage(userMgr.Logger, $"User {await userMgr.GetUserIdAsync(user)} is not in role {roleName}."); IdentityResultAssert.VerifyLogMessage(userMgr.Logger, $"User is not in role {roleName}.");
} }
/// <summary> /// <summary>
@ -507,7 +507,7 @@ namespace Microsoft.AspNetCore.Identity.Test
IdentityResultAssert.IsSuccess(await userMgr.AddToRoleAsync(user, roleName)); IdentityResultAssert.IsSuccess(await userMgr.AddToRoleAsync(user, roleName));
Assert.True(await userMgr.IsInRoleAsync(user, roleName)); Assert.True(await userMgr.IsInRoleAsync(user, roleName));
IdentityResultAssert.IsFailure(await userMgr.AddToRoleAsync(user, roleName), _errorDescriber.UserAlreadyInRole(roleName)); IdentityResultAssert.IsFailure(await userMgr.AddToRoleAsync(user, roleName), _errorDescriber.UserAlreadyInRole(roleName));
IdentityResultAssert.VerifyLogMessage(userMgr.Logger, $"User {await userMgr.GetUserIdAsync(user)} is already in role {roleName}."); IdentityResultAssert.VerifyLogMessage(userMgr.Logger, $"User is already in role {roleName}.");
} }
/// <summary> /// <summary>

64
src/Identity/Specification.Tests/src/UserManagerSpecificationTests.cs
View File

@ -252,11 +252,11 @@ namespace Microsoft.AspNetCore.Identity.Test
IdentityResultAssert.IsSuccess(await manager.CreateAsync(newUser)); IdentityResultAssert.IsSuccess(await manager.CreateAsync(newUser));
var error = _errorDescriber.InvalidUserName(""); var error = _errorDescriber.InvalidUserName("");
IdentityResultAssert.IsFailure(await manager.SetUserNameAsync(newUser, ""), error); IdentityResultAssert.IsFailure(await manager.SetUserNameAsync(newUser, ""), error);
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"User {await manager.GetUserIdAsync(newUser)} validation failed: {error.Code}."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"User validation failed: {error.Code}.");
error = _errorDescriber.DuplicateUserName(newUsername); error = _errorDescriber.DuplicateUserName(newUsername);
IdentityResultAssert.IsFailure(await manager.SetUserNameAsync(newUser, newUsername), error); IdentityResultAssert.IsFailure(await manager.SetUserNameAsync(newUser, newUsername), error);
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"User {await manager.GetUserIdAsync(newUser)} validation failed: {error.Code}."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"User validation failed: {error.Code}.");
} }
/// <summary> /// <summary>
@ -332,7 +332,7 @@ namespace Microsoft.AspNetCore.Identity.Test
SetUserPasswordHash(user, manager.PasswordHasher.HashPassword(user, "New")); SetUserPasswordHash(user, manager.PasswordHasher.HashPassword(user, "New"));
IdentityResultAssert.IsSuccess(await manager.UpdateAsync(user)); IdentityResultAssert.IsSuccess(await manager.UpdateAsync(user));
Assert.False(await manager.CheckPasswordAsync(user, "password")); Assert.False(await manager.CheckPasswordAsync(user, "password"));
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"Invalid password for user {await manager.GetUserIdAsync(user)}."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"Invalid password for user.");
Assert.True(await manager.CheckPasswordAsync(user, "New")); Assert.True(await manager.CheckPasswordAsync(user, "New"));
} }
@ -361,7 +361,7 @@ namespace Microsoft.AspNetCore.Identity.Test
manager.UserValidators.Clear(); manager.UserValidators.Clear();
manager.UserValidators.Add(new AlwaysBadValidator()); manager.UserValidators.Add(new AlwaysBadValidator());
IdentityResultAssert.IsFailure(await manager.CreateAsync(user), AlwaysBadValidator.ErrorMessage); IdentityResultAssert.IsFailure(await manager.CreateAsync(user), AlwaysBadValidator.ErrorMessage);
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"User {await manager.GetUserIdAsync(user) ?? NullValue} validation failed: {AlwaysBadValidator.ErrorMessage.Code}."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"User validation failed: {AlwaysBadValidator.ErrorMessage.Code}.");
} }
/// <summary> /// <summary>
@ -377,7 +377,7 @@ namespace Microsoft.AspNetCore.Identity.Test
manager.UserValidators.Clear(); manager.UserValidators.Clear();
manager.UserValidators.Add(new AlwaysBadValidator()); manager.UserValidators.Add(new AlwaysBadValidator());
IdentityResultAssert.IsFailure(await manager.UpdateAsync(user), AlwaysBadValidator.ErrorMessage); IdentityResultAssert.IsFailure(await manager.UpdateAsync(user), AlwaysBadValidator.ErrorMessage);
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"User {await manager.GetUserIdAsync(user) ?? NullValue} validation failed: {AlwaysBadValidator.ErrorMessage.Code}."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"User validation failed: {AlwaysBadValidator.ErrorMessage.Code}.");
} }
/// <summary> /// <summary>
@ -394,7 +394,7 @@ namespace Microsoft.AspNetCore.Identity.Test
manager.UserValidators.Add(new AlwaysBadValidator()); manager.UserValidators.Add(new AlwaysBadValidator());
var result = await manager.CreateAsync(user); var result = await manager.CreateAsync(user);
IdentityResultAssert.IsFailure(result, AlwaysBadValidator.ErrorMessage); IdentityResultAssert.IsFailure(result, AlwaysBadValidator.ErrorMessage);
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"User {await manager.GetUserIdAsync(user) ?? NullValue} validation failed: {AlwaysBadValidator.ErrorMessage.Code};{AlwaysBadValidator.ErrorMessage.Code}."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"User validation failed: {AlwaysBadValidator.ErrorMessage.Code};{AlwaysBadValidator.ErrorMessage.Code}.");
Assert.Equal(2, result.Errors.Count()); Assert.Equal(2, result.Errors.Count());
} }
@ -442,7 +442,7 @@ namespace Microsoft.AspNetCore.Identity.Test
manager.PasswordValidators.Add(new AlwaysBadValidator()); manager.PasswordValidators.Add(new AlwaysBadValidator());
IdentityResultAssert.IsFailure(await manager.AddPasswordAsync(user, "password"), IdentityResultAssert.IsFailure(await manager.AddPasswordAsync(user, "password"),
AlwaysBadValidator.ErrorMessage); AlwaysBadValidator.ErrorMessage);
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"User {await manager.GetUserIdAsync(user)} password validation failed: {AlwaysBadValidator.ErrorMessage.Code}."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"User password validation failed: {AlwaysBadValidator.ErrorMessage.Code}.");
} }
/// <summary> /// <summary>
@ -530,7 +530,7 @@ namespace Microsoft.AspNetCore.Identity.Test
manager.PasswordValidators.Add(new AlwaysBadValidator()); manager.PasswordValidators.Add(new AlwaysBadValidator());
IdentityResultAssert.IsFailure(await manager.ChangePasswordAsync(user, "password", "new"), IdentityResultAssert.IsFailure(await manager.ChangePasswordAsync(user, "password", "new"),
AlwaysBadValidator.ErrorMessage); AlwaysBadValidator.ErrorMessage);
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"User {await manager.GetUserIdAsync(user) ?? NullValue} password validation failed: {AlwaysBadValidator.ErrorMessage.Code}."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"User password validation failed: {AlwaysBadValidator.ErrorMessage.Code}.");
} }
/// <summary> /// <summary>
@ -545,7 +545,7 @@ namespace Microsoft.AspNetCore.Identity.Test
manager.PasswordValidators.Clear(); manager.PasswordValidators.Clear();
manager.PasswordValidators.Add(new AlwaysBadValidator()); manager.PasswordValidators.Add(new AlwaysBadValidator());
IdentityResultAssert.IsFailure(await manager.CreateAsync(user, "password"), AlwaysBadValidator.ErrorMessage); IdentityResultAssert.IsFailure(await manager.CreateAsync(user, "password"), AlwaysBadValidator.ErrorMessage);
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"User {await manager.GetUserIdAsync(user) ?? NullValue} password validation failed: {AlwaysBadValidator.ErrorMessage.Code}."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"User password validation failed: {AlwaysBadValidator.ErrorMessage.Code}.");
} }
/// <summary> /// <summary>
@ -625,7 +625,7 @@ namespace Microsoft.AspNetCore.Identity.Test
Assert.True(await manager.HasPasswordAsync(user)); Assert.True(await manager.HasPasswordAsync(user));
IdentityResultAssert.IsFailure(await manager.AddPasswordAsync(user, "password"), IdentityResultAssert.IsFailure(await manager.AddPasswordAsync(user, "password"),
"User already has a password set."); "User already has a password set.");
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"User {await manager.GetUserIdAsync(user)} already has a password."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"User already has a password.");
} }
/// <summary> /// <summary>
@ -829,7 +829,7 @@ namespace Microsoft.AspNetCore.Identity.Test
IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, "password")); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, "password"));
var result = await manager.ChangePasswordAsync(user, "bogus", "newpassword"); var result = await manager.ChangePasswordAsync(user, "bogus", "newpassword");
IdentityResultAssert.IsFailure(result, "Incorrect password."); IdentityResultAssert.IsFailure(result, "Incorrect password.");
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"Change password failed for user {await manager.GetUserIdAsync(user)}."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"Change password failed for user.");
} }
/// <summary> /// <summary>
@ -906,7 +906,7 @@ namespace Microsoft.AspNetCore.Identity.Test
IdentityResultAssert.IsSuccess(await manager.AddLoginAsync(user, login)); IdentityResultAssert.IsSuccess(await manager.AddLoginAsync(user, login));
var result = await manager.AddLoginAsync(user, login); var result = await manager.AddLoginAsync(user, login);
IdentityResultAssert.IsFailure(result, _errorDescriber.LoginAlreadyAssociated()); IdentityResultAssert.IsFailure(result, _errorDescriber.LoginAlreadyAssociated());
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"AddLogin for user {await manager.GetUserIdAsync(user)} failed because it was already associated with another user."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"AddLogin for user failed because it was already associated with another user.");
} }
// Email tests // Email tests
@ -1028,7 +1028,7 @@ namespace Microsoft.AspNetCore.Identity.Test
manager.PasswordValidators.Add(new AlwaysBadValidator()); manager.PasswordValidators.Add(new AlwaysBadValidator());
IdentityResultAssert.IsFailure(await manager.ResetPasswordAsync(user, token, newPassword), IdentityResultAssert.IsFailure(await manager.ResetPasswordAsync(user, token, newPassword),
AlwaysBadValidator.ErrorMessage); AlwaysBadValidator.ErrorMessage);
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"User {await manager.GetUserIdAsync(user)} password validation failed: {AlwaysBadValidator.ErrorMessage.Code}."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"User password validation failed: {AlwaysBadValidator.ErrorMessage.Code}.");
Assert.True(await manager.CheckPasswordAsync(user, password)); Assert.True(await manager.CheckPasswordAsync(user, password));
Assert.Equal(stamp, await manager.GetSecurityStampAsync(user)); Assert.Equal(stamp, await manager.GetSecurityStampAsync(user));
} }
@ -1050,7 +1050,7 @@ namespace Microsoft.AspNetCore.Identity.Test
var stamp = await manager.GetSecurityStampAsync(user); var stamp = await manager.GetSecurityStampAsync(user);
Assert.NotNull(stamp); Assert.NotNull(stamp);
IdentityResultAssert.IsFailure(await manager.ResetPasswordAsync(user, "bogus", newPassword), "Invalid token."); IdentityResultAssert.IsFailure(await manager.ResetPasswordAsync(user, "bogus", newPassword), "Invalid token.");
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyUserTokenAsync() failed with purpose: ResetPassword for user { await manager.GetUserIdAsync(user)}."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyUserTokenAsync() failed with purpose: ResetPassword for user.");
Assert.True(await manager.CheckPasswordAsync(user, password)); Assert.True(await manager.CheckPasswordAsync(user, password));
Assert.Equal(stamp, await manager.GetSecurityStampAsync(user)); Assert.Equal(stamp, await manager.GetSecurityStampAsync(user));
} }
@ -1074,13 +1074,13 @@ namespace Microsoft.AspNetCore.Identity.Test
Assert.True(await manager.VerifyUserTokenAsync(user, "Static", "test", token)); Assert.True(await manager.VerifyUserTokenAsync(user, "Static", "test", token));
Assert.False(await manager.VerifyUserTokenAsync(user, "Static", "test2", token)); Assert.False(await manager.VerifyUserTokenAsync(user, "Static", "test2", token));
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyUserTokenAsync() failed with purpose: test2 for user { await manager.GetUserIdAsync(user)}."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyUserTokenAsync() failed with purpose: test2 for user.");
Assert.False(await manager.VerifyUserTokenAsync(user, "Static", "test", token + "a")); Assert.False(await manager.VerifyUserTokenAsync(user, "Static", "test", token + "a"));
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyUserTokenAsync() failed with purpose: test for user { await manager.GetUserIdAsync(user)}."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyUserTokenAsync() failed with purpose: test for user.");
Assert.False(await manager.VerifyUserTokenAsync(user2, "Static", "test", token)); Assert.False(await manager.VerifyUserTokenAsync(user2, "Static", "test", token));
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyUserTokenAsync() failed with purpose: test for user { await manager.GetUserIdAsync(user2)}."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyUserTokenAsync() failed with purpose: test for user.");
} }
/// <summary> /// <summary>
@ -1120,7 +1120,7 @@ namespace Microsoft.AspNetCore.Identity.Test
IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user));
IdentityResultAssert.IsFailure(await manager.ConfirmEmailAsync(user, "bogus"), "Invalid token."); IdentityResultAssert.IsFailure(await manager.ConfirmEmailAsync(user, "bogus"), "Invalid token.");
Assert.False(await manager.IsEmailConfirmedAsync(user)); Assert.False(await manager.IsEmailConfirmedAsync(user));
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyUserTokenAsync() failed with purpose: EmailConfirmation for user { await manager.GetUserIdAsync(user)}."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyUserTokenAsync() failed with purpose: EmailConfirmation for user.");
} }
/// <summary> /// <summary>
@ -1138,7 +1138,7 @@ namespace Microsoft.AspNetCore.Identity.Test
Assert.NotNull(token); Assert.NotNull(token);
IdentityResultAssert.IsSuccess(await manager.ChangePasswordAsync(user, "password", "newpassword")); IdentityResultAssert.IsSuccess(await manager.ChangePasswordAsync(user, "password", "newpassword"));
IdentityResultAssert.IsFailure(await manager.ConfirmEmailAsync(user, token), "Invalid token."); IdentityResultAssert.IsFailure(await manager.ConfirmEmailAsync(user, token), "Invalid token.");
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyUserTokenAsync() failed with purpose: EmailConfirmation for user { await manager.GetUserIdAsync(user)}."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyUserTokenAsync() failed with purpose: EmailConfirmation for user.");
Assert.False(await manager.IsEmailConfirmedAsync(user)); Assert.False(await manager.IsEmailConfirmedAsync(user));
} }
@ -1161,7 +1161,7 @@ namespace Microsoft.AspNetCore.Identity.Test
IdentityResultAssert.IsSuccess(await mgr.AccessFailedAsync(user)); IdentityResultAssert.IsSuccess(await mgr.AccessFailedAsync(user));
Assert.True(await mgr.IsLockedOutAsync(user)); Assert.True(await mgr.IsLockedOutAsync(user));
Assert.True(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55)); Assert.True(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55));
IdentityResultAssert.VerifyLogMessage(mgr.Logger, $"User {await mgr.GetUserIdAsync(user)} is locked out."); IdentityResultAssert.VerifyLogMessage(mgr.Logger, $"User is locked out.");
Assert.Equal(0, await mgr.GetAccessFailedCountAsync(user)); Assert.Equal(0, await mgr.GetAccessFailedCountAsync(user));
} }
@ -1187,7 +1187,7 @@ namespace Microsoft.AspNetCore.Identity.Test
IdentityResultAssert.IsSuccess(await mgr.AccessFailedAsync(user)); IdentityResultAssert.IsSuccess(await mgr.AccessFailedAsync(user));
Assert.True(await mgr.IsLockedOutAsync(user)); Assert.True(await mgr.IsLockedOutAsync(user));
Assert.True(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55)); Assert.True(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55));
IdentityResultAssert.VerifyLogMessage(mgr.Logger, $"User {await mgr.GetUserIdAsync(user)} is locked out."); IdentityResultAssert.VerifyLogMessage(mgr.Logger, $"User is locked out.");
Assert.Equal(0, await mgr.GetAccessFailedCountAsync(user)); Assert.Equal(0, await mgr.GetAccessFailedCountAsync(user));
} }
@ -1243,7 +1243,7 @@ namespace Microsoft.AspNetCore.Identity.Test
IdentityResultAssert.IsSuccess(await mgr.AccessFailedAsync(user)); IdentityResultAssert.IsSuccess(await mgr.AccessFailedAsync(user));
Assert.True(await mgr.IsLockedOutAsync(user)); Assert.True(await mgr.IsLockedOutAsync(user));
Assert.True(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55)); Assert.True(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55));
IdentityResultAssert.VerifyLogMessage(mgr.Logger, $"User {await mgr.GetUserIdAsync(user)} is locked out."); IdentityResultAssert.VerifyLogMessage(mgr.Logger, $"User is locked out.");
Assert.Equal(0, await mgr.GetAccessFailedCountAsync(user)); Assert.Equal(0, await mgr.GetAccessFailedCountAsync(user));
} }
@ -1277,7 +1277,7 @@ namespace Microsoft.AspNetCore.Identity.Test
Assert.False(await mgr.GetLockoutEnabledAsync(user)); Assert.False(await mgr.GetLockoutEnabledAsync(user));
IdentityResultAssert.IsFailure(await mgr.SetLockoutEndDateAsync(user, new DateTimeOffset()), IdentityResultAssert.IsFailure(await mgr.SetLockoutEndDateAsync(user, new DateTimeOffset()),
"Lockout is not enabled for this user."); "Lockout is not enabled for this user.");
IdentityResultAssert.VerifyLogMessage(mgr.Logger, $"Lockout for user {await mgr.GetUserIdAsync(user)} failed because lockout is not enabled for this user."); IdentityResultAssert.VerifyLogMessage(mgr.Logger, $"Lockout for user failed because lockout is not enabled for this user.");
Assert.False(await mgr.IsLockedOutAsync(user)); Assert.False(await mgr.IsLockedOutAsync(user));
} }
@ -1407,7 +1407,7 @@ namespace Microsoft.AspNetCore.Identity.Test
var stamp = await manager.GetSecurityStampAsync(user); var stamp = await manager.GetSecurityStampAsync(user);
IdentityResultAssert.IsFailure(await manager.ChangePhoneNumberAsync(user, "111-111-1111", "bogus"), IdentityResultAssert.IsFailure(await manager.ChangePhoneNumberAsync(user, "111-111-1111", "bogus"),
"Invalid token."); "Invalid token.");
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyUserTokenAsync() failed with purpose: ChangePhoneNumber:111-111-1111 for user {await manager.GetUserIdAsync(user)}."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyUserTokenAsync() failed with purpose: ChangePhoneNumber:111-111-1111 for user.");
Assert.False(await manager.IsPhoneNumberConfirmedAsync(user)); Assert.False(await manager.IsPhoneNumberConfirmedAsync(user));
Assert.Equal("123-456-7890", await manager.GetPhoneNumberAsync(user)); Assert.Equal("123-456-7890", await manager.GetPhoneNumberAsync(user));
Assert.Equal(stamp, await manager.GetSecurityStampAsync(user)); Assert.Equal(stamp, await manager.GetSecurityStampAsync(user));
@ -1486,8 +1486,8 @@ namespace Microsoft.AspNetCore.Identity.Test
Assert.True(await manager.VerifyChangePhoneNumberTokenAsync(user, token2, num2)); Assert.True(await manager.VerifyChangePhoneNumberTokenAsync(user, token2, num2));
Assert.False(await manager.VerifyChangePhoneNumberTokenAsync(user, "bogus", num1)); Assert.False(await manager.VerifyChangePhoneNumberTokenAsync(user, "bogus", num1));
Assert.False(await manager.VerifyChangePhoneNumberTokenAsync(user, "bogus", num2)); Assert.False(await manager.VerifyChangePhoneNumberTokenAsync(user, "bogus", num2));
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyUserTokenAsync() failed with purpose: ChangePhoneNumber:{num1} for user {await manager.GetUserIdAsync(user)}."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyUserTokenAsync() failed with purpose: ChangePhoneNumber:{num1} for user.");
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyUserTokenAsync() failed with purpose: ChangePhoneNumber:{num2} for user {await manager.GetUserIdAsync(user)}."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyUserTokenAsync() failed with purpose: ChangePhoneNumber:{num2} for user.");
} }
/// <summary> /// <summary>
@ -1601,7 +1601,7 @@ namespace Microsoft.AspNetCore.Identity.Test
var stamp = await manager.GetSecurityStampAsync(user); var stamp = await manager.GetSecurityStampAsync(user);
IdentityResultAssert.IsFailure(await manager.ChangeEmailAsync(user, "whatevah@foo.boop", "bogus"), IdentityResultAssert.IsFailure(await manager.ChangeEmailAsync(user, "whatevah@foo.boop", "bogus"),
"Invalid token."); "Invalid token.");
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyUserTokenAsync() failed with purpose: ChangeEmail:whatevah@foo.boop for user { await manager.GetUserIdAsync(user)}."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyUserTokenAsync() failed with purpose: ChangeEmail:whatevah@foo.boop for user.");
Assert.False(await manager.IsEmailConfirmedAsync(user)); Assert.False(await manager.IsEmailConfirmedAsync(user));
Assert.Equal(await manager.GetEmailAsync(user), oldEmail); Assert.Equal(await manager.GetEmailAsync(user), oldEmail);
Assert.Equal(stamp, await manager.GetSecurityStampAsync(user)); Assert.Equal(stamp, await manager.GetSecurityStampAsync(user));
@ -1625,7 +1625,7 @@ namespace Microsoft.AspNetCore.Identity.Test
var token1 = await manager.GenerateChangeEmailTokenAsync(user, "forgot@alrea.dy"); var token1 = await manager.GenerateChangeEmailTokenAsync(user, "forgot@alrea.dy");
IdentityResultAssert.IsFailure(await manager.ChangeEmailAsync(user, "oops@foo.boop", token1), IdentityResultAssert.IsFailure(await manager.ChangeEmailAsync(user, "oops@foo.boop", token1),
"Invalid token."); "Invalid token.");
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyUserTokenAsync() failed with purpose: ChangeEmail:oops@foo.boop for user { await manager.GetUserIdAsync(user)}."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyUserTokenAsync() failed with purpose: ChangeEmail:oops@foo.boop for user.");
Assert.False(await manager.IsEmailConfirmedAsync(user)); Assert.False(await manager.IsEmailConfirmedAsync(user));
Assert.Equal(await manager.GetEmailAsync(user), oldEmail); Assert.Equal(await manager.GetEmailAsync(user), oldEmail);
Assert.Equal(stamp, await manager.GetSecurityStampAsync(user)); Assert.Equal(stamp, await manager.GetSecurityStampAsync(user));
@ -1658,7 +1658,7 @@ namespace Microsoft.AspNetCore.Identity.Test
IdentityResultAssert.IsSuccess(await manager.UpdateSecurityStampAsync(user)); IdentityResultAssert.IsSuccess(await manager.UpdateSecurityStampAsync(user));
} }
Assert.False(await manager.VerifyTwoFactorTokenAsync(user, factorId, token)); Assert.False(await manager.VerifyTwoFactorTokenAsync(user, factorId, token));
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyTwoFactorTokenAsync() failed for user {await manager.GetUserIdAsync(user)}."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyTwoFactorTokenAsync() failed for user.");
} }
/// <summary> /// <summary>
@ -1855,7 +1855,7 @@ namespace Microsoft.AspNetCore.Identity.Test
Assert.NotNull(token); Assert.NotNull(token);
IdentityResultAssert.IsSuccess(await manager.UpdateSecurityStampAsync(user)); IdentityResultAssert.IsSuccess(await manager.UpdateSecurityStampAsync(user));
Assert.False(await manager.VerifyTwoFactorTokenAsync(user, factorId, token)); Assert.False(await manager.VerifyTwoFactorTokenAsync(user, factorId, token));
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyTwoFactorTokenAsync() failed for user {await manager.GetUserIdAsync(user)}."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyTwoFactorTokenAsync() failed for user.");
} }
/// <summary> /// <summary>
@ -1871,7 +1871,7 @@ namespace Microsoft.AspNetCore.Identity.Test
var token = await manager.GenerateTwoFactorTokenAsync(user, "Phone"); var token = await manager.GenerateTwoFactorTokenAsync(user, "Phone");
Assert.NotNull(token); Assert.NotNull(token);
Assert.False(await manager.VerifyTwoFactorTokenAsync(user, "Email", token)); Assert.False(await manager.VerifyTwoFactorTokenAsync(user, "Email", token));
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyTwoFactorTokenAsync() failed for user {await manager.GetUserIdAsync(user)}."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyTwoFactorTokenAsync() failed for user.");
} }
/// <summary> /// <summary>
@ -1885,7 +1885,7 @@ namespace Microsoft.AspNetCore.Identity.Test
var user = CreateTestUser(phoneNumber: "4251234567"); var user = CreateTestUser(phoneNumber: "4251234567");
IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user));
Assert.False(await manager.VerifyTwoFactorTokenAsync(user, "Phone", "bogus")); Assert.False(await manager.VerifyTwoFactorTokenAsync(user, "Phone", "bogus"));
IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyTwoFactorTokenAsync() failed for user {await manager.GetUserIdAsync(user)}."); IdentityResultAssert.VerifyLogMessage(manager.Logger, $"VerifyTwoFactorTokenAsync() failed for user.");
} }
/// <summary> /// <summary>

2
src/Identity/UI/src/Areas/Identity/Pages/V3/Account/ExternalLogin.cshtml.cs
View File

@ -148,7 +148,7 @@ namespace Microsoft.AspNetCore.Identity.UI.V3.Pages.Account.Internal
var result = await _signInManager.ExternalLoginSignInAsync(info.LoginProvider, info.ProviderKey, isPersistent: false, bypassTwoFactor: true); var result = await _signInManager.ExternalLoginSignInAsync(info.LoginProvider, info.ProviderKey, isPersistent: false, bypassTwoFactor: true);
if (result.Succeeded) if (result.Succeeded)
{ {
_logger.LogInformation("{Name} logged in with {LoginProvider} provider.", info.Principal.Identity.Name, info.LoginProvider); _logger.LogInformation("User logged in with {LoginProvider} provider.", info.LoginProvider);
return LocalRedirect(returnUrl); return LocalRedirect(returnUrl);
} }
if (result.IsLockedOut) if (result.IsLockedOut)

6
src/Identity/UI/src/Areas/Identity/Pages/V3/Account/LoginWith2fa.cshtml.cs
View File

@ -131,17 +131,17 @@ namespace Microsoft.AspNetCore.Identity.UI.V3.Pages.Account.Internal
if (result.Succeeded) if (result.Succeeded)
{ {
_logger.LogInformation("User with ID '{UserId}' logged in with 2fa.", userId); _logger.LogInformation("User logged in with 2fa.");
return LocalRedirect(returnUrl); return LocalRedirect(returnUrl);
} }
else if (result.IsLockedOut) else if (result.IsLockedOut)
{ {
_logger.LogWarning("User with ID '{UserId}' account locked out.", userId); _logger.LogWarning("User account locked out.");
return RedirectToPage("./Lockout"); return RedirectToPage("./Lockout");
} }
else else
{ {
_logger.LogWarning("Invalid authenticator code entered for user with ID '{UserId}'.", userId); _logger.LogWarning("Invalid authenticator code entered.");
ModelState.AddModelError(string.Empty, "Invalid authenticator code."); ModelState.AddModelError(string.Empty, "Invalid authenticator code.");
return Page(); return Page();
} }

6
src/Identity/UI/src/Areas/Identity/Pages/V3/Account/LoginWithRecoveryCode.cshtml.cs
View File

@ -114,17 +114,17 @@ namespace Microsoft.AspNetCore.Identity.UI.V3.Pages.Account.Internal
if (result.Succeeded) if (result.Succeeded)
{ {
_logger.LogInformation("User with ID '{UserId}' logged in with a recovery code.", userId); _logger.LogInformation("User logged in with a recovery code.");
return LocalRedirect(returnUrl ?? Url.Content("~/")); return LocalRedirect(returnUrl ?? Url.Content("~/"));
} }
if (result.IsLockedOut) if (result.IsLockedOut)
{ {
_logger.LogWarning("User with ID '{UserId}' account locked out.", userId); _logger.LogWarning("User account locked out.");
return RedirectToPage("./Lockout"); return RedirectToPage("./Lockout");
} }
else else
{ {
_logger.LogWarning("Invalid recovery code entered for user with ID '{UserId}' ", userId); _logger.LogWarning("Invalid recovery code entered.");
ModelState.AddModelError(string.Empty, "Invalid recovery code entered."); ModelState.AddModelError(string.Empty, "Invalid recovery code entered.");
return Page(); return Page();
} }

5
src/Identity/UI/src/Areas/Identity/Pages/V3/Account/Manage/DeletePersonalData.cshtml.cs
View File

@ -105,15 +105,14 @@ namespace Microsoft.AspNetCore.Identity.UI.V3.Pages.Account.Manage.Internal
} }
var result = await _userManager.DeleteAsync(user); var result = await _userManager.DeleteAsync(user);
var userId = await _userManager.GetUserIdAsync(user);
if (!result.Succeeded) if (!result.Succeeded)
{ {
throw new InvalidOperationException($"Unexpected error occurred deleting user with ID '{userId}'."); throw new InvalidOperationException($"Unexpected error occurred deleting user.");
} }
await _signInManager.SignOutAsync(); await _signInManager.SignOutAsync();
_logger.LogInformation("User with ID '{UserId}' deleted themselves.", userId); _logger.LogInformation("User deleted themselves.");
return Redirect("~/"); return Redirect("~/");
} }

8
src/Identity/UI/src/Areas/Identity/Pages/V3/Account/Manage/Disable2fa.cshtml.cs
View File

@ -59,7 +59,7 @@ namespace Microsoft.AspNetCore.Identity.UI.V3.Pages.Account.Manage.Internal
if (!await _userManager.GetTwoFactorEnabledAsync(user)) if (!await _userManager.GetTwoFactorEnabledAsync(user))
{ {
throw new InvalidOperationException($"Cannot disable 2FA for user with ID '{_userManager.GetUserId(User)}' as it's not currently enabled."); throw new InvalidOperationException($"Cannot disable 2FA as it's not currently enabled.");
} }
return Page(); return Page();
@ -76,12 +76,12 @@ namespace Microsoft.AspNetCore.Identity.UI.V3.Pages.Account.Manage.Internal
var disable2faResult = await _userManager.SetTwoFactorEnabledAsync(user, false); var disable2faResult = await _userManager.SetTwoFactorEnabledAsync(user, false);
if (!disable2faResult.Succeeded) if (!disable2faResult.Succeeded)
{ {
throw new InvalidOperationException($"Unexpected error occurred disabling 2FA for user with ID '{_userManager.GetUserId(User)}'."); throw new InvalidOperationException($"Unexpected error occurred disabling 2FA.");
} }
_logger.LogInformation("User with ID '{UserId}' has disabled 2fa.", _userManager.GetUserId(User)); _logger.LogInformation("User has disabled 2fa.");
StatusMessage = "2fa has been disabled. You can reenable 2fa when you setup an authenticator app"; StatusMessage = "2fa has been disabled. You can reenable 2fa when you setup an authenticator app";
return RedirectToPage("./TwoFactorAuthentication"); return RedirectToPage("./TwoFactorAuthentication");
} }
} }
} }

2
src/Identity/UI/src/Areas/Identity/Pages/V3/Account/Manage/DownloadPersonalData.cshtml.cs
View File

@ -59,7 +59,7 @@ namespace Microsoft.AspNetCore.Identity.UI.V3.Pages.Account.Manage.Internal
return NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."); return NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
} }
_logger.LogInformation("User with ID '{UserId}' asked for their personal data.", _userManager.GetUserId(User)); _logger.LogInformation("User asked for their personal data.");
// Only include personal data for download // Only include personal data for download
var personalData = new Dictionary<string, string>(); var personalData = new Dictionary<string, string>();

2
src/Identity/UI/src/Areas/Identity/Pages/V3/Account/Manage/EnableAuthenticator.cshtml.cs
View File

@ -143,7 +143,7 @@ namespace Microsoft.AspNetCore.Identity.UI.V3.Pages.Account.Manage.Internal
await _userManager.SetTwoFactorEnabledAsync(user, true); await _userManager.SetTwoFactorEnabledAsync(user, true);
var userId = await _userManager.GetUserIdAsync(user); var userId = await _userManager.GetUserIdAsync(user);
_logger.LogInformation("User with ID '{UserId}' has enabled 2FA with an authenticator app.", userId); _logger.LogInformation("User has enabled 2FA with an authenticator app.");
StatusMessage = "Your authenticator app has been verified."; StatusMessage = "Your authenticator app has been verified.";

2
src/Identity/UI/src/Areas/Identity/Pages/V3/Account/Manage/ExternalLogins.cshtml.cs
View File

@ -151,7 +151,7 @@ namespace Microsoft.AspNetCore.Identity.UI.V3.Pages.Account.Manage.Internal
var info = await _signInManager.GetExternalLoginInfoAsync(userId); var info = await _signInManager.GetExternalLoginInfoAsync(userId);
if (info == null) if (info == null)
{ {
throw new InvalidOperationException($"Unexpected error occurred loading external login info for user with ID '{userId}'."); throw new InvalidOperationException($"Unexpected error occurred loading external login info.");
} }
var result = await _userManager.AddLoginAsync(user, info); var result = await _userManager.AddLoginAsync(user, info);

8
src/Identity/UI/src/Areas/Identity/Pages/V3/Account/Manage/GenerateRecoveryCodes.cshtml.cs
View File

@ -68,8 +68,7 @@ namespace Microsoft.AspNetCore.Identity.UI.V3.Pages.Account.Manage.Internal
var isTwoFactorEnabled = await _userManager.GetTwoFactorEnabledAsync(user); var isTwoFactorEnabled = await _userManager.GetTwoFactorEnabledAsync(user);
if (!isTwoFactorEnabled) if (!isTwoFactorEnabled)
{ {
var userId = await _userManager.GetUserIdAsync(user); throw new InvalidOperationException($"Cannot generate recovery codes because they do not have 2FA enabled.");
throw new InvalidOperationException($"Cannot generate recovery codes for user with ID '{userId}' because they do not have 2FA enabled.");
} }
return Page(); return Page();
@ -84,16 +83,15 @@ namespace Microsoft.AspNetCore.Identity.UI.V3.Pages.Account.Manage.Internal
} }
var isTwoFactorEnabled = await _userManager.GetTwoFactorEnabledAsync(user); var isTwoFactorEnabled = await _userManager.GetTwoFactorEnabledAsync(user);
var userId = await _userManager.GetUserIdAsync(user);
if (!isTwoFactorEnabled) if (!isTwoFactorEnabled)
{ {
throw new InvalidOperationException($"Cannot generate recovery codes for user with ID '{userId}' as they do not have 2FA enabled."); throw new InvalidOperationException($"Cannot generate recovery codes as they do not have 2FA enabled.");
} }
var recoveryCodes = await _userManager.GenerateNewTwoFactorRecoveryCodesAsync(user, 10); var recoveryCodes = await _userManager.GenerateNewTwoFactorRecoveryCodesAsync(user, 10);
RecoveryCodes = recoveryCodes.ToArray(); RecoveryCodes = recoveryCodes.ToArray();
_logger.LogInformation("User with ID '{UserId}' has generated new 2FA recovery codes.", userId); _logger.LogInformation("User has generated new 2FA recovery codes.");
StatusMessage = "You have generated new recovery codes."; StatusMessage = "You have generated new recovery codes.";
return RedirectToPage("./ShowRecoveryCodes"); return RedirectToPage("./ShowRecoveryCodes");
} }

4
src/Identity/UI/src/Areas/Identity/Pages/V3/Account/Manage/ResetAuthenticator.cshtml.cs
View File

@ -75,7 +75,7 @@ namespace Microsoft.AspNetCore.Identity.UI.V3.Pages.Account.Manage.Internal
await _userManager.SetTwoFactorEnabledAsync(user, false); await _userManager.SetTwoFactorEnabledAsync(user, false);
await _userManager.ResetAuthenticatorKeyAsync(user); await _userManager.ResetAuthenticatorKeyAsync(user);
var userId = await _userManager.GetUserIdAsync(user); var userId = await _userManager.GetUserIdAsync(user);
_logger.LogInformation("User with ID '{UserId}' has reset their authentication app key.", userId); _logger.LogInformation("User has reset their authentication app key.");
await _signInManager.RefreshSignInAsync(user); await _signInManager.RefreshSignInAsync(user);
StatusMessage = "Your authenticator app key has been reset, you will need to configure your authenticator app using the new key."; StatusMessage = "Your authenticator app key has been reset, you will need to configure your authenticator app using the new key.";
@ -83,4 +83,4 @@ namespace Microsoft.AspNetCore.Identity.UI.V3.Pages.Account.Manage.Internal
return RedirectToPage("./EnableAuthenticator"); return RedirectToPage("./EnableAuthenticator");
} }
} }
} }

2
src/Identity/UI/src/Areas/Identity/Pages/V4/Account/ExternalLogin.cshtml.cs
View File

@ -145,7 +145,7 @@ namespace Microsoft.AspNetCore.Identity.UI.V4.Pages.Account.Internal
var result = await _signInManager.ExternalLoginSignInAsync(info.LoginProvider, info.ProviderKey, isPersistent: false, bypassTwoFactor: true); var result = await _signInManager.ExternalLoginSignInAsync(info.LoginProvider, info.ProviderKey, isPersistent: false, bypassTwoFactor: true);
if (result.Succeeded) if (result.Succeeded)
{ {
_logger.LogInformation("{Name} logged in with {LoginProvider} provider.", info.Principal.Identity.Name, info.LoginProvider); _logger.LogInformation("User logged in with {LoginProvider} provider.", info.LoginProvider);
return LocalRedirect(returnUrl); return LocalRedirect(returnUrl);
} }
if (result.IsLockedOut) if (result.IsLockedOut)

6
src/Identity/UI/src/Areas/Identity/Pages/V4/Account/LoginWith2fa.cshtml.cs
View File

@ -130,17 +130,17 @@ namespace Microsoft.AspNetCore.Identity.UI.V4.Pages.Account.Internal
if (result.Succeeded) if (result.Succeeded)
{ {
_logger.LogInformation("User with ID '{UserId}' logged in with 2fa.", userId); _logger.LogInformation("User logged in with 2fa.");
return LocalRedirect(returnUrl); return LocalRedirect(returnUrl);
} }
else if (result.IsLockedOut) else if (result.IsLockedOut)
{ {
_logger.LogWarning("User with ID '{UserId}' account locked out.", userId); _logger.LogWarning("User account locked out.");
return RedirectToPage("./Lockout"); return RedirectToPage("./Lockout");
} }
else else
{ {
_logger.LogWarning("Invalid authenticator code entered for user with ID '{UserId}'.", userId); _logger.LogWarning("Invalid authenticator code entered.");
ModelState.AddModelError(string.Empty, "Invalid authenticator code."); ModelState.AddModelError(string.Empty, "Invalid authenticator code.");
return Page(); return Page();
} }

6
src/Identity/UI/src/Areas/Identity/Pages/V4/Account/LoginWithRecoveryCode.cshtml.cs
View File

@ -113,17 +113,17 @@ namespace Microsoft.AspNetCore.Identity.UI.V4.Pages.Account.Internal
if (result.Succeeded) if (result.Succeeded)
{ {
_logger.LogInformation("User with ID '{UserId}' logged in with a recovery code.", userId); _logger.LogInformation("User logged in with a recovery code.");
return LocalRedirect(returnUrl ?? Url.Content("~/")); return LocalRedirect(returnUrl ?? Url.Content("~/"));
} }
if (result.IsLockedOut) if (result.IsLockedOut)
{ {
_logger.LogWarning("User with ID '{UserId}' account locked out.", userId); _logger.LogWarning("User account locked out.");
return RedirectToPage("./Lockout"); return RedirectToPage("./Lockout");
} }
else else
{ {
_logger.LogWarning("Invalid recovery code entered for user with ID '{UserId}' ", userId); _logger.LogWarning("Invalid recovery code entered.");
ModelState.AddModelError(string.Empty, "Invalid recovery code entered."); ModelState.AddModelError(string.Empty, "Invalid recovery code entered.");
return Page(); return Page();
} }

4
src/Identity/UI/src/Areas/Identity/Pages/V4/Account/Manage/DeletePersonalData.cshtml.cs
View File

@ -108,12 +108,12 @@ namespace Microsoft.AspNetCore.Identity.UI.V4.Pages.Account.Manage.Internal
var userId = await _userManager.GetUserIdAsync(user); var userId = await _userManager.GetUserIdAsync(user);
if (!result.Succeeded) if (!result.Succeeded)
{ {
throw new InvalidOperationException($"Unexpected error occurred deleting user with ID '{userId}'."); throw new InvalidOperationException($"Unexpected error occurred deleting user.");
} }
await _signInManager.SignOutAsync(); await _signInManager.SignOutAsync();
_logger.LogInformation("User with ID '{UserId}' deleted themselves.", userId); _logger.LogInformation("User deleted themselves.");
return Redirect("~/"); return Redirect("~/");
} }

8
src/Identity/UI/src/Areas/Identity/Pages/V4/Account/Manage/Disable2fa.cshtml.cs
View File

@ -59,7 +59,7 @@ namespace Microsoft.AspNetCore.Identity.UI.V4.Pages.Account.Manage.Internal
if (!await _userManager.GetTwoFactorEnabledAsync(user)) if (!await _userManager.GetTwoFactorEnabledAsync(user))
{ {
throw new InvalidOperationException($"Cannot disable 2FA for user with ID '{_userManager.GetUserId(User)}' as it's not currently enabled."); throw new InvalidOperationException($"Cannot disable 2FA for user as it's not currently enabled.");
} }
return Page(); return Page();
@ -76,12 +76,12 @@ namespace Microsoft.AspNetCore.Identity.UI.V4.Pages.Account.Manage.Internal
var disable2faResult = await _userManager.SetTwoFactorEnabledAsync(user, false); var disable2faResult = await _userManager.SetTwoFactorEnabledAsync(user, false);
if (!disable2faResult.Succeeded) if (!disable2faResult.Succeeded)
{ {
throw new InvalidOperationException($"Unexpected error occurred disabling 2FA for user with ID '{_userManager.GetUserId(User)}'."); throw new InvalidOperationException($"Unexpected error occurred disabling 2FA.");
} }
_logger.LogInformation("User with ID '{UserId}' has disabled 2fa.", _userManager.GetUserId(User)); _logger.LogInformation("User has disabled 2fa.");
StatusMessage = "2fa has been disabled. You can reenable 2fa when you setup an authenticator app"; StatusMessage = "2fa has been disabled. You can reenable 2fa when you setup an authenticator app";
return RedirectToPage("./TwoFactorAuthentication"); return RedirectToPage("./TwoFactorAuthentication");
} }
} }
} }

2
src/Identity/UI/src/Areas/Identity/Pages/V4/Account/Manage/DownloadPersonalData.cshtml.cs
View File

@ -59,7 +59,7 @@ namespace Microsoft.AspNetCore.Identity.UI.V4.Pages.Account.Manage.Internal
return NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."); return NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
} }
_logger.LogInformation("User with ID '{UserId}' asked for their personal data.", _userManager.GetUserId(User)); _logger.LogInformation("User asked for their personal data.");
// Only include personal data for download // Only include personal data for download
var personalData = new Dictionary<string, string>(); var personalData = new Dictionary<string, string>();

2
src/Identity/UI/src/Areas/Identity/Pages/V4/Account/Manage/EnableAuthenticator.cshtml.cs
View File

@ -143,7 +143,7 @@ namespace Microsoft.AspNetCore.Identity.UI.V4.Pages.Account.Manage.Internal
await _userManager.SetTwoFactorEnabledAsync(user, true); await _userManager.SetTwoFactorEnabledAsync(user, true);
var userId = await _userManager.GetUserIdAsync(user); var userId = await _userManager.GetUserIdAsync(user);
_logger.LogInformation("User with ID '{UserId}' has enabled 2FA with an authenticator app.", userId); _logger.LogInformation("User has enabled 2FA with an authenticator app.");
StatusMessage = "Your authenticator app has been verified."; StatusMessage = "Your authenticator app has been verified.";

2
src/Identity/UI/src/Areas/Identity/Pages/V4/Account/Manage/ExternalLogins.cshtml.cs
View File

@ -151,7 +151,7 @@ namespace Microsoft.AspNetCore.Identity.UI.V4.Pages.Account.Manage.Internal
var info = await _signInManager.GetExternalLoginInfoAsync(userId); var info = await _signInManager.GetExternalLoginInfoAsync(userId);
if (info == null) if (info == null)
{ {
throw new InvalidOperationException($"Unexpected error occurred loading external login info for user with ID '{userId}'."); throw new InvalidOperationException($"Unexpected error occurred loading external login info.");
} }
var result = await _userManager.AddLoginAsync(user, info); var result = await _userManager.AddLoginAsync(user, info);

8
src/Identity/UI/src/Areas/Identity/Pages/V4/Account/Manage/GenerateRecoveryCodes.cshtml.cs
View File

@ -68,8 +68,7 @@ namespace Microsoft.AspNetCore.Identity.UI.V4.Pages.Account.Manage.Internal
var isTwoFactorEnabled = await _userManager.GetTwoFactorEnabledAsync(user); var isTwoFactorEnabled = await _userManager.GetTwoFactorEnabledAsync(user);
if (!isTwoFactorEnabled) if (!isTwoFactorEnabled)
{ {
var userId = await _userManager.GetUserIdAsync(user); throw new InvalidOperationException($"Cannot generate recovery codes for user because they do not have 2FA enabled.");
throw new InvalidOperationException($"Cannot generate recovery codes for user with ID '{userId}' because they do not have 2FA enabled.");
} }
return Page(); return Page();
@ -84,16 +83,15 @@ namespace Microsoft.AspNetCore.Identity.UI.V4.Pages.Account.Manage.Internal
} }
var isTwoFactorEnabled = await _userManager.GetTwoFactorEnabledAsync(user); var isTwoFactorEnabled = await _userManager.GetTwoFactorEnabledAsync(user);
var userId = await _userManager.GetUserIdAsync(user);
if (!isTwoFactorEnabled) if (!isTwoFactorEnabled)
{ {
throw new InvalidOperationException($"Cannot generate recovery codes for user with ID '{userId}' as they do not have 2FA enabled."); throw new InvalidOperationException($"Cannot generate recovery codes for user as they do not have 2FA enabled.");
} }
var recoveryCodes = await _userManager.GenerateNewTwoFactorRecoveryCodesAsync(user, 10); var recoveryCodes = await _userManager.GenerateNewTwoFactorRecoveryCodesAsync(user, 10);
RecoveryCodes = recoveryCodes.ToArray(); RecoveryCodes = recoveryCodes.ToArray();
_logger.LogInformation("User with ID '{UserId}' has generated new 2FA recovery codes.", userId); _logger.LogInformation("User has generated new 2FA recovery codes.");
StatusMessage = "You have generated new recovery codes."; StatusMessage = "You have generated new recovery codes.";
return RedirectToPage("./ShowRecoveryCodes"); return RedirectToPage("./ShowRecoveryCodes");
} }

4
src/Identity/UI/src/Areas/Identity/Pages/V4/Account/Manage/ResetAuthenticator.cshtml.cs
View File

@ -74,7 +74,7 @@ namespace Microsoft.AspNetCore.Identity.UI.V4.Pages.Account.Manage.Internal
await _userManager.SetTwoFactorEnabledAsync(user, false); await _userManager.SetTwoFactorEnabledAsync(user, false);
await _userManager.ResetAuthenticatorKeyAsync(user); await _userManager.ResetAuthenticatorKeyAsync(user);
var userId = await _userManager.GetUserIdAsync(user); var userId = await _userManager.GetUserIdAsync(user);
_logger.LogInformation("User with ID '{UserId}' has reset their authentication app key.", userId); _logger.LogInformation("User has reset their authentication app key.");
await _signInManager.RefreshSignInAsync(user); await _signInManager.RefreshSignInAsync(user);
StatusMessage = "Your authenticator app key has been reset, you will need to configure your authenticator app using the new key."; StatusMessage = "Your authenticator app key has been reset, you will need to configure your authenticator app using the new key.";
@ -82,4 +82,4 @@ namespace Microsoft.AspNetCore.Identity.UI.V4.Pages.Account.Manage.Internal
return RedirectToPage("./EnableAuthenticator"); return RedirectToPage("./EnableAuthenticator");
} }
} }
} }

10
src/Identity/test/Identity.Test/SignInManagerTest.cs
View File

@ -132,7 +132,7 @@ namespace Microsoft.AspNetCore.Identity.Test
// Assert // Assert
Assert.False(result.Succeeded); Assert.False(result.Succeeded);
Assert.True(result.IsLockedOut); Assert.True(result.IsLockedOut);
Assert.Contains($"User {user.Id} is currently locked out.", logger.LogMessages); Assert.Contains($"User is currently locked out.", logger.LogMessages);
manager.Verify(); manager.Verify();
} }
@ -162,7 +162,7 @@ namespace Microsoft.AspNetCore.Identity.Test
// Assert // Assert
Assert.False(result.Succeeded); Assert.False(result.Succeeded);
Assert.True(result.IsLockedOut); Assert.True(result.IsLockedOut);
Assert.Contains($"User {user.Id} is currently locked out.", logger.LogMessages); Assert.Contains($"User is currently locked out.", logger.LogMessages);
manager.Verify(); manager.Verify();
} }
@ -771,7 +771,7 @@ namespace Microsoft.AspNetCore.Identity.Test
// Assert // Assert
Assert.False(result.Succeeded); Assert.False(result.Succeeded);
Assert.False(checkResult.Succeeded); Assert.False(checkResult.Succeeded);
Assert.Contains($"User {user.Id} failed to provide the correct password.", logger.LogMessages); Assert.Contains($"User failed to provide the correct password.", logger.LogMessages);
manager.Verify(); manager.Verify();
context.Verify(); context.Verify();
} }
@ -881,7 +881,7 @@ namespace Microsoft.AspNetCore.Identity.Test
Assert.Equal(confirmed, result.Succeeded); Assert.Equal(confirmed, result.Succeeded);
Assert.NotEqual(confirmed, result.IsNotAllowed); Assert.NotEqual(confirmed, result.IsNotAllowed);
var message = $"User {user.Id} cannot sign in without a confirmed email."; var message = $"User cannot sign in without a confirmed email.";
if (!confirmed) if (!confirmed)
{ {
Assert.Contains(message, logger.LogMessages); Assert.Contains(message, logger.LogMessages);
@ -935,7 +935,7 @@ namespace Microsoft.AspNetCore.Identity.Test
Assert.Equal(confirmed, result.Succeeded); Assert.Equal(confirmed, result.Succeeded);
Assert.NotEqual(confirmed, result.IsNotAllowed); Assert.NotEqual(confirmed, result.IsNotAllowed);
var message = $"User {user.Id} cannot sign in without a confirmed phone number."; var message = $"User cannot sign in without a confirmed phone number.";
if (!confirmed) if (!confirmed)
{ {
Assert.Contains(message, logger.LogMessages); Assert.Contains(message, logger.LogMessages);