CRUD Operations Unit Testing In ASP.NET Core Web API With xUnit

public PostUnitTestController()
{
    var context = new BlogDBContext(dbContextOptions);
    DummyDataDBInitializer db = new DummyDataDBInitializer();
    db.Seed(context);
    repository = new PostRepository(context);
}

Now, we have everything like a connection string, an instance of BlogDBContext, an instance of PostRepository, and all. So, we can move next and write Unit Test Cases for all EndPoints which are defined inside the PostController in the "CoreServices" project.

We will write the Unit Test Cases one by one for all the EndPoints. If you are new in Unit Testing and willing to write it then you can go with my article "Getting started with Unit Testing using C# and xUnit" where you will learn more about Unit Testing's Pros and Cons and the best way to write Unit Test Cases.

We need to keep three things while writing the Unit Test Cases and these are Arranging the data, Performing the action, and Matching the output (Arrange, Act, Assert).

So, let's first write the Unit Test Case for the "Get By Id " method as follows. We have multiple Unit Test Cases to test a single method. Each Unit Test Case has its own responsibilities like matching the OK Result, checking for the Not Found Result, checking for Bad Requests, etc.

When we talk about Fluent Assertions, we are implementing "Task_GetPostById_MatchResult" to get the actual data.

#region Get By Id

[Fact]
public async Task GetPostById_Return_OkResult()
{
    // Arrange
    var controller = new PostController(repository);
    var postId = 2;
    // Act
    var data = await controller.GetPost(postId);
    // Assert
    Assert.IsType<OkObjectResult>(data);
}
[Fact]
public async Task GetPostById_Return_NotFoundResult()
{
    // Arrange
    var controller = new PostController(repository);
    var postId = 3;
    // Act
    var data = await controller.GetPost(postId);
    // Assert
    Assert.IsType<NotFoundResult>(data);
}
[Fact]
public async Task GetPostById_Return_BadRequestResult()
{
    // Arrange
    var controller = new PostController(repository);
    int? postId = null;
    // Act
    var data = await controller.GetPost(postId);
    // Assert
    Assert.IsType<BadRequestResult>(data);
}
[Fact]
public async Task GetPostById_MatchResult()
{
    // Arrange
    var controller = new PostController(repository);
    int? postId = 1;
    // Act
    var data = await controller.GetPost(postId);
    // Assert
    Assert.IsType<OkObjectResult>(data);
    var okResult = data.Should().BeOfType<OkObjectResult>().Subject;
    var post = okResult.Value.Should().BeAssignableTo<PostViewModel>().Subject;
    Assert.Equal("Test Title 1", post.Title);
    Assert.Equal("Test Description 1", post.Description);
}
#endregion

Following are the Unit Test Cases for the "Get All" methods. Here we have written 3 Unit Test Cases one for Ok Result, another for Bad Request Result when the wrong result is passed, and a last one for matching the Ok Result Output with our data.

#region Get By Id

    [Fact]
    public async Task Task_GetPostById_Return_OkResult()
    {
        // Arrange
        var controller = new PostController(repository);
        var postId = 2;
        // Act
        var data = await controller.GetPost(postId);
        // Assert
        Assert.IsType<OkObjectResult>(data);
    }
    [Fact]
    public async Task Task_GetPostById_Return_NotFoundResult()
    {
        // Arrange
        var controller = new PostController(repository);
        var postId = 3;
        // Act
        var data = await controller.GetPost(postId);
        // Assert
        Assert.IsType<NotFoundResult>(data);
    }
    [Fact]
    public async Task Task_GetPostById_Return_BadRequestResult()
    {
        // Arrange
        var controller = new PostController(repository);
        int? postId = null;
        // Act
        var data = await controller.GetPost(postId);
        // Assert
        Assert.IsType<BadRequestResult>(data);
    }
    [Fact]
    public async Task Task_GetPostById_MatchResult()
    {
        // Arrange
        var controller = new PostController(repository);
        int? postId = 1;
        // Act
        var data = await controller.GetPost(postId);
        // Assert
        Assert.IsType<OkObjectResult>(data);
        var okResult = data.Should().BeOfType<OkObjectResult>().Subject;
        var post = okResult.Value.Should().BeAssignableTo<PostViewModel>().Subject;
        Assert.Equal("Test Title 1", post.Title);
        Assert.Equal("Test Description 1", post.Description);
    }
#endregion

The following Unit Test Cases are for CREATE operation, let me confirm one thing here we will prepare the data for adding in the Arrange section. One thing you should notice here is that in the "Task_Add_InvalidData_Return_BadRequest" Unit Test Cases, we are passing more than 20 characters for the Title, which is not correct because, in the Post model, we have defined the size of the Title as 20 characters.

#region Add New Blog

