public async Task TestCreateStory_Created()
{
// Arrange
Guid expectedStoryId = Guid.NewGuid();
RequestStoryDTO requestStoryDTO = new RequestStoryDTO
{
StoryId = expectedStoryId,
Title = "",
Body = "",
PublishedDate = DateTime.UtcNow
};
DBStatus dbStatus = DBStatus.Added;
storiesService.Setup(x => x.CreateStoryAsync(requestStoryDTO, "akash")).ReturnsAsync(dbStatus);
storiesController.ControllerContext = httpContext;
//Act
var actionResult = await storiesController.CreateStory(requestStoryDTO) as CreatedAtActionResult;
//Assert
Assert.NotNull(actionResult);
Assert.Equal(201, actionResult.StatusCode);
Assert.Equal(expectedStoryId.ToString(), actionResult.RouteValues.GetValueOrDefault("storyId").ToString());
}
public async Task <IActionResult> UpdateStory([FromBody] RequestStoryDTO storyDTO)
{
string userId = HttpContext.User.Claims.FirstOrDefault(c => c.Type == System.Security.Claims.ClaimTypes.Sid).Value;
DBStatus status = await storiesService.ReplaceStoryAsync(storyDTO, userId);
ResponseStatusDTO responseStatusDTO = new ResponseStatusDTO((int)status, status.ToString());
if (status == DBStatus.NotFound)
{
return(NotFound());
}
else if (status == DBStatus.Forbidden)
{
return(Forbid());
}
else if (status == DBStatus.NotModified)
{
return(BadRequest(new BadResponseDTO {
Status = (int)status, Errors = new Errors {
Message = new List <string> {
status.ToString()
}
}
}));
}
else if (status == DBStatus.PreconditionFailed)
{
return(StatusCode(StatusCodes.Status412PreconditionFailed));
}
else
{
return(Ok(responseStatusDTO));
}
}
public async Task TestUpdateStory_Ok()
{
//Arrange
string expectedTitle = "LoremIpsum";
string userId = "akash";
DBStatus status = DBStatus.Modified;
RequestStoryDTO storyDTO = new RequestStoryDTO {
Title = expectedTitle
};
storiesService.Setup(x => x.ReplaceStoryAsync(storyDTO, userId)).ReturnsAsync(status);
storiesController.ControllerContext = httpContext;
//Act
var result = await storiesController.UpdateStory(storyDTO) as OkObjectResult;
//Assert
Assert.NotNull(result);
var response = result.Value as ResponseStatusDTO;
Assert.Equal(200, result.StatusCode);
Assert.Equal("Modified", response.Message);
}
public async Task <DBStatus> CreateStoryAsync(RequestStoryDTO storyDTO, string userId)
{
Story story = mapper.Map <Story>(storyDTO);
story.AuthorId = userId;
DBStatus status = await storiesRepository.AddStoryAsync(story);
return(status);
}
public IEnumerator <object[]> GetEnumerator()
{
RequestStoryDTO story = new RequestStoryDTO
{
StoryId = Guid.NewGuid(),
Title = "Corona Virus",
Body = "Corona virus is a huge threat for Mankind",
PublishedDate = DateTime.UtcNow
};
yield return(new object[] { story });
}
public async Task TestReplaceStory_NotModified(RequestStoryDTO requestStoryDTO)
{
//Arrange
string userId = "akash";
DBStatus expectedStatus = DBStatus.NotModified;
storiesRepository.Setup(x => x.ReplaceStoryAsync(requestStoryDTO, userId)).ReturnsAsync(expectedStatus);
//Act
DBStatus actualStatus = await storiesService.ReplaceStoryAsync(requestStoryDTO, userId);
//Assert
Assert.Equal(expectedStatus, actualStatus);
}
public async Task TestCreateStory_Failed(RequestStoryDTO requestStoryDTO, Story story)
{
//Arrange
string userId = "akash";
DBStatus expectedStatus = DBStatus.Failed;
mapper.Setup(m => m.Map <Story>(requestStoryDTO)).Returns(story);
storiesRepository.Setup(x => x.AddStoryAsync(story))
.ReturnsAsync(expectedStatus);
//Act
DBStatus status = await storiesService.CreateStoryAsync(requestStoryDTO, userId);
//Assert
Assert.Equal(expectedStatus, status);
}
public async Task TestReplaceStory_Modified(RequestStoryDTO requestStoryDTO, Story story)
{
//Arrange
DBStatus expectedStatus = DBStatus.Modified;
dbContext.Stories.Add(story);
dbContext.SaveChanges();
requestStoryDTO.Title = "changed";
//Act
DBStatus actualStatus = await storiesRepository.ReplaceStoryAsync(requestStoryDTO, "akash");
//Assert
Assert.Equal(expectedStatus, actualStatus);
}
public async Task TestCreateStory_BadRequest(RequestStoryDTO requestStoryDTO)
{
// Arrange
DBStatus dbStatus = DBStatus.Failed;
storiesService.Setup(x => x.CreateStoryAsync(requestStoryDTO, "akash")).ReturnsAsync(dbStatus);
storiesController.ControllerContext = httpContext;
//Act
var actionResult = await storiesController.CreateStory(requestStoryDTO) as BadRequestObjectResult;
//Assert
Assert.NotNull(actionResult);
Assert.Equal(400, actionResult.StatusCode);
BadResponseDTO badResponseDTO = actionResult.Value as BadResponseDTO;
Assert.Equal(1, badResponseDTO.Status);
}
public async Task TestUpdateStory_NotFound()
{
//Arrange
string expectedTitle = "LoremIpsum";
string userId = "akash";
DBStatus status = DBStatus.NotFound;
RequestStoryDTO storyDTO = new RequestStoryDTO {
Title = expectedTitle
};
storiesService.Setup(x => x.ReplaceStoryAsync(storyDTO, userId)).ReturnsAsync(status);
storiesController.ControllerContext = httpContext;
//Act
var result = await storiesController.UpdateStory(storyDTO) as NotFoundResult;
//Assert
Assert.NotNull(result);
Assert.Equal(404, result.StatusCode);
}
public IEnumerator <object[]> GetEnumerator()
{
Guid storyId = Guid.NewGuid();
RequestStoryDTO requestStoryDTO = new RequestStoryDTO
{
StoryId = storyId,
Title = "Corona Virus",
Body = "Corona virus is a huge threat for Mankind",
PublishedDate = DateTime.UtcNow
};
Story story = new Story
{
StoryId = storyId,
Title = "Corona Virus",
Body = "Corona virus is a huge threat for Mankind",
PublishedDate = DateTime.UtcNow,
AuthorId = "akash"
};
yield return(new object[] { requestStoryDTO, story });
}
public async Task <IActionResult> CreateStory([FromBody] RequestStoryDTO storyDTO)
{
string userId = HttpContext.User.Claims.FirstOrDefault(c => c.Type == System.Security.Claims.ClaimTypes.Sid).Value;
DBStatus status = await storiesService.CreateStoryAsync(storyDTO, userId);
ResponseStatusDTO responseStatusDTO = new ResponseStatusDTO((int)status, status.ToString());
if (status == DBStatus.Failed)
{
return(BadRequest(new BadResponseDTO {
Status = (int)status, Errors = new Errors {
Message = new List <string> {
status.ToString()
}
}
}));
}
else
{
return(CreatedAtAction(nameof(GetStory), new { storyId = storyDTO.StoryId }, null));
}
}
public async Task <DBStatus> ReplaceStoryAsync(RequestStoryDTO storyDTO, string userId)
{
Story persistentStory = await blogContext.Stories.FirstOrDefaultAsync(story => story.StoryId == storyDTO.StoryId);
if (persistentStory == null)
{
return(DBStatus.NotFound);
}
if (userId != persistentStory.AuthorId)
{
return(DBStatus.Forbidden);
}
persistentStory.Title = storyDTO.Title;
persistentStory.Body = storyDTO.Body;
persistentStory.PublishedDate = storyDTO.PublishedDate;
persistentStory.LastModified = DateTime.UtcNow;
var resultStatus = await blogContext.SaveChangesAsync();
return(resultStatus == 0 ? DBStatus.NotModified : DBStatus.Modified);
}
public async Task <DBStatus> ReplaceStoryAsync(RequestStoryDTO storyDTO, string userId)
{
DBStatus status = await storiesRepository.ReplaceStoryAsync(storyDTO, userId);
return(status);
}
