public void UpdatePatientDetails_ReturnsNotFound_WhenRetrievalServiceReturnsNull()
{
// Arrange
var expectedExaminationId = "expectedExaminationId";
var examinationRetrievalService = new Mock <IAsyncQueryHandler <ExaminationRetrievalQuery, Examination> >();
var patientDetailsUpdateService = new Mock <IAsyncQueryHandler <PatientDetailsUpdateQuery, Examination> >();
examinationRetrievalService.Setup(service => service.Handle(It.IsAny <ExaminationRetrievalQuery>()))
.Returns(Task.FromResult((Examination)null));
Controller = new PatientDetailsController(
LoggerMock.Object,
Mapper,
UsersRetrievalByOktaIdServiceMock.Object,
AuthorizationServiceMock.Object,
PermissionServiceMock.Object,
examinationRetrievalService.Object,
patientDetailsUpdateService.Object,
_locationParentsQueryServiceMock.Object);
var expectedPutPatientDetailsRequest = new PutPatientDetailsRequest();
// Act
var response = Controller.UpdatePatientDetails(expectedExaminationId, expectedPutPatientDetailsRequest).Result;
// Assert
var taskResult = response.Should().BeOfType <ActionResult <PutPatientDetailsResponse> >().Subject;
var notFoundObjectResult = taskResult.Result.Should().BeAssignableTo <NotFoundObjectResult>().Subject;
notFoundObjectResult.Value.Should().BeAssignableTo <PutPatientDetailsResponse>();
}
public void UpdatePatientDetails_ReturnsBadRequest_WhenModelError()
{
// Arrange
var expectedExaminationId = "expectedExaminationId";
var examinationRetrievalService = new Mock <IAsyncQueryHandler <ExaminationRetrievalQuery, Examination> >();
var patientDetailsUpdateService = new Mock <IAsyncQueryHandler <PatientDetailsUpdateQuery, Examination> >();
Controller = new PatientDetailsController(
LoggerMock.Object,
Mapper,
UsersRetrievalByOktaIdServiceMock.Object,
AuthorizationServiceMock.Object,
PermissionServiceMock.Object,
examinationRetrievalService.Object,
patientDetailsUpdateService.Object,
_locationParentsQueryServiceMock.Object);
Controller.ModelState.AddModelError("An", nameof(SystemValidationErrors.Duplicate));
var expectedPutPatientDetailsRequest = new PutPatientDetailsRequest();
// Act
var response = Controller.UpdatePatientDetails(expectedExaminationId, expectedPutPatientDetailsRequest).Result;
// Assert
var taskResult = response.Should().BeOfType <ActionResult <PutPatientDetailsResponse> >().Subject;
var badRequestObjectResult = taskResult.Result.Should().BeAssignableTo <BadRequestObjectResult>().Subject;
badRequestObjectResult.Value.Should().BeAssignableTo <PutPatientDetailsResponse>();
}
public void UpdatePatientDetails_ReturnsForbid_WhenNoPermissionAtNewMEOfficeLocation()
{
// Arrange
AuthorizationServiceMock
.SetupSequence(aus => aus.AuthorizeAsync(
It.IsAny <ClaimsPrincipal>(),
It.IsAny <ILocationPath>(),
It.IsAny <IEnumerable <IAuthorizationRequirement> >()))
.Returns(Task.FromResult(AuthorizationResult.Success()))
.Returns(Task.FromResult(AuthorizationResult.Failed()));
var expectedExaminationId = "expectedExaminationId";
var expectedExamination = new Examination()
{
ExaminationId = expectedExaminationId,
};
var examinationRetrievalService = new Mock <IAsyncQueryHandler <ExaminationRetrievalQuery, Examination> >();
var patientDetailsUpdateService = new Mock <IAsyncQueryHandler <PatientDetailsUpdateQuery, Examination> >();
UsersRetrievalByOktaIdServiceMock
.Setup(service => service.Handle(It.IsAny <UserRetrievalByOktaIdQuery>()))
.Returns(Task.FromResult(AuthorizedUser));
examinationRetrievalService
.Setup(service => service.Handle(It.IsAny <ExaminationRetrievalQuery>()))
.Returns(Task.FromResult(expectedExamination));
patientDetailsUpdateService
.Setup(pdus => pdus.Handle(It.IsAny <PatientDetailsUpdateQuery>()))
.Returns(Task.FromResult(expectedExamination));
Controller = new PatientDetailsController(
LoggerMock.Object,
Mapper,
UsersRetrievalByOktaIdServiceMock.Object,
AuthorizationServiceMock.Object,
PermissionServiceMock.Object,
examinationRetrievalService.Object,
patientDetailsUpdateService.Object,
_locationParentsQueryServiceMock.Object);
Controller.ControllerContext = GetControllerContext();
var expectedPutPatientDetailsRequest = new PutPatientDetailsRequest();
// Act
var response = Controller.UpdatePatientDetails(expectedExaminationId, expectedPutPatientDetailsRequest).Result;
// Assert
var taskResult = response.Should().BeOfType <ActionResult <PutPatientDetailsResponse> >().Subject;
taskResult.Result.Should().BeAssignableTo <ForbidResult>();
}
public void UpdatePatientDetails_DoesNotReOpenCase_WhenCaseClosed()
{
// Arrange
SetupAuthorize(AuthorizationResult.Success());
var expectedExaminationId = "expectedExaminationId";
var expectedExamination = new Examination()
{
ExaminationId = expectedExaminationId,
CaseCompleted = true,
};
var examinationRetrievalService = new Mock <IAsyncQueryHandler <ExaminationRetrievalQuery, Examination> >();
var patientDetailsUpdateService = new Mock <IAsyncQueryHandler <PatientDetailsUpdateQuery, Examination> >();
UsersRetrievalByOktaIdServiceMock
.Setup(service => service.Handle(It.IsAny <UserRetrievalByOktaIdQuery>()))
.Returns(Task.FromResult(AuthorizedUser));
examinationRetrievalService
.Setup(service => service.Handle(It.IsAny <ExaminationRetrievalQuery>()))
.Returns(Task.FromResult(expectedExamination));
patientDetailsUpdateService
.Setup(pdus => pdus.Handle(It.IsAny <PatientDetailsUpdateQuery>()))
.Returns(Task.FromResult(expectedExamination));
Controller = new PatientDetailsController(
LoggerMock.Object,
Mapper,
UsersRetrievalByOktaIdServiceMock.Object,
AuthorizationServiceMock.Object,
PermissionServiceMock.Object,
examinationRetrievalService.Object,
patientDetailsUpdateService.Object,
_locationParentsQueryServiceMock.Object);
Controller.ControllerContext = GetControllerContext();
var expectedPutPatientDetailsRequest = new PutPatientDetailsRequest();
// Act
var response = Controller.UpdatePatientDetails(expectedExaminationId, expectedPutPatientDetailsRequest).Result;
// Assert
var taskResult = response.Should().BeOfType <ActionResult <PutPatientDetailsResponse> >().Subject;
var okObjectResult = taskResult.Result.Should().BeAssignableTo <OkObjectResult>().Subject;
var okObjectResultValue = okObjectResult.Value.Should().BeAssignableTo <PutPatientDetailsResponse>().Subject;
okObjectResultValue.Header.Should().NotBeNull();
expectedExamination.CaseCompleted.Should().BeTrue();
}
public async Task <ActionResult <PutPatientDetailsResponse> > UpdatePatientDetails(string examinationId,
[FromBody][ExaminationValidationModelBinderContext("examinationId")] PutPatientDetailsRequest putPatientDetailsRequest)
{
if (!ModelState.IsValid)
{
return(BadRequestEnums(new PutPatientDetailsResponse()));
}
var examination =
await _examinationRetrievalService.Handle(new ExaminationRetrievalQuery(examinationId, null));
if (examination == null)
{
return(NotFound(new PutPatientDetailsResponse()));
}
// Do they have update permission on the examination being updated
if (!CanAsync(Permission.UpdateExamination, examination))
{
return(Forbid());
}
var patientDetails = Mapper.Map <PatientDetails>(putPatientDetailsRequest);
var locations = (await _locationParentsService.Handle(
new LocationParentsQuery(patientDetails.MedicalExaminerOfficeResponsible))).ToList();
var locationPath = new LocationPath();
locationPath.UpdateLocationPath(locations);
// Do they have permission at this location to update the examination. I.e. they're changing the Medical Examiner Office.
if (!CanAsync(Permission.UpdateExamination, locationPath))
{
return(Forbid());
}
var myUser = await CurrentUser();
var result = await _patientDetailsUpdateService.Handle(new PatientDetailsUpdateQuery(
examinationId,
patientDetails,
myUser,
locations));
var patientCard = Mapper.Map <PatientCardItem>(result);
return(Ok(new PutPatientDetailsResponse
{
Header = patientCard
}));
}
