Getting Started With NUnit in ASP.NET Core

ASP.NET Core is an open-source framework for building modern web applications. NUnit, on the other hand, is a unit-testing framework for C# developers. In this article, I’ll explain how you can use NUnit in ASP.NET Core testing to ensure that you have coverage on your web applications!

Testing is a crucial step in software development as it ensures the reliability and quality of code while reducing debugging time and cost. This article touches on the benefits of testing with NUnit and will provide a step-by-step guide on how to implement unit testing in ASP.NET Core to improve your code quality. Let’s dive in!

Understanding ASP.NET Core Testing

ASP.NET Core is a widely used open-source framework for building web applications, and like any software, it can have issues that need to be addressed. One way to ensure that your application is reliable and meets the user’s needs is to perform rigorous testing. In this section, I will explain the basics of ASP.NET Core testing, the benefits of using NUnit for testing, and how to create an NUnit project to test an ASP.NET Core application.

What is Testing in ASP.NET Core?

ASP.NET Core testing is the process by which developers test an ASP.NET Core application to ensure that it works as intended. Testing can help to determine issues that may exist in both the front-end and back-end code. ASP.NET Core testing can be done using various testing frameworks, but in this article, we will focus on NUnit.

It’s important to acknowledge that we have multiple different testing types available to us, regardless of what framework we’re using. With that said, many people talk about “unit” tests but there are “functional” or “integration” tests as well. I treat “unit” tests as tests that are much more isolated and require mocking out dependencies. In contrast, I use “functional” or “integration” tests to cover much more broad areas of a system.

What’s the “best” way to test? The answer, in my opinion, is a mix across the spectrum of what’s available. Prioritize the styles of testing that give you the best levels of confidence in your code.

Check out this video on testing approaches for more of my perspective on this:

Benefits of Testing with NUnit

NUnit is an open-source unit testing framework for Microsoft .NET that is widely used in the development community. Some benefits of testing with NUnit include:

• Improved code quality – Automated testing with NUnit ensures that code is working as intended and helps catch errors earlier in the development process.
• Simplified debugging – By testing with NUnit, developers can quickly identify and isolate issues, which makes debugging much more manageable.
• Consistent functionality – Running NUnit tests assures developers that changes to the code do not impact the existing functionality of the application.

Creating an ASP.NET Core Project for Testing

To start unit testing in ASP.NET Core applications with NUnit, you need to have a project to test. You can either create a new project explicitly for testing or use an existing project. A good practice is to keep your test project separate from your production project—this way, any changes you make will only affect the test project.

To explain this more clearly – you want to separate what you are using for supporting your tests from the code that you want to ship to production. In the same way that when you download an app to your phone you’re not getting all of the testing code from the app developer, when you deploy a web application you don’t want to deploy all of the test code with it. By separating out your deployable product code from your test code, you have the flexibility to have a dedicated test environment separate from your production environment!

Setting up an NUnit Project

Setting up an NUnit project is relatively simple and straightforward—there are just a few things to keep in mind. You need to make sure you have the correct NuGet packages installed, and you need to create a class file specifically for your unit tests. Once you’ve set up your NUnit project, you can start writing tests for your application.

Let’s make sure you get the packages you need:

• NUnit – This is the testing framework itself. You’ll need this to be able to mark tests and use assertion logic in your tests!
• Microsoft.NET.Test.Sdk – If you’re running tests from Visual Studio, you’ll need to ensure you have the .NET test SDK included as well. Without this and JUST having NUnit, you’ll be able to mark your tests but they won’t get picked up to be able to run!
• NUnit3TestAdapter – Finally, you’ll need this test adapter to run the NUnit tests from inside the Visual Studio test explorer.

With these Nuget packages added to your test project, you’re on your way to creating reliable and high-quality software! Next up, we’ll focus on creating the tests themselves.

Writing Basic NUnit Tests in CSharp

Now that we have a basic understanding of ASP.NET Core testing and how to set up an NUnit project, let’s dive into writing NUnit tests for an ASP.NET Core application.

Writing Your First NUnit Test

Before we get into the web side of things, the first step in writing NUnit tests is to write a simple test that validates that a method returns the expected output. Let’s say we have a method called Add on a class called Calculator that adds two numbers together. To write a test for this method, we would write the following code:

using NUnit.Framework;

[TestFixture]
public class CalculatorTests
{
    [Test]
    public void Add_TwoNumbers_ReturnsSum()
    {
        // Arrange
        Calculator calculator = new Calculator();
        int x = 2;
        int y = 3;

        // Act
        int sum = calculator.Add(x, y);

        // Assert
        Assert.AreEqual(5, sum);
    }
}

This code defines a test class, which contains the individual tests. The test method is decorated with the [Test] attribute, which tells NUnit that this method is a test. The Add_TwoNumbers_ReturnsSum method has three parts:

• Arrange section initializes the variables
• Act section performs the operation we want to test
• Assert section compares the actual result to the expected result

This is a common format to follow for readable tests. And at this point, we’ve seen the basic setup for marking a test method and defining how we can assert conditions!

Using Assertions to Validate Test Results

Assertions are a fundamental part of NUnit tests — and all testing frameworks, for that matter. They provide a way for tests to perform comparisons between expected and actual values. The assertion part of a test should draw your attention to what’s truly being validated, and not just exercised. Remember, it’s one thing for a line of code to be executed, but it’s another thing for us to validate that the line of code we executed is doing what we expect!

There are several types of assertions available in NUnit, including:

