Unit Testing in .NET with xUnit or NUnit

Image generate by OpenAI

Unit testing is like building a house. Imagine every brick represents a piece of your code. Before adding it to the structure, you check if the brick is solid and fits. Unit tests ensure that every “brick” (code unit) is reliable, so when the house (application) is complete, it stands strong and stable.

From a software perspective, a unit test is a small, isolated piece of code that validates the functionality of a specific part of your application — usually a single method or function. This article explores how to write unit tests in .NET using xUnit and NUnit.

Why use Unit Testing?

• Reliability: You can trust your code to behave as expected.
• Confidence: Refactoring code becomes less stressful.
• Maintainability: Bugs are easier to fix when caught early.

xUnit

• Lightweight and designed for modern .NET.
• Features parallel test execution and cleaner syntax ([Fact] and [Theory]).
• Integrates seamlessly with .NET CLI.

NUnit

• A feature-rich, mature testing framework.
• Supports [Test], [SetUp], and [TestCase] for flexibility.
• Familiar to developers working with older .NET versions.

What’s New in .NET 7+ for Unit Testing?

1. Minimal APIs Testing: Test APIs directly using WebApplicationFactory.
2. Enhanced Test Coverage Tools: Integrated in Visual Studio.
3. Performance Boosts: Faster reflection and parallelization.

Writing Your First Test

Install xUnit

Add xUnit NuGet packages:

> dotnet add package xunit
> dotnet add package xunit.runner.visualstudio

Example Test (xUnit)

public class Calculator
{
    public int Add(int a, int b) => a + b;
}

using Xunit;

public class CalculatorTests
{
    [Fact]
    public void When_AddingTwoNumbers_Then_ReturnsCorrectSum()
    {
        // Arrange
        var calculator = new Calculator();

        // Act
        var result = calculator.Add(2, 3);

        // Assert
        Assert.Equal(5, result);
    }
}

Example Test (NUnit)

Install NUnit packages:

> dotnet add package NUnit
> dotnet add package NUnit3TestAdapter

[TestFixture]
public class CalculatorTests
{
    [Test]
    public void When_AddingTwoNumbers_Then_ReturnsCorrectSum()
    {
        // Arrange
        var calculator = new Calculator();

        // Act
        var result = calculator.Add(2, 3);

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

Best Practices for Unit Testing

1. Keep Tests Small: Test one thing at a time.
2. Use Clear Names: When_AddingTwoNumbers_Then_ReturnsCorrectSum is descriptive.
3. Mock Dependencies: Use tools like Moq to isolate units.
4. Run Tests Regularly: Integrate tests into CI/CD pipelines.
5. Test Edge Cases: Cover boundary and negative scenarios.
6. Follow the AAA Pattern: Structure your tests into three distinct sections:

• Arrange: Set up the test data and dependencies.
• Act: Execute the method or functionality being tested.
• Assert: Verify the outcome matches the expected result.

Now, let’s be honest: writing unit tests isn’t always exciting. It can be tedious and time-consuming, and the benefits aren’t immediately clear. But, like a house needs a strong foundation, your code needs reliable tests. While the effort might seem daunting initially, unit tests help you catch bugs early, refactor more easily, and build software that stands the test of growth and change. Whether you prefer xUnit, NUnit, or another framework, they are your allies for creating dependable and maintainable applications.