public async void CreateProject_BadRequest_NullPost()
{
_sut.ModelState.AddModelError("x", "Test Error");
ProjectViewModel project = null;
IActionResult result = await _sut.CreateProject(project);
ObjectResult badReqResult = Assert.IsType <BadRequestObjectResult>(result);
Assert.Equal($"Please provide details to create a project.", badReqResult.Value);
// Ensure CreateProjectViaManager is never run since it should no be reached
_mockManager.Verify(x => x.CreateProject(
It.IsAny <ProjectViewModel>()), Times.Never);
}
public async Task When_the_project_is_valid_is_should_return_a_CreatedResult_with_the_new_project_id()
{
var projectManagerService = new Mock <IProjectManagerService>();
projectManagerService.Setup(pms => pms.Handle(It.IsAny <CreateProjectCommand>()))
.Returns(Task.FromResult(CommandResult.Success(Guid.Parse("11111111-1111-1111-1111-111111111111"))));
var subject = new ProjectsController(
projectManagerService.Object,
Mock.Of <IProjectRepository>(),
Mock.Of <ILogger <ProjectsController> >());
subject.ControllerContext = new ControllerContext
{
HttpContext = new DefaultHttpContext()
};
subject.ControllerContext.HttpContext.Request.Scheme = "http";
subject.ControllerContext.HttpContext.Request.Host = HostString.FromUriComponent("localhost:5000");
subject.ControllerContext.HttpContext.Request.Path = "/";
var result =
Assert.IsType <CreatedResult>(
await subject.CreateProject(new CreateProjectDto("Valid project", "Desc", "VP", "Kanban")));
Assert.EndsWith("/11111111-1111-1111-1111-111111111111", result.Location);
}
public async Task CreateProject_CallWithMockedIProject_ThrowsAndCatchesProjectException()
{
// Arrange
var mock = new Mock <IProject>();
var projectGuid = Guid.Empty;
var projectDto = new ProjectDto()
{
Id = projectGuid,
Name = "Project"
};
var message = "ExceptionThrown";
var ex = new ProjectException(message);
mock.Setup(project => project.CreateProjectAsync(projectDto)).ThrowsAsync(ex);
var projectsController = new ProjectsController(mock.Object);
// Act
var result = await projectsController.CreateProject(projectDto);
var response = (BadRequestObjectResult)result;
var objectResult = (ResponseDto <ErrorDto>)response.Value;
// Assert
Assert.IsType <BadRequestObjectResult>(result);
Assert.IsType <ResponseDto <ErrorDto> >(response.Value);
Assert.Equal(message, objectResult.Data.Message);
}
public async void PostExpected201WithLocationHeader()
{
IProjectService prjServiceFake = A.Fake <IProjectService>();
ISdlcSystemService sdlcServiceFake = A.Fake <ISdlcSystemService>();
IMapper mapServiceFake = A.Fake <IMapper>();
List <project> prjList = new List <project> {
CreateDefault()
};
var modelDTO = new ProjectDTO
{
external_id = "EXTERNALID",
name = "name"
};
modelDTO.sdlcSystem = new sdlcSystem
{
id = 1
};
A.CallTo(() => prjServiceFake.GetAllProjects()).Returns(prjList);
ProjectsController sut = CreateSut(prjServiceFake, mapServiceFake, sdlcServiceFake);
sut.ControllerContext = new Microsoft.AspNetCore.Mvc.ControllerContext();
sut.ControllerContext.HttpContext = new DefaultHttpContext();
sut.ControllerContext.HttpContext.Request.Scheme = "http";
sut.ControllerContext.HttpContext.Request.Host = new HostString("localhost");
//Act
var result = await sut.CreateProject(modelDTO);
//Assert
Assert.IsType <CreatedResult>(result);
}
public async Task When_the_new_project_is_null_it_should_return_a_BadRequest()
{
var subject = new ProjectsController(
Mock.Of <IProjectManagerService>(),
Mock.Of <IProjectRepository>(),
Mock.Of <ILogger <ProjectsController> >());
Assert.IsType <BadRequestResult>(await subject.CreateProject(null));
}
public void CreateProjectReturnsBadRequestOnInvalidData()
{
var projectData = new ProjectCreateUpdateRequestDto();
ProjectsController controller = this.ProjectsControllerInstance;
controller.ModelState.AddModelError("error", "error");
IActionResult result = controller.CreateProject(projectData);
Assert.IsType <BadRequestObjectResult>(result);
}
private HttpResponseMessage ProcessNewProject(Template newProjTemplate)
{
var ctrler = new ProjectsController
{
Configuration = new HttpConfiguration(),
Request = new HttpRequestMessage()
};
var dataFromBody = new WriteDocument {
Template = newProjTemplate
};
return(ctrler.CreateProject(dataFromBody).Result);
}
public async void PostPayloadNotContainingSystem()
{
//Arrange & Act
ProjectsController projController = new ProjectsController(_projectSvc, _mapper, _sdlcSvc);
var model = new ProjectDTO();
model.external_id = "EXTERNAL-ID";
var result = await projController.CreateProject(model);
var okResult = result as Microsoft.AspNetCore.Mvc.StatusCodeResult;
//Assert
Assert.Equal(StatusCodes.Status400BadRequest, okResult.StatusCode);
}
public async Task When_the_project_breaks_domain_rules_it_should_return_a_BadRequest()
{
var projectManagerService = new Mock <IProjectManagerService>();
projectManagerService.Setup(pms => pms.Handle(It.IsAny <CreateProjectCommand>()))
.Returns(Task.FromResult(CommandResult.Fail("business rule broken")));
var subject = new ProjectsController(
projectManagerService.Object,
Mock.Of <IProjectRepository>(),
Mock.Of <ILogger <ProjectsController> >());
var result = Assert.IsType <BadRequestObjectResult>(await subject.CreateProject(new CreateProjectDto("whatever", "description", "we", "kanban")));
Assert.Equal("business rule broken", ((string[])result.Value)[0]);
}
public async Task CreateProject()
{
//Arrange
var newDTO = CreateDefaultDTO();
var newproj = CreateDefault();
var newMap = _mapper.Map(newproj, newDTO);
// Act
var result = await _contr.CreateProject(newMap);
//Assert
var empList = result as CreatedResult;
Assert.IsType <CreatedResult>(result);
Assert.NotNull(empList);
}
public void TestValidProjectCreateReturnsOk()
{
var user = new User
{
UserId = Guid.NewGuid(),
UserName = "******",
Email = "*****@*****.**"
};
var project = new ProjectCreate
{
ProjectName = "testName",
ProjectDescription = "a test description",
ProjectExternalUrl = "https://github.com/foo/bar"
};
SetControllerHttpContext(user);
var actual = _controller.CreateProject(project);
Assert.IsInstanceOfType(actual, typeof(OkResult));
}
public async Task When_the_project_abbreviation_is_already_taken_it_should_return_a_BadRequest()
{
var projectRepository = new Mock <IProjectRepository>();
projectRepository.Setup(pr => pr.GetProjectByAbbreviation("prj-1"))
.Returns(new ProjectReadModel
{
ProjectId = Guid.Parse("11111111-1111-1111-1111-111111111111")
});
var subject = new ProjectsController(
Mock.Of <IProjectManagerService>(),
projectRepository.Object,
Mock.Of <ILogger <ProjectsController> >());
var result = Assert.IsType <BadRequestObjectResult>(
await subject.CreateProject(
new CreateProjectDto("Project1", "Desc", "prj-1", "Kanban")
));
Assert.Contains("project abbreviation", (string)result.Value);
}
public async Task CreateProject_CallWithMockedIProject_ReturnsOkObjectResult()
{
// Arrange
var mock = new Mock <IProject>();
var projectGuid = Guid.Empty;
var projectDto = new ProjectDto()
{
Id = projectGuid,
Name = "Project"
};
mock.Setup(project => project.CreateProjectAsync(projectDto)).ReturnsAsync(projectDto);
var projectsController = new ProjectsController(mock.Object);
// Act
var result = await projectsController.CreateProject(projectDto);
var response = (OkObjectResult)result;
var objectResult = (ResponseDto <ProjectDto>)response.Value;
// Assert
Assert.IsType <OkObjectResult>(result);
Assert.IsType <ResponseDto <ProjectDto> >(response.Value);
}
public async Task TestCreateProjectValidInput()
{
var projectDto = new ProjectDto
{
Title = "Title1",
Notes = "Note1",
Outcome = "Outcome1",
StartDate = new DateTime(),
EndDate = new DateTime(),
CourseIds = Enumerable.Empty <int>(),
OrganisationId = 1,
ContactId = 1
};
var organisation = new Organisation
{
Id = 1,
};
Contact contact = new Contact
{
Id = 1,
Name = "Test Name",
Email = "*****@*****.**",
PhoneNumber = "111",
OrganisationId = 1,
Projects = new List <Project>
{
new Project {
Id = 1,
Title = "HCI Extreme",
Notes = "Notes Test",
Outcome = "Outcome Test",
StartDate = new DateTime(),
EndDate = new DateTime(),
ProjectCourses = Enumerable.Empty <ProjectCourse>().ToList(),
Organisation = organisation
}
}
};
_mockProjectRepository.Setup(x => x.InsertAsync(It.IsAny <Project>())).Returns(Task.FromResult(1));
_mockOrganisationRepository.Setup(x => x.GetByIdAsync(1)).ReturnsAsync(organisation);
_mockContactRepository.Setup(x => x.GetByIdAsync(1)).Returns(Task.FromResult(contact));
// Act
ActionResult <CreatedDto> response = await _projectsController.CreateProject(projectDto);
// Assert
Assert.IsInstanceOf <CreatedResult>(response.Result);
CreatedResult createdResult = response.Result as CreatedResult;
Assert.AreEqual(201, createdResult.StatusCode);
CreatedDto value = createdResult.Value.As <CreatedDto>();
Assert.IsNotNull(value);
Assert.AreEqual(0, value.Id);
_mockProjectRepository.Verify(x => x.InsertAsync(It.IsAny <Project>()), Times.Once);
}