public async Task GivenAnApplicant_CreateApplicant_AddsAnApplicant()
{
var applicantToBeReturned = fixture.Create <Applicant>();
var applicantForCreationDtoToBeCreated = fixture.Create <ApplicantForCreationDto>();
var applicantDtoToBeReturned = fixture.Create <ApplicantDto>();
applicantServiceMock.Setup(mock => mock.CreateApplicant(It.IsAny <Applicant>()))
.ReturnsAsync(applicantToBeReturned);
mapperMock.Setup(mock => mock.Map <ApplicantForCreationDto>(It.IsAny <Applicant>()))
.Returns(applicantForCreationDtoToBeCreated);
mapperMock.Setup(mock => mock.Map <ApplicantDto>(It.IsAny <Applicant>()))
.Returns(applicantDtoToBeReturned);
sut = new ApplicantsController(loggerMock.Object, mapperMock.Object, applicantServiceMock.Object);
var result = await sut.CreateApplicant(applicantForCreationDtoToBeCreated);
var actionResult = Assert.IsType <ActionResult <ApplicantDto> >(result);
var applicantReturned = Assert.IsType <CreatedAtRouteResult>(actionResult.Result).Value;
Assert.Equal(applicantDtoToBeReturned, applicantReturned);
}
public async Task GivenAnExistingApplicant_UpdateApplicant_UpdatesApplicant()
{
var applicantToBeReturned = fixture.Create <Applicant>();
var applicantForUpdateDto = fixture.Create <ApplicantForUpdateDto>();
var applicantDtoToBeReturned = fixture.Create <ApplicantDto>();
applicantServiceMock.Setup(mock => mock.GetApplicant(It.Is <int>(id => id == 1)))
.ReturnsAsync(applicantToBeReturned);
applicantServiceMock.Setup(mock => mock.UpdateApplicant(It.IsAny <int>(), It.IsAny <Applicant>()))
.ReturnsAsync(Result.Success);
mapperMock.Setup(mock => mock.Map <ApplicantForUpdateDto>(It.IsAny <Applicant>()))
.Returns(applicantForUpdateDto);
mapperMock.Setup(mock => mock.Map <Applicant>(It.IsAny <ApplicantForUpdateDto>()))
.Returns(applicantToBeReturned);
mapperMock.Setup(mock => mock.Map <ApplicantDto>(It.IsAny <Applicant>()))
.Returns(applicantDtoToBeReturned);
sut = new ApplicantsController(loggerMock.Object, mapperMock.Object, applicantServiceMock.Object);
var result = await sut.UpdateApplicant(1, applicantForUpdateDto);
var actionResult = Assert.IsAssignableFrom <ActionResult>(result);
var applicantReturned = Assert.IsType <NoContentResult>(actionResult);
}
public void Index_ReturnAllApplicants()
{
//Arrange
var applicantModel = new AdminApplicantListingViewModel()
{
Id = 1,
FirstName = "FirstName",
LastName = "LastName"
};
bool methodCalled = false;
var mockRepository = new Mock <IAdminApplicantService>();
mockRepository
.Setup(s => s.All())
.Returns(new[] { applicantModel })
.Callback(() => methodCalled = true);
var controller = new ApplicantsController(mockRepository.Object);
//Act
var result = controller.Index();
//Assert
Assert.IsInstanceOfType(result, typeof(ViewResult));
var resultView = result as ViewResult;
Assert.IsNotNull(resultView.Model);
Assert.IsTrue(methodCalled);
}
public async Task Details_ShouldReturnApplicant()
{
//Arrange
var applicantModel = new AdminApplicantDetailsViewModel()
{
Id = 1,
FirstName = "FirstName",
LastName = "LastName"
};
bool serviceCalled = false;
var mockRepository = new Mock <IAdminApplicantService>();
mockRepository.Setup(service => service.Details(It.IsAny <int>()))
.ReturnsAsync(applicantModel)
.Callback(() => serviceCalled = true);
var controller = new ApplicantsController(mockRepository.Object);
//Act
var result = await controller.Details(1);
//Assert
Assert.IsInstanceOfType(result, typeof(ViewResult));
Assert.IsTrue(serviceCalled);
}
public ApplicantsControllerTests()
{
_mockMediator = new Mock <IMediator>();
_mockMediator.Setup(x => x.Send(It.IsAny <GetApplicantsQuery>(), CancellationToken.None))
.ReturnsAsync(new GetApplicantsResponse())
.Callback <GetApplicantsQuery, CancellationToken>((q, _) => _queryPassed = q);
_sut = new ApplicantsController(_mockMediator.Object);
}
public ApplicantsControllerUnitTests()
{
var svc = GetService <IApplicantDomainService>();
svc.Validator = GetService <IValidator <Applicant> >();
_controller = new ApplicantsController(svc, null);
context = GetDbContext();
}
public async Task GivenANonExistingApplicantId_GetApplicant_ReturnsNotFound()
{
sut = new ApplicantsController(loggerMock.Object, mapperMock.Object, applicantServiceMock.Object);
var result = await sut.GetApplicant(1);
var actionResult = Assert.IsType <ActionResult <ApplicantDto> >(result);
Assert.IsType <NotFoundResult>(actionResult.Result);
}
public void GetApplicantsByID_Return200()
{
var mockRepo = new Mock <IDataStore>();
ApplicantsDto mockApplicant = new ApplicantsDto("1", "Doddle", false, false);
mockRepo.Setup((repo) => repo.GetApplicantById("1")).Returns(mockApplicant);
var sut = new ApplicantsController(mockRepo.Object);
IActionResult result = sut.GetApplicantById("1");
Assert.IsType <OkObjectResult>(result);
}
public void Create_WithValidApplicant_ShouldCallService()
{
//Arrange
var model = new CreateApplicantBindingModel();
bool serviceCalled = false;
var mockRepository = new Mock <IAdminApplicantService>();
mockRepository.Setup(r => r.Create(model))
.Callback(() => serviceCalled = true);
var controller = new ApplicantsController(mockRepository.Object);
//Act
var result = controller.Create(model);
//Assert
Assert.IsTrue(serviceCalled);
}
public async Task GivenAnExistingApplicantId_GetApplicant_ReturnsAnApplicant()
{
var applicantToBeReturned = fixture.Create <Applicant>();
var applicantDtoToBeReturned = fixture.Create <ApplicantDto>();
applicantServiceMock.Setup(mock => mock.GetApplicant(It.Is <int>(id => id == 1)))
.ReturnsAsync(applicantToBeReturned);
mapperMock.Setup(mock => mock.Map <ApplicantDto>(It.IsAny <Applicant>()))
.Returns(applicantDtoToBeReturned);
sut = new ApplicantsController(loggerMock.Object, mapperMock.Object, applicantServiceMock.Object);
var result = await sut.GetApplicant(1);
var actionResult = Assert.IsType <ActionResult <ApplicantDto> >(result);
var applicantReturned = Assert.IsType <OkObjectResult>(actionResult.Result).Value;
Assert.Equal(applicantDtoToBeReturned, applicantReturned);
}
public void DeleteApplicantWithDefaultGuidShouldbeBadRequest()
{
// Arrange
_mockService.Setup(s => s.Delete(It.IsAny <string>(), It.IsAny <Guid>()))
.Returns(Task.FromResult(_mockServiceResult.Object));
var controller = new ApplicantsController(_mockService.Object)
{
ControllerContext = new ControllerContext {
HttpContext = _mockHttpContext.Object
}
};
// Act
var resultWithDefaultGuid = controller.Delete(default(Guid)).Result;
var resultWithEmptyGuid = controller.Delete(Guid.Empty).Result;
// Assert
Assert.IsType <BadRequestResult>(resultWithDefaultGuid);
Assert.IsType <BadRequestResult>(resultWithEmptyGuid);
}
public void DeleteWithNormalGuidApplicantServiceShouldbeCalledWithUsername()
{
// Arrange
_mockServiceResult.SetupProperty(r => r.Sucess, true);
_mockService.Setup(s => s.Delete(It.IsAny <string>(), It.IsAny <Guid>()))
.Returns(Task.FromResult(_mockServiceResult.Object));
var controller = new ApplicantsController(_mockService.Object)
{
ControllerContext = new ControllerContext {
HttpContext = _mockHttpContext.Object
}
};
Guid applicantId = Guid.NewGuid();
// Act
controller.Delete(applicantId).GetAwaiter().GetResult();
// Assert
_mockService.Verify(s => s.Delete(_mockUserId, applicantId), Times.Once);
}
