public void PostMedicalTeam_MedicalteamUpdateServiceErrors_Returns_Expected_Type()
{
// Arrange
SetupAuthorize(AuthorizationResult.Success());
var examinationId = Guid.NewGuid().ToString();
var examination = new Examination
{
ExaminationId = examinationId
};
const Examination nullExamination = (Examination)null;
var putMedicalTeamRequest = new PutMedicalTeamRequest();
UsersRetrievalByOktaIdServiceMock
.Setup(service => service.Handle(It.IsAny <UserRetrievalByOktaIdQuery>()))
.Returns(Task.FromResult(AuthorizedUser));
_examinationRetrievalServiceMock
.Setup(service => service.Handle(It.IsAny <ExaminationRetrievalQuery>()))
.Returns(Task.FromResult(examination));
_medicalTeamUpdateServiceMock
.Setup(u => u.Handle(It.IsAny <Examination>(), "a"))
.Returns(Task.FromResult(nullExamination));
Controller.ControllerContext = GetControllerContext();
// Act
var response = Controller.PutMedicalTeam(examinationId, putMedicalTeamRequest).Result;
// Assert
var taskResult = response.Should().BeOfType <ActionResult <PutMedicalTeamResponse> >().Subject;
taskResult.Result.Should().BeAssignableTo <BadRequestObjectResult>();
}
public void PostMedicalTeam_Forbid()
{
// Arrange
SetupAuthorize(AuthorizationResult.Failed());
var examinationId = Guid.NewGuid().ToString();
const string expectedNursingTeamInformation = "expectedNursingTeamInformation";
var examination = new Examination
{
ExaminationId = examinationId,
};
var postMedicalTeamRequest = new PutMedicalTeamRequest()
{
NursingTeamInformation = expectedNursingTeamInformation,
};
_examinationRetrievalServiceMock.Setup(service => service.Handle(It.IsAny <ExaminationRetrievalQuery>()))
.Returns(Task.FromResult(examination));
_medicalTeamUpdateServiceMock.Setup(u => u.Handle(It.IsAny <Examination>(), It.IsAny <string>()))
.Returns(Task.FromResult(examination));
Controller.ControllerContext = GetControllerContext();
// Act
var response = Controller.PutMedicalTeam(examinationId, postMedicalTeamRequest).Result;
// Assert
var taskResult = response.Should().BeOfType <ActionResult <PutMedicalTeamResponse> >().Subject;
taskResult.Result.Should().BeAssignableTo <ForbidResult>();
}
public async void BindModelAsync_ThrowsInvalidOperationException_WhenExaminationRetrievalServiceNotRegistered()
{
// Arrange
var expectedModelBinder = new Mock <IModelBinder>();
var expectedParameterName = "expectedParameterName";
var sut = new ExaminationValidationModelBinder(expectedModelBinder.Object);
var context = new Mock <ModelBindingContext>(MockBehavior.Strict);
var expectedModel = new PutMedicalTeamRequest();
var modelMetadata = MockDefaultModelMetadata();
context
.Setup(c => c.HttpContext.RequestServices.GetService(
typeof(IAsyncQueryHandler <ExaminationRetrievalQuery, MedicalExaminer.Models.Examination>)))
.Returns(null);
expectedModelBinder
.Setup(emb => emb.BindModelAsync(It.IsAny <ModelBindingContext>()))
.Returns((ModelBindingContext mbc) => Task.CompletedTask);
context
.SetupGet(c => c.ModelMetadata)
.Returns(modelMetadata);
context
.Setup(c => c.ValueProvider.GetValue(expectedParameterName))
.Returns(new ValueProviderResult(new[] { "1" }));
context.SetupGet(c => c.Result).Returns(ModelBindingResult.Success(expectedModel));
// Act
Func <Task> act = async() => await sut.BindModelAsync(context.Object);
// Assert
act.Should().Throw <InvalidOperationException>();
}
public async void BindModelAsync_SetsExaminationOnContextProvider()
{
// Arrange
var expectedModelBinder = new Mock <IModelBinder>(MockBehavior.Strict);
var expectedParameterName = "expectedParameterName";
var modelMetadata = MockDefaultModelMetadata();
var sut = new ExaminationValidationModelBinder(expectedModelBinder.Object);
var context = new Mock <ModelBindingContext>(MockBehavior.Strict);
var expectedModel = new PutMedicalTeamRequest();
var expectedExamination = new Examination();
var examinationRetrievalServiceMock =
new Mock <IAsyncQueryHandler <ExaminationRetrievalQuery, MedicalExaminer.Models.Examination> >(MockBehavior.Strict);
examinationRetrievalServiceMock
.Setup(ers => ers.Handle(It.IsAny <ExaminationRetrievalQuery>()))
.Returns(Task.FromResult(expectedExamination));
context
.Setup(c => c.HttpContext.RequestServices.GetService(
typeof(IAsyncQueryHandler <ExaminationRetrievalQuery, MedicalExaminer.Models.Examination>)))
.Returns(examinationRetrievalServiceMock.Object);
var examinationValidationContextFactory = new ExaminationValidationContextFactory();
context
.Setup(c => c.HttpContext.RequestServices.GetService(
typeof(ExaminationValidationContextFactory)))
.Returns(examinationValidationContextFactory);
var examinationValidationContextProvider = new ExaminationValidationContextProvider();
context
.Setup(c => c.HttpContext.RequestServices.GetService(
typeof(ExaminationValidationContextProvider)))
.Returns(examinationValidationContextProvider);
expectedModelBinder
.Setup(emb => emb.BindModelAsync(It.IsAny <ModelBindingContext>()))
.Returns((ModelBindingContext mbc) => Task.CompletedTask);
context
.SetupGet(c => c.ModelMetadata)
.Returns(modelMetadata);
context
.Setup(c => c.ValueProvider.GetValue(expectedParameterName))
.Returns(new ValueProviderResult(new[] { "1" }));
context.SetupGet(c => c.Result).Returns(ModelBindingResult.Success(expectedModel));
// Act
await sut.BindModelAsync(context.Object);
// Assert
examinationValidationContextProvider.Current.Examination.Should().Be(expectedExamination);
}
public async Task PutMedicalTeam_ShouldReturnBadRequest_WhenModelStateInvalid()
{
// Arrange
var examinationId = "examinationId";
var request = new PutMedicalTeamRequest();
Controller.ControllerContext = GetControllerContext();
Controller.ModelState.AddModelError("An", "Error");
// Act
var response = await Controller.PutMedicalTeam(examinationId, request);
// Assert
response.Result.Should().BeAssignableTo <BadRequestObjectResult>();
var result = (BadRequestObjectResult)response.Result;
result.Value.Should().BeAssignableTo <PutMedicalTeamResponse>();
var model = (PutMedicalTeamResponse)result.Value;
model.Errors.Count.Should().Be(1);
model.Success.Should().BeFalse();
}
public void PostMedicalTeam_Invalid_ExaminationId_Returns_Expected_Result()
{
// Arrange
var examinationId = Guid.NewGuid().ToString();
const Examination examination = null;
var postMedicalTeamRequest = new PutMedicalTeamRequest();
_examinationRetrievalServiceMock.Setup(service => service.Handle(It.IsAny <ExaminationRetrievalQuery>()))
.Returns(Task.FromResult(examination));
_medicalTeamUpdateServiceMock.Setup(u => u.Handle(It.IsAny <Examination>(), "a"))
.Returns(Task.FromResult(examination));
Controller.ControllerContext = GetControllerContext();
// Act
var response = Controller.PutMedicalTeam(examinationId, postMedicalTeamRequest).Result;
// Assert
var taskResult = response.Should().BeOfType <ActionResult <PutMedicalTeamResponse> >().Subject;
taskResult.Result.Should().BeAssignableTo <NotFoundResult>();
}
public async Task <ActionResult <PutMedicalTeamResponse> > PutMedicalTeam(
string examinationId,
[FromBody][ExaminationValidationModelBinderContext("examinationId")] PutMedicalTeamRequest putMedicalTeamRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(new PutMedicalTeamResponse()));
}
var medicalTeamRequest = Mapper.Map <MedicalTeam>(putMedicalTeamRequest);
var myUser = await CurrentUser();
var examination = await _examinationRetrievalService.Handle(new ExaminationRetrievalQuery(examinationId, null));
if (examination == null)
{
return(NotFound());
}
if (!CanAsync(Permission.UpdateExamination, examination))
{
return(Forbid());
}
examination.MedicalTeam = medicalTeamRequest;
var returnedExamination = await _medicalTeamUpdateService.Handle(examination, myUser.UserId);
if (returnedExamination == null)
{
return(BadRequest(new PutMedicalTeamResponse()));
}
var response = Mapper.Map <PutMedicalTeamResponse>(returnedExamination);
return(Ok(response));
}
