public async void AddComment_ReturnsNotFoundObjectResult_WhenThePostOrUserDoesntExist(bool doesTheUserExists, bool doesThePostExists)
{
//Arrange
_mockPostService.Setup(Service => Service.CheckIfPostExists(It.IsAny <Guid>()))
.Returns(doesThePostExists)
.Verifiable();
_mockUserService.Setup(Service => Service.CheckIfUserExists(It.IsAny <Guid>()))
.ReturnsAsync(doesTheUserExists)
.Verifiable();
var controller = new PostCommentsController(_loggerMock.Object, _mockPostService.Object, _mockUserService.Object, _mockCommentService.Object);
//Act
var result = await controller.AddComment(ConstIds.ExampleUserId, ConstIds.ExamplePostId, _commentToAdd);
//Assert
var notFoundObjectResult = Assert.IsType <NotFoundObjectResult>(result.Result);
Assert.Equal($"User: {ConstIds.ExampleUserId} or post {ConstIds.ExamplePostId} not found.", notFoundObjectResult.Value);
_mockPostService.Verify();
//if post doesnt exist the user will not be checked
if (doesThePostExists)
{
_mockUserService.Verify();
}
}
public async void AddComment_ReturnsCreatedAtRouteResult_WithPostCommentData()
{
//Arrange
_mockPostService.Setup(Service => Service.CheckIfPostExists(It.IsAny <Guid>()))
.Returns(true)
.Verifiable();
_mockUserService.Setup(Service => Service.CheckIfUserExists(It.IsAny <Guid>()))
.ReturnsAsync(true)
.Verifiable();
var commentEntity = _mapper.Map <PostCommentDto>(_commentToAdd);
commentEntity.Id = new Guid(ConstIds.ExampleCommentId);
_mockCommentService.Setup(Service => Service.AddCommentAsync(It.IsAny <Guid>(), It.IsAny <PostCommentToAddDto>()))
.ReturnsAsync(commentEntity)
.Verifiable();
var controller = new PostCommentsController(_loggerMock.Object, _mockPostService.Object, _mockUserService.Object, _mockCommentService.Object);
//Act
var result = await controller.AddComment(ConstIds.ExampleUserId, ConstIds.ExamplePostId, _commentToAdd);
//Assert
var redirectToActionResult = Assert.IsType <CreatedAtRouteResult>(result.Result);
Assert.Equal(ConstIds.ExampleUserId, redirectToActionResult.RouteValues["userId"].ToString());
//Assert.Equal(_commentToAdd.PostId.ToString(), redirectToActionResult.RouteValues["postId"].ToString());
Assert.Equal(ConstIds.ExampleCommentId, redirectToActionResult.RouteValues["commentId"].ToString());
Assert.Equal("GetComment", redirectToActionResult.RouteName);
_mockCommentService.Verify();
_mockPostService.Verify();
_mockUserService.Verify();
}
public void GetComments_ReturnsOkObjectResult_WithListOfCommentsData()
{
//Arrange
var comments = GetTestPostData();
var pagedList = PagedList <PostCommentDto> .Create(comments, _paginationsParams.PageNumber, _paginationsParams.PageSize, _paginationsParams.Skip);
_mockPostService.Setup(Service => Service.CheckIfPostExists(It.IsAny <Guid>()))
.Returns(true)
.Verifiable();
_mockCommentService.Setup(Service => Service.GetPostComments(It.IsAny <Guid>(), _paginationsParams))
.Returns(pagedList)
.Verifiable();
var mockUrlHelper = new Mock <IUrlHelper>();
mockUrlHelper
.Setup(m => m.Link("GetMessagesWith", It.IsAny <object>()))
.Returns("some url")
.Verifiable();
var controller = new PostCommentsController(_loggerMock.Object, _mockPostService.Object, _mockUserService.Object, _mockCommentService.Object)
{
Url = mockUrlHelper.Object
};
//Act
var result = controller.GetComments(ConstIds.ExamplePostId, _paginationsParams);
//Assert
var actionResult = Assert.IsType <OkObjectResult>(result.Result);
var model = Assert.IsType <CollectionWithPaginationData <PostCommentDto> >(actionResult.Value);
_mockCommentService.Verify();
_mockPostService.Verify();
}
public async void PartiallyUpdateComment_ReturnsBadRequestObjectResult_WhenTheCommentIdIsInvalid()
{
//Arrange
var controller = new PostCommentsController(_loggerMock.Object, _mockPostService.Object, _mockUserService.Object, _mockCommentService.Object);
//Act
var result = await controller.PartiallyUpdateComment(ConstIds.InvalidGuid, GetJsonPatchDocument());
//Assert
var badRequestObjectResult = Assert.IsType <BadRequestObjectResult>(result);
Assert.Equal($"{ConstIds.InvalidGuid} is not valid guid.", badRequestObjectResult.Value);
}
public async void AddComment_ReturnsBadRequestObjectResult_WhenThePostOrUserIdIsInvalid(string userTestId, string postTestId)
{
//Arrange
var controller = new PostCommentsController(_loggerMock.Object, _mockPostService.Object, _mockUserService.Object, _mockCommentService.Object);
//Act
var result = await controller.AddComment(userTestId, postTestId, _commentToAdd);
//Assert
var badRequestObjectResult = Assert.IsType <BadRequestObjectResult>(result.Result);
Assert.Equal($"{userTestId} or {postTestId} is not valid guid.", badRequestObjectResult.Value);
}
public void GetComments_ReturnsBadRequestObjectResult_WhenThePostIdIsInvalid()
{
//Arrange
var controller = new PostCommentsController(_loggerMock.Object, _mockPostService.Object, _mockUserService.Object, _mockCommentService.Object);
//Act
var result = controller.GetComments(ConstIds.InvalidGuid, _paginationsParams);
//Assert
var badRequestObjectResult = Assert.IsType <BadRequestObjectResult>(result.Result);
Assert.Equal($"{ConstIds.InvalidGuid} is not valid guid.", badRequestObjectResult.Value);
}
public void GetComment_ReturnsBadRequestObjectResult_WhenThePostOrCommentIdIsInvalid(string testPostId, string testCommentId)
{
//Arrange
var controller = new PostCommentsController(_loggerMock.Object, _mockPostService.Object, _mockUserService.Object, _mockCommentService.Object);
//Act
var result = controller.GetComment(testPostId, testCommentId);
//Assert
var badRequestObjectResult = Assert.IsType <BadRequestObjectResult>(result.Result);
Assert.Equal($"{testPostId} or {testCommentId} is not valid guid.", badRequestObjectResult.Value);
}
public async void DeleteComment_ReturnsNoContentResult_WhenTheCommentHasBeenRemoved()
{
//Arrange
_mockCommentService.Setup(Service => Service.DeleteCommentAsync(It.IsAny <Guid>()))
.Verifiable();
var controller = new PostCommentsController(_loggerMock.Object, _mockPostService.Object, _mockUserService.Object, _mockCommentService.Object);
//Act
var result = await controller.DeleteComment(ConstIds.ExampleCommentId);
//Act
var noContentResult = Assert.IsType <NoContentResult>(result);
_mockCommentService.Verify();
}
public void Setup()
{
_unitOfWork = new Mock <IUnitOfWork>();
_mapper = new Mock <IMapper>();
_accessor = new Mock <IHttpContextAccessor>();
_controller = new PostCommentsController(_unitOfWork.Object, _mapper.Object, _accessor.Object)
{
ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = new ClaimsPrincipal()
}
}
};
}
public async void PartiallyUpdateComment_ReturnsBadRequestResult_WhenTheCommentHasNotBeenUpdated()
{
//Arrange
_mockCommentService.Setup(Service => Service.TryUpdatePostCommentAsync(It.IsAny <Guid>(), It.IsAny <JsonPatchDocument <PostCommentToUpdateDto> >()))
.ReturnsAsync(false)
.Verifiable();
var controller = new PostCommentsController(_loggerMock.Object, _mockPostService.Object, _mockUserService.Object, _mockCommentService.Object);
//Act
var result = await controller.PartiallyUpdateComment(ConstIds.ExampleCommentId, GetJsonPatchDocument());
//Assert
var badRequestResult = Assert.IsType <BadRequestResult>(result);
_mockCommentService.Verify();
}
public async void DeleteComment_ReturnsInternalServerErrorResult_WhenExceptionThrownInService()
{
//Arrange
_mockCommentService.Setup(Service => Service.DeleteCommentAsync(It.IsAny <Guid>()))
.Throws(new ArgumentNullException(nameof(Guid)))
.Verifiable();
var controller = new PostCommentsController(_loggerMock.Object, _mockPostService.Object, _mockUserService.Object, _mockCommentService.Object);
//Act
var result = await controller.DeleteComment(ConstIds.ExampleCommentId);
//Assert
var internalServerErrorResult = Assert.IsType <StatusCodeResult>(result);
Assert.Equal(StatusCodes.Status500InternalServerError, internalServerErrorResult.StatusCode);
_mockCommentService.Verify();
}
public void GetComments_ReturnsInternalServerErrorResult_WhenExceptionThrownInService()
{
//Arrange
_mockPostService.Setup(Service => Service.CheckIfPostExists(It.IsAny <Guid>()))
.Throws(new ArgumentNullException(nameof(Guid)))
.Verifiable();
var controller = new PostCommentsController(_loggerMock.Object, _mockPostService.Object, _mockUserService.Object, _mockCommentService.Object);
//Act
var result = controller.GetComments(ConstIds.ExamplePostId, _paginationsParams);
//Assert
var internalServerErrorResult = Assert.IsType <StatusCodeResult>(result.Result);
Assert.Equal(StatusCodes.Status500InternalServerError, internalServerErrorResult.StatusCode);
_mockPostService.Verify();
}
public void GetComments_ReturnsNotFoundObjectResult_WhenThePostDoesntExist()
{
//Arrange
_mockPostService.Setup(Service => Service.CheckIfPostExists(It.IsAny <Guid>()))
.Returns(false)
.Verifiable();
var controller = new PostCommentsController(_loggerMock.Object, _mockPostService.Object, _mockUserService.Object, _mockCommentService.Object);
//Act
var result = controller.GetComments(ConstIds.ExamplePostId, _paginationsParams);
//Assert
var notFoundObjectResult = Assert.IsType <NotFoundObjectResult>(result.Result);
Assert.Equal($"Post: {ConstIds.ExamplePostId} not found.", notFoundObjectResult.Value);
_mockPostService.Verify();
}
public void GetComment_ReturnsOkObjectResult_WithCommentData()
{
//Arrange
var comment = GetTestPostData().ElementAt(0);
_mockPostService.Setup(Service => Service.CheckIfPostExists(It.IsAny <Guid>()))
.Returns(true)
.Verifiable();
_mockCommentService.Setup(Service => Service.GetComment(It.IsAny <Guid>()))
.Returns(comment)
.Verifiable();
var controller = new PostCommentsController(_loggerMock.Object, _mockPostService.Object, _mockUserService.Object, _mockCommentService.Object);
//Act
var result = controller.GetComment(ConstIds.ExamplePostId, ConstIds.ExampleCommentId);
//Assert
var actionResult = Assert.IsType <OkObjectResult>(result.Result);
var model = Assert.IsType <PostCommentDto>(actionResult.Value);
_mockCommentService.Verify();
_mockPostService.Verify();
}
