public async void AddPostNullInput()
{
// Arrange
// Act
IActionResult actionResult = await _controller.AddPost(null);
// Assert
_cacheServiceMock.Verify(x => x.GetWsClientsAsync(), Times.Never);
_postServiceMock.Verify(x => x.AddRequestAsync(It.IsAny <PostDto>(), It.IsAny <WsClient>()), Times.Never);
_loggerMock.Verify(m => m.Log(
LogLevel.Error,
0,
It.Is <FormattedLogValues>(v => v.ToString()
.Contains($"Null input for '{typeof(PostDto).Name}'")),
null,
It.IsAny <Func <object, Exception, string> >()
));
actionResult.Should().NotBeNull().And.BeOfType <BadRequestObjectResult>();
var badRequestResult = actionResult as BadRequestObjectResult;
badRequestResult.StatusCode.Should().Be(StatusCodes.Status400BadRequest);
badRequestResult.Value.Should().NotBeNull().And.BeOfType <ResultDto>();
var resultDto = badRequestResult.Value as ResultDto;
resultDto.IsOk.Should().Be(false);
resultDto.Message.Should().NotBeNull().And.Be("Null input.");
}
public async void AddPost_ReturnsCreatedAtRouteResult_WithPostData()
{
//Arrange
_mockUserService.Setup(Service => Service.CheckIfUserExists(It.IsAny <Guid>()))
.ReturnsAsync(true)
.Verifiable();
var postEntity = _mapper.Map <PostDto>(_postToAdd);
_mockPostService.Setup(Service => Service.AddPostAsync(Guid.Parse(ConstIds.ExampleUserId), It.IsAny <PostToAddDto>()))
.ReturnsAsync(postEntity)
.Verifiable();
var controller = new PostsController(_loggerMock.Object, _mockPostService.Object, _mockUserService.Object);
//Act
var result = await controller.AddPost(ConstIds.ExampleUserId, _postToAdd);
//Assert
var redirectToActionResult = Assert.IsType <CreatedAtRouteResult>(result.Result);
Assert.Equal(ConstIds.ExampleUserId, redirectToActionResult.RouteValues["userId"].ToString());
Assert.Equal(Guid.Empty.ToString(), redirectToActionResult.RouteValues["postId"].ToString());
Assert.Equal("GetPost", redirectToActionResult.RouteName);
Assert.IsType <PostDto>(redirectToActionResult.Value);
_mockUserService.Verify();
_mockPostService.Verify();
}
public async void AddPost_ReturnsBadRequestObjectResult_WhenTheUserIdIsInvalid()
{
//Arrange
var controller = new PostsController(_loggerMock.Object, _mockPostService.Object, _mockUserService.Object);
//Act
var result = await controller.AddPost(ConstIds.InvalidGuid, _postToAdd);
//Assert
var badRequestObjectResult = Assert.IsType <BadRequestObjectResult>(result.Result);
Assert.Equal($"{ConstIds.InvalidGuid} is not valid guid.", badRequestObjectResult.Value);
}
public void PostsController_AddPost_ReturnsOk()
{
// Arrange
_postsController = new PostsController(_mockPostService.Object);
Post post = new Post {
Author = "hanna", Content = "test"
};
// Act
IHttpActionResult result = _postsController.AddPost(post);
// Assert
_mockPostService.Verify(x => x.Create(It.IsAny <Post>()), Times.Once);
Assert.IsInstanceOfType(result, typeof(OkResult));
}
public async void AddPost_ReturnsInternalServerErrorResult_WhenExceptionThrownInService()
{
//Arrange
_mockUserService.Setup(Service => Service.CheckIfUserExists(It.IsAny <Guid>()))
.Throws(new ArgumentNullException(nameof(Guid)))
.Verifiable();
var controller = new PostsController(_loggerMock.Object, _mockPostService.Object, _mockUserService.Object);
//Act
var result = await controller.AddPost(ConstIds.ExampleUserId, _postToAdd);
//Assert
var internalServerErrorResult = Assert.IsType <StatusCodeResult>(result.Result);
Assert.Equal(StatusCodes.Status500InternalServerError, internalServerErrorResult.StatusCode);
_mockUserService.Verify();
}
public async void AddPost_ReturnsNotFoundObjectResult_WhenTheUserDoesntExist()
{
//Arrange
_mockUserService.Setup(Service => Service.CheckIfUserExists(It.IsAny <Guid>()))
.ReturnsAsync(false)
.Verifiable();
var controller = new PostsController(_loggerMock.Object, _mockPostService.Object, _mockUserService.Object);
//Act
var result = await controller.AddPost(ConstIds.ExampleUserId, _postToAdd);
//Assert
var notFoundObjectResult = Assert.IsType <NotFoundObjectResult>(result.Result);
Assert.Equal($"User: {ConstIds.ExampleUserId} not found.", notFoundObjectResult.Value);
_mockUserService.Verify();
}
public void Post_ShouldReturnBadRequest_WhenGivenInvalidModel()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
PostsController controller = Controller();
controller.ModelState.AddModelError("error", "some validation error");
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
var result = controller.AddPost(post: null) as BadRequestObjectResult;
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
result.Should().BeOfType(typeof(BadRequestObjectResult), "because the create operation should not work with invalid data");
result.StatusCode.Should().Be(400, "because HTTP Status 400 should be returned to signal a Bad Request");
}
public void EmptyTable_RequestPostOnePost_CreatedPostAndLocationAreReturned()
{
//Arrange
var postBuilder = new PostBuilder();
var postRepository = DatabaseHelper.GetPostRepository("AddPost_Db");
var postsController = new PostsController(postRepository);
var post = postBuilder.Build();
//Act
var apiResponse = postsController.AddPost(post);
//Assert
var createdAtResponse = apiResponse as CreatedAtRouteResult;
Assert.NotNull(createdAtResponse);
Assert.Equal("GetPost", createdAtResponse.RouteName);
Assert.True(createdAtResponse.RouteValues.ContainsKey("id"));
var postCreated = createdAtResponse.Value as Post;
Assert.NotNull(postCreated);
Assert.Equal("Test Content", postCreated.Content);
}