[Fact]
public async void Task_Add_ValidData_Return_OkResult()
{
    //Arrange
    var controller = new PostController(repository);
    var post = new Post()
    {
        Title = "Test Title 3",
        Description = "Test Description 3",
        CategoryId = 2,
        CreatedDate = DateTime.Now
    };
    //Act
    var data = await controller.AddPost(post);
    //Assert
    Assert.IsType<OkObjectResult>(data);
}
[Fact]
public async void Task_Add_InvalidData_Return_BadRequest()
{
    //Arrange
    var controller = new PostController(repository);
    Post post = new Post()
    {
        Title = "Test Title More Than 20 Characters",
        Description = "Test Description 3",
        CategoryId = 3,
        CreatedDate = DateTime.Now
    };
    //Act
    var data = await controller.AddPost(post);
    //Assert
    Assert.IsType<BadRequestResult>(data);
}
[Fact]
public async void Task_Add_ValidData_MatchResult()
{
    //Arrange
    var controller = new PostController(repository);
    var post = new Post()
    {
        Title = "Test Title 4",
        Description = "Test Description 4",
        CategoryId = 2,
        CreatedDate = DateTime.Now
    };
    //Act
    var data = await controller.AddPost(post);
    //Assert
    Assert.IsType<OkObjectResult>(data);
    var okResult = data.Should().BeOfType<OkObjectResult>().Subject;
    // var result = okResult.Value.Should().BeAssignableTo<PostViewModel>().Subject;
    Assert.Equal(3, okResult.Value);
}
#endregion

Here as follows are the Unit Test Cases for the UPDATE operation. In Unit Test Cases for an Update operation, we first get the Post details based on the Post Id and then modify the data and send it for updating.

#region Update Existing Blog

[Fact]
public async Task Task_Update_ValidData_Return_OkResult()
{
    //Arrange
    var controller = new PostController(repository);
    var postId = 2;
    //Act
    var existingPost = await controller.GetPost(postId);
    var okResult = existingPost.Should().BeOfType<OkObjectResult>().Subject;
    var result = okResult.Value.Should().BeAssignableTo<PostViewModel>().Subject;
    var post = new Post
    {
        Title = "Test Title 2 Updated",
        Description = result.Description,
        CategoryId = result.CategoryId,
        CreatedDate = result.CreatedDate
    };
    var updatedData = await controller.UpdatePost(post);
    //Assert
    Assert.IsType<OkResult>(updatedData);
}
[Fact]
public async Task Task_Update_InvalidData_Return_BadRequest()
{
    //Arrange
    var controller = new PostController(repository);
    var postId = 2;
    //Act
    var existingPost = await controller.GetPost(postId);
    var okResult = existingPost.Should().BeOfType<OkObjectResult>().Subject;
    var result = okResult.Value.Should().BeAssignableTo<PostViewModel>().Subject;
    var post = new Post
    {
        Title = "Test Title More Than 20 Characteres",
        Description = result.Description,
        CategoryId = result.CategoryId,
        CreatedDate = result.CreatedDate
    };
    var data = await controller.UpdatePost(post);
    //Assert
    Assert.IsType<BadRequestResult>(data);
}
[Fact]
public async Task Task_Update_InvalidData_Return_NotFound()
{
    //Arrange
    var controller = new PostController(repository);
    var postId = 2;
    //Act
    var existingPost = await controller.GetPost(postId);
    var okResult = existingPost.Should().BeOfType<OkObjectResult>().Subject;
    var result = okResult.Value.Should().BeAssignableTo<PostViewModel>().Subject;
    var post = new Post
    {
        PostId = 5,
        Title = "Test Title More Than 20 Characteres",
        Description = result.Description,
        CategoryId = result.CategoryId,
        CreatedDate = result.CreatedDate
    };
    var data = await controller.UpdatePost(post);
    //Assert
    Assert.IsType<NotFoundResult>(data);
}
#endregion

Here are the last Unit Test Cases for the DELETE operation as follows.

#region Delete Post

    [Fact]
    public async void Task_Delete_Post_Return_OkResult()
    {
        // Arrange
        var controller = new PostController(repository);
        var postId = 2;
        // Act
        var data = await controller.DeletePost(postId);
        // Assert
        Assert.IsType<OkResult>(data);
    }
    [Fact]
    public async void Task_Delete_Post_Return_NotFoundResult()
    {
        // Arrange
        var controller = new PostController(repository);
        var postId = 5;
        // Act
        var data = await controller.DeletePost(postId);
        // Assert
        Assert.IsType<NotFoundResult>(data);
    }
    [Fact]
    public async void Task_Delete_Return_BadRequestResult()
    {
        // Arrange
        var controller = new PostController(repository);
        int? postId = null;
        // Act
        var data = await controller.DeletePost(postId);
        // Assert
        Assert.IsType<BadRequestResult>(data);
    }
#endregion

So, we have written a total of 16 Unit Test Cases for CRUD Operations along with the "Get All" method. Now it's time to run the Unit Test Cases and see the output. So, running the Unit Test Cases, let's move to Test Explorer and click on Run All links. It will start executing all your Unit Test Cases one by one and the final output will be as below.

Conclusion

So, today, we have learned with a practical demonstration how to write Unit Test Cases for Asp.Net Core Web API CRUD operations.

I hope this post will help you. Please leave your feedback using comments which helps me to improve myself for the next post. If you have any doubts please ask your doubts or queries in the comment section and if you like this post, please share it with your friends. Thanks.