public async Task CreateIssueAsync_Where_SaveChangesAsync_Fails_Should__return_a_IssueNotCreatedException_Test()
{
// Arrange
const int id = 4;
var expectedLog = $"Creating new Issue: {id} Failed!";
var newIssueDto = new IssueForCreationDto
{
Id = 4, IssueDescription = "Test 4", DateAdded = DateTimeOffset.Now
};
RepositoryWrapperMock
.Setup(x => x.Issue.GetIssueByIdAsync(id))
.ReturnsAsync(default(Issue)).Verifiable();
RepositoryWrapperMock
.Setup(x => x.SaveAsync())
.Throws(new Exception("Save Changes Failed")).Verifiable();
// Act
await Assert.ThrowsAsync <IssueNotCreatedException>(() => ServiceUnderTest.CreateIssueAsync(newIssueDto));
// Assert
LoggerMock.VerifyLog(LogLevel.Error, expectedLog);
RepositoryWrapperMock.Verify(x => x.SaveAsync(), Times.Once);
}
public async Task CreateIssueAsync_Should_create_and_return_the_specified_Issue_Test()
{
// Arrange
const int id = 5;
var newIssueDto = new IssueForCreationDto
{
Id = 5, IssueDescription = "Test 5", DateAdded = DateTimeOffset.Now
};
RepositoryWrapperMock
.Setup(x => x.Issue.GetIssueByIdAsync(It.IsAny <int>()))
.ReturnsAsync(default(Issue)).Verifiable();
RepositoryWrapperMock
.Setup(x => x.SaveAsync())
.Returns(() => Task.Run(() => { return(1); })).Verifiable();
// Act
var result = await ServiceUnderTest.CreateIssueAsync(newIssueDto);
// Assert
result.Should().NotBeNull();
result.Should().BeOfType <IssueDto>();
result.Id.Should().Be(id);
result.IssueDescription.Should().Be(newIssueDto.IssueDescription);
RepositoryWrapperMock.Verify(x => x.SaveAsync(), Times.Once);
}
public async Task <IActionResult> CreateIssueAsync([FromBody] IssueForCreationDto issue)
{
try
{
if (issue == null)
{
_logger.LogError("Issue object sent from client is null");
return(BadRequest("Issue object sent from client is null."));
}
if (await _issueService.IssueExistsAsync(issue.Id))
{
_logger.LogError("Issue object sent from client already exists");
return(BadRequest("Issue object sent from client already exists."));
}
if (!ModelState.IsValid)
{
_logger.LogError("Invalid issue object sent from client");
return(BadRequest(ModelState));
}
var createdIssue = await _issueService.CreateIssueAsync(issue);
return(CreatedAtRoute(nameof(IssueByIdAsync), new { id = createdIssue.Id }, createdIssue));
}
catch (Exception ex)
{
_logger.LogError("Something went wrong inside CreateIssueAsync action: {Message}", ex.Message);
return(StatusCode(500, "Internal server error"));
}
}
public async Task CreateIssueAsync_With_An_Exception_Should_Return_StatusCode_500_Test()
{
// Arrange
var issueToCreate = new IssueForCreationDto {
IssueDescription = "Test 1"
};
const string expectedLog = "Something went wrong inside CreateIssueAsync action: Some Error";
const string expectedValue = "Internal server error";
IssueServiceMock
.Setup(x => x.CreateIssueAsync(It.IsAny <IssueForCreationDto>()))
.ThrowsAsync(new Exception("Some Error"));
// Act
var result = await ControllerUnderTest.CreateIssueAsync(issueToCreate);
// Assert
result.Should().BeOfType <ObjectResult>();
LoggerMock.Invocations.Count.Should().Be(1);
LoggerMock.Invocations[0].Arguments[2].ToString().Should().Contain(expectedLog);
var content = (ObjectResult)result;
content.StatusCode.Should().Be(500);
content.Value.Should().Be(expectedValue);
}
public async Task CreateIssueAsync_Should_Return_CreatedAtActionResult_With_The_created_Issue_Test()
{
// Arrange
var expectedCreatedAtActionName = nameof(IssueController.IssueByIdAsync);
var issueToCreate = new IssueForCreationDto {
IssueDescription = "Test 1"
};
var expectedResult = new IssueDto {
Id = 1, IssueDescription = "Test 1"
};
IssueServiceMock
.Setup(x => x.CreateIssueAsync(issueToCreate))
.ReturnsAsync(expectedResult);
// Act
var result = await ControllerUnderTest.CreateIssueAsync(issueToCreate);
// Assert
var createdResult = Assert.IsType <CreatedAtRouteResult>(result);
Assert.Same(expectedResult, createdResult.Value);
Assert.Equal(expectedCreatedAtActionName, createdResult.RouteName);
Assert.Equal(expectedResult.Id, createdResult.RouteValues.GetValueOrDefault("id")
);
}
public async Task CreateIssueAsync(IssueForCreationDto issue)
{
using var response = await _apiHelper.ApiClient.PostAsJsonAsync("/api/CreateIssueAsync", issue);
if (response.IsSuccessStatusCode)
{
// Log successful call?
}
else
{
throw new Exception(response.ReasonPhrase);
}
}
public async Task <IActionResult> CreateIssueForProject(Guid projectId, IssueForCreationDto issueForCreation)
{
if (issueForCreation.DueDate != null && issueForCreation.DueDate < DateTime.Today)
{
return(BadRequest("Due Date cannot be before today"));
}
var projectFromRepo = await _repository.Project.GetProject(projectId);
if (projectFromRepo == null)
{
return(BadRequest("Project doesn't exist"));
}
Severity severity;
Classification classify;
Stage status;
Enum.TryParse(issueForCreation.Severity, out severity);
Enum.TryParse(issueForCreation.Classification, out classify);
Enum.TryParse(issueForCreation.Status, out status);
var issueToCreate = _mapper.Map <Issue>(issueForCreation);
var reporterId = Guid.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier));
issueToCreate.Severity = severity;
issueToCreate.Classification = classify;
issueToCreate.Status = status;
issueToCreate.ProjectId = projectId;
issueToCreate.ReporterId = reporterId;
issueToCreate.Created = DateTime.Now;
_repository.Issue.CreateIssue(issueToCreate);
var saveIssue = await _repository.SaveAsync();
if (!saveIssue)
{
throw new Exception("Failed to create issue for project");
}
var issueToReturn = _mapper.Map <IssueForDetailedDto>(issueToCreate);
return(CreatedAtRoute("GetIssue",
new { projectId = issueToCreate.ProjectId, issueId = issueToCreate.IssueId }, issueToReturn));
}
public async Task <IssueDto> CreateIssueAsync(IssueForCreationDto issue)
{
var issueEntity = _mapper.Map <Issue>(issue);
_repositoryWrapper.Issue.CreateIssue(issueEntity);
try
{
await _repositoryWrapper.SaveAsync();
return(_mapper.Map <Issue, IssueDto>(issueEntity));
}
catch (Exception ex)
{
_logger.LogError(ex, "Creating new Issue: {Id} Failed!", issue.Id);
throw new IssueNotCreatedException(_mapper.Map <Issue>(issue));
}
}
public async Task CreateIssueAsync_With_Invalid_Id_Should_Return_BadRequestResult_Test()
{
// Arrange
var expectedIssue = new IssueForCreationDto()
{
Id = 1, IssueDescription = "Test 1", DateAdded = DateTimeOffset.Now
};
ControllerUnderTest.ModelState.AddModelError("Id", "Some Error");
// Act
var result = await ControllerUnderTest.CreateIssueAsync(expectedIssue);
// Assert
var badRequestResult = Assert.IsType <BadRequestObjectResult>(result);
Assert.IsType <SerializableError>(badRequestResult.Value);
}
