public async Task <IActionResult> UpdateUserPasswordAsync(PasswordInitializationRequest request)
{
if (request == null)
{
return(BadRequest(new ResultMessage
{
OperationStatus = false,
ErrorMessages = new List <string> {
MessageResources.PasswordUpdateRequestEmpty
}
}));
}
try
{
ResultMessage result = await _identityService.UpdateUserPasswordAsync(request).ConfigureAwait(false);
return(Ok(result));
}
catch (Exception)
{
return(StatusCode(500, new ResultMessage
{
OperationStatus = false,
ErrorMessages = new List <string>
{
MessageResources.PasswordUpdateFailed
}
}));
}
}
public async Task UpdateUserPasswordAsync_RequestNotNull_SuccessfulUpdate_ReturnSuccessMessage()
{
// Arrange
PasswordInitializationRequest request = new PasswordInitializationRequest
{
Login = "******",
OldPassword = "******",
NewPassword = "******"
};
User identityUser = new User
{
UserName = request.Login
};
_userManagerMock.Setup(mock => mock.FindByNameAsync(request.Login)).ReturnsAsync(identityUser);
_userManagerMock.Setup(mock => mock.ChangePasswordAsync(identityUser, request.OldPassword, request.NewPassword))
.ReturnsAsync(IdentityResult.Success);
// Act
ResultMessage resultMessage = await _identityService.UpdateUserPasswordAsync(request).ConfigureAwait(false);
// Assert
Assert.NotNull(resultMessage);
Assert.True(resultMessage.OperationStatus);
}
public async Task UpdateUserPasswordAsync_RequestNotNull_FailingUpdate_ReturnErrorMessage()
{
// Arrange
PasswordInitializationRequest request = new PasswordInitializationRequest
{
Login = "******",
OldPassword = "******",
NewPassword = "******"
};
User identityUser = new User
{
UserName = request.Login
};
string errorMessage = "stupid flanders";
_userManagerMock.Setup(mock => mock.FindByNameAsync(request.Login)).ReturnsAsync(identityUser);
_userManagerMock.Setup(mock => mock.ChangePasswordAsync(identityUser, request.OldPassword, request.NewPassword))
.ReturnsAsync(IdentityResult.Failed(new IdentityError {
Description = errorMessage
}));
// Act
ResultMessage resultMessage = await _identityService.UpdateUserPasswordAsync(request).ConfigureAwait(false);
// Assert
Assert.NotNull(resultMessage);
Assert.False(resultMessage.OperationStatus);
Assert.Equal(errorMessage, resultMessage.ErrorMessages.First());
}
public async Task InitializeUserPassword_NotNullRequest_NotAdminRole_AddNewPasswordFailed_ReturnErrorMessage()
{
// Arrange
PasswordInitializationRequest request = new PasswordInitializationRequest
{
Login = "******",
NewPassword = "******",
OldPassword = "******"
};
User identityUser = new User
{
UserName = request.Login
};
string errorMessage = "your password suck";
_userManagerMock.Setup(mock => mock.FindByNameAsync(request.Login)).ReturnsAsync(identityUser);
_userManagerMock.Setup(mock => mock.GetRolesAsync(identityUser)).ReturnsAsync(new List <string>
{
"littleKid"
});
_userManagerMock.Setup(mock => mock.RemovePasswordAsync(identityUser)).ReturnsAsync(IdentityResult.Success);
_userManagerMock.Setup(mock => mock.AddPasswordAsync(identityUser, request.NewPassword)).ReturnsAsync(
IdentityResult.Failed(new IdentityError {
Description = errorMessage
}));
// Act
ResultMessage result = await _identityService.InitializeUserPasswordAsync(request).ConfigureAwait(false);
// Assert
Assert.NotNull(result);
Assert.False(result.OperationStatus);
Assert.Equal(errorMessage, result.ErrorMessages.First());
}
public async Task InitializeUserPassword_NotNullRequest_AdminRole_ReturnErrorMessage()
{
// Arrange
PasswordInitializationRequest request = new PasswordInitializationRequest
{
Login = "******",
NewPassword = "******",
OldPassword = "******"
};
User identityUser = new User
{
UserName = request.Login
};
_userManagerMock.Setup(mock => mock.FindByNameAsync(request.Login)).ReturnsAsync(identityUser);
_userManagerMock.Setup(mock => mock.GetRolesAsync(identityUser)).ReturnsAsync(new List <string>
{
"ADMINISTRATOR"
});
// Act
ResultMessage result = await _identityService.InitializeUserPasswordAsync(request).ConfigureAwait(false);
// Assert
Assert.NotNull(result);
Assert.False(result.OperationStatus);
Assert.Equal(MessageResources.ReinitializeAdminPassword,
result.ErrorMessages.First());
}
public async Task InitializeUserPassword_NotNullRequest_NotAdminRole_SuccessOperation_ReturnSuccessMessage()
{
// Arrange
PasswordInitializationRequest request = new PasswordInitializationRequest
{
Login = "******",
NewPassword = "******",
OldPassword = "******"
};
User identityUser = new User
{
UserName = request.Login
};
_userManagerMock.Setup(mock => mock.FindByNameAsync(request.Login)).ReturnsAsync(identityUser);
_userManagerMock.Setup(mock => mock.GetRolesAsync(identityUser)).ReturnsAsync(new List <string>
{
"littleKid"
});
_userManagerMock.Setup(mock => mock.RemovePasswordAsync(identityUser)).ReturnsAsync(IdentityResult.Success);
_userManagerMock.Setup(mock => mock.AddPasswordAsync(identityUser, request.NewPassword)).ReturnsAsync(IdentityResult.Success);
// Act
ResultMessage result = await _identityService.InitializeUserPasswordAsync(request).ConfigureAwait(false);
// Assert
Assert.NotNull(result);
Assert.True(result.OperationStatus);
}
public async Task UpdateUserPasswordAsync_NotNullRequest_IdentityServiceReturnsResponse_ReturnOkResult()
{
// Arrange
PasswordInitializationRequest request = new PasswordInitializationRequest
{
Login = "******",
NewPassword = "******",
OldPassword = "******"
};
_identityServiceMock.Setup(mock => mock.UpdateUserPasswordAsync(request)).ReturnsAsync(new ResultMessage
{
OperationStatus = true
});
// Act
OkObjectResult result = await _usersController.UpdateUserPasswordAsync(request).ConfigureAwait(false)
as OkObjectResult;
// Assert
Assert.NotNull(result);;
ResultMessage authenticationResult = result.Value as ResultMessage;
Assert.True(authenticationResult.OperationStatus);
}
public async Task UpdateUserPasswordAsync_RequestNull_ThrowArgumentNullException()
{
// Arrange
PasswordInitializationRequest request = null;
// Act + Assert
ArgumentNullException exception = await Assert.ThrowsAsync <ArgumentNullException>(() =>
_identityService.UpdateUserPasswordAsync(request)).ConfigureAwait(false);
Assert.NotNull(exception);
Assert.Equal(string.Format(ErrorMessages.NullExceptionMessage, "request"), exception.Message);
}
public async Task UpdateUserPasswordAsync_NullRequest_ReturnBadRequest()
{
// Arrange
PasswordInitializationRequest request = null;
// Act
BadRequestObjectResult result = await _usersController.UpdateUserPasswordAsync(request).ConfigureAwait(false)
as BadRequestObjectResult;
// Assert
Assert.NotNull(result);
ResultMessage objectResult = result.Value as ResultMessage;
Assert.False(objectResult.OperationStatus);
Assert.Equal(MessageResources.PasswordUpdateRequestEmpty, objectResult.ErrorMessages.First());
}
/// <inheritdoc />
public async Task <ResultMessage> UpdateUserPasswordAsync(PasswordInitializationRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
User identityUser = await _userManager.FindByNameAsync(request.Login).ConfigureAwait(false);
IdentityResult changePasswordResult = await _userManager.ChangePasswordAsync(identityUser, request.OldPassword,
request.NewPassword).ConfigureAwait(false);
return(new ResultMessage
{
OperationStatus = changePasswordResult.Succeeded,
ErrorMessages = changePasswordResult.Errors?.Select(err => err.Description)
});
}
/// <inheritdoc />
public async Task <ResultMessage> InitializeUserPasswordAsync(PasswordInitializationRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
User identityUser = await _userManager.FindByNameAsync(request.Login).ConfigureAwait(false);
IList <string> identityUserRoles = await _userManager.GetRolesAsync(identityUser).ConfigureAwait(false);
if (identityUserRoles.Contains("ADMINISTRATOR"))
{
return(new ResultMessage
{
OperationStatus = false,
ErrorMessages = new List <string>
{
MessageResources.ReinitializeAdminPassword
}
});
}
IdentityResult removePasswordResult = await _userManager.RemovePasswordAsync(identityUser).ConfigureAwait(false);
if (!removePasswordResult.Succeeded)
{
return(new ResultMessage
{
OperationStatus = removePasswordResult.Succeeded,
ErrorMessages = removePasswordResult.Errors?.Select(err => err.Description)
});
}
IdentityResult newPasswordResult = await _userManager.AddPasswordAsync(identityUser, request.NewPassword).ConfigureAwait(false);
return(new ResultMessage
{
OperationStatus = newPasswordResult.Succeeded,
ErrorMessages = newPasswordResult.Errors?.Select(err => err.Description)
});
}
public async Task UpdateUserPasswordAsync_NotNullRequest_IdentityServiceThrowsException_ReturnServerError()
{
// Arrange
PasswordInitializationRequest request = new PasswordInitializationRequest
{
Login = "******",
NewPassword = "******",
OldPassword = "******"
};
_identityServiceMock.Setup(mock => mock.UpdateUserPasswordAsync(request)).ThrowsAsync(new Exception());
// Act
ObjectResult result = await _usersController.UpdateUserPasswordAsync(request).ConfigureAwait(false)
as ObjectResult;
// Assert
Assert.NotNull(result);
Assert.Equal(500, result.StatusCode);
ResultMessage resultObject = result.Value as ResultMessage;
Assert.False(resultObject.OperationStatus);
Assert.Equal(MessageResources.PasswordUpdateFailed, resultObject.ErrorMessages.First());
}