• Assert.AreEqual(expected, actual) – Tests if two values are equal.
• Assert.IsTrue(condition) – Tests if a condition is true.
• Assert.IsFalse(condition) – Tests if a condition is false.
• Assert.IsNull(object) – Tests if an object is null.
• Assert.IsNotNull(object) – Tests if an object is not null.

These assertions can be used in the Assert section of a test method, as shown in the previous example.

Testing Web APIs with NUnit in ASP.NET Core

Testing web APIs is an essential part of ensuring that the functionality of an ASP.NET Core application works as intended. To write tests for web APIs, we can use the HttpClient class provided by the System.Net.Http namespace in C#. Here is an example of how to test a basic GET request using NUnit:

using NUnit.Framework;
using System.Net.Http;
using System.Threading.Tasks;

[TestFixture]
public class MyApiTests
{
    [Test]
    public async Task Get_EndpointReturnsSuccessAndCorrectContentType()
    {
        // Arrange
        HttpClient client = new HttpClient();
        string url = "https://example.com/api/values";

        // Act
        HttpResponseMessage response = await client.GetAsync(url);
        string responseContent = await response.Content.ReadAsStringAsync();

        // Assert
        response.EnsureSuccessStatusCode();
        Assert.AreEqual("application/json; charset=utf-8",
            response.Content.Headers.ContentType.ToString());
    }
}

In this example, we use an HttpClient object to execute the GET request. The test checks if the response is successful and has the correct content type.

What’s the big problem with this though? It’s hitting a URL out on the Internet! Even if you change it to localhost or 127.0.0.1, you still need to find a way to manage the lifecycle of the application that you want to test!

WebApplicationFactory with NUnit in ASP.NET Core

To solve this, we can use a WebApplicationFactory! I recommend you check out this article on using WebApplicationFactory as an additional primer to spinning up a web app to test. WebApplicationFactory is agnostic to the testing framework you choose (xUNit, NUnit, or whatever else) so you can use it with what you have seen in this article so far.

To jump into a concrete code example, let’s see the following:

using System.Net.Http;
using System.Threading.Tasks;

using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc.Testing;

using NUnit.Framework;

[TestFixture]
public class MyApiTests
{
    [Test]
    public async Task Get_EndpointReturnsSuccessAndCorrectContentType()
    {
        // Arrange
        var factory = new WebApplicationFactory<Program>().WithWebHostBuilder(builder =>
        {
            builder.UseEnvironment("Testing");
        });
        var client = factory.CreateClient();
        string url = "https://example.com/api/values";

        // Act
        HttpResponseMessage response = await client.GetAsync(url);
        string responseContent = await response.Content.ReadAsStringAsync();

        // Assert
        response.EnsureSuccessStatusCode();
        Assert.AreEqual("application/json; charset=utf-8",
            response.Content.Headers.ContentType.ToString());
    }
}

Please note that the <Program> type parameter included here in the WebApplicationFactory is because of using minimal APIs in a web project that we want to test. And if you’re using the minimal API approach, you may need to put this at the end of your program.cs file in your web application to publicly expose your Program class to your test project, or look into InternalsVisibleTo to expose this internal class to your test project:

Benefits of NUnit in ASP.NET Core Tests

Unit testing with NUnit in ASP.NET Core can provide a range of benefits that help create high-quality software. In this section, we will discuss how using NUnit for testing can improve your code’s reliability and quality, as well as speed up the debugging process.

Increased Code Reliability and Quality

NUnit tests are automated, which means that they can run quickly and easily. Running tests regularly can help you catch errors and spot issues early on in the development lifecycle, allowing for prompt and effective solutions.

By running tests regularly with NUnit, teams can be confident that their code is working as it should, and it provides relevant data about the quality of the code. Automatic testing can also ensure that there are no regression bugs that would otherwise go unnoticed.

Faster and Easier Debugging

Debugging software can be a challenging task for many developers. By running NUnit tests, you can isolate bugs early on in the development cycle and fix them as quickly as possible.

NUnit makes use of the “Arrange-Act-Assert” pattern, which allows developers to identify the problem if a test fails. This pattern is particularly useful in allowing developers to isolate errors and produce effective debug reports.

Ensuring Consistent Functionality Through Code Changes

The functionality of an application can change when code is added or modified. Testing with Nunit in ASP.NET Core allows you to run tests regularly and ensure that any changes to the code don’t impact existing functionality. This process is necessary to ensure consistent functionality across the development lifecycle of any project — and using functional/integration test coverage on ASP.NET Core web APIs can be incredibly powerful for helping build this confidence.

NUnit testing can provide a wide range of benefits to developers looking to create high-quality software. By relying on NUnit test-driven development, you can:

• Improve the reliability and quality of your code
• Reduce the time and effort needed to debug
• Help ensure consistent functionality throughout the development cycle

Wrapping Up NUnit in ASP.NET Core

Learning how to use NUnit in ASP.NET Core is a valuable skill for any C# developer creating web APIs. Not only does it increase the reliability and quality of your code, but it also ensures consistent functionality through code changes. Additionally, debugging becomes faster and easier, saving time and resources. Catching issues now is *WAY* better than hearing from your customer.

By leveraging NUnit in ASP.NET Core, you can catch bugs early on, preventing them from becoming larger issues down the line. As a result, you and your development team can produce higher-quality software in less time. I highly recommend incorporating NUnit testing into your work with ASP.NET Core — and if not NUnit then at least consider xUnit!

With a willingness to experiment with different testing approaches, your team can take its testing capabilities to the next level! Mix and match your types of testing coverage to greatly increase your level of confidence in your changes. If you found this useful and you’re looking for more learning opportunities, consider subscribing to my free weekly software engineering newsletter and check out my free videos on YouTube!