Unit Test in C# (Moq 4 and NUnit)

Published in

Dev Genius

5 min readOct 15, 2024

Unit testing is a cornerstone of reliable software development, especially in environments where code interacts with multiple components, services, or external systems. Moq is a widely used mocking library in .NET, while NUnit remains one of the most popular unit-testing frameworks.

What is Moq 4?

Moq is a robust and flexible mocking framework for .NET that allows you to create mock objects to isolate your code from its dependencies during testing. This is crucial when you want to focus on a single component without relying on external resources like databases, APIs, or file systems.

Some key Moq 4 features:

Mock interfaces and classes: Mock both interfaces and concrete classes for testing flexibility.
Method setup and verification: Control method behavior and verify method calls to ensure your code interacts with dependencies correctly.
Support for asynchronous methods: Moq allows easy handling of asynchronous code using the ReturnsAsync() method, which is increasingly important in modern applications.

What is NUnit?

NUnit is a popular unit-testing framework for .NET languages, designed to make it easy to write and organize tests. NUnit offers a wide range of assertion methods, attributes for organizing test cases, and capabilities for parallel test execution.

Key features of NUnit:

Attributes for test management: [Test], [SetUp], and [TearDown] to control test life cycles.
Asynchronous testing support: NUnit natively supports async methods, allowing you to write clean tests for asynchronous code.
Powerful assertions: With Assert.That() and custom constraints, NUnit provides precise and expressive test validations.

Setting Up Moq 4 and NUnit

Before starting, add the required NuGet packages to your .NET project. You can do this through the NuGet Package Manager in Visual Studio or using the following commands in the NuGet Package Manager Console:

Install-Package Moq
Install-Package NUnit
Install-Package NUnit3TestAdapter

The NUnit3TestAdapter is necessary to run tests within Visual Studio’s Test Explorer.

Writing Unit Tests with Moq 4 and NUnit

Scenario: Testing a Service with a Dependency on an API Client

Consider a WeatherService class that depends on an external IWeatherApiClient to fetch weather data. We aim to test the behavior of WeatherService, but without making actual HTTP calls. We'll use Moq to create a mock version of IWeatherApiClient.

public interface IWeatherApiClient
{
    Task<WeatherData> GetWeatherAsync(string city);
}

public class WeatherService
{
    private readonly IWeatherApiClient _apiClient;

    public WeatherService(IWeatherApiClient apiClient)
    {
        _apiClient = apiClient;
    }

    public async Task<WeatherData> GetWeatherByCityAsync(string city)
    {
        if (string.IsNullOrEmpty(city))
            throw new ArgumentException("City cannot be null or empty.");

        return await _apiClient.GetWeatherAsync(city);
    }
}

public class WeatherData
{
    public string City { get; set; }
    public double Temperature { get; set; }
}

Step 1: Creating an Asynchronous Mock

To test this asynchronous method, we need to mock the GetWeatherAsync() method of the IWeatherApiClient. We can easily mock this method using Moq’s ReturnsAsync function.

[TestFixture]
public class WeatherServiceTests
{
    private Mock<IWeatherApiClient> _apiClientMock;
    private WeatherService _weatherService;

    [SetUp]
    public void SetUp()
    {
        _apiClientMock = new Mock<IWeatherApiClient>();
        _weatherService = new WeatherService(_apiClientMock.Object);
    }

    [Test]
    public async Task GetWeatherByCityAsync_ValidCity_ReturnsWeatherData()
    {
        // Arrange
        var expectedWeather = new WeatherData { City = "New York", Temperature = 20.5 };
        _apiClientMock.Setup(client => client.GetWeatherAsync("New York"))
                      .ReturnsAsync(expectedWeather);

        // Act
        var result = await _weatherService.GetWeatherByCityAsync("New York");

        // Assert
        Assert.IsNotNull(result);
        Assert.AreEqual("New York", result.City);
        Assert.AreEqual(20.5, result.Temperature);
    }

    [Test]
    public void GetWeatherByCityAsync_NullCity_ThrowsArgumentException()
    {
        // Assert
        Assert.ThrowsAsync<ArgumentException>(async () => await _weatherService.GetWeatherByCityAsync(null));
    }
}

Step 2: Verifying Method Calls and Exception Handling

Moq provides excellent support for verifying whether methods on mock objects were called with specific parameters. Let’s test if the GetWeatherAsync() method was called with the correct arguments:

[Test]
public async Task GetWeatherByCityAsync_VerifiesApiClientCall()
{
    // Arrange
    var weatherData = new WeatherData { City = "London", Temperature = 15.0 };
    _apiClientMock.Setup(client => client.GetWeatherAsync("London")).ReturnsAsync(weatherData);

    // Act
    await _weatherService.GetWeatherByCityAsync("London");

    // Assert
    _apiClientMock.Verify(client => client.GetWeatherAsync("London"), Times.Once);
}

Here, we verify that GetWeatherAsync("London") was called exactly once.

Advanced Mocking Scenarios

Handling Complex Dependency Trees

In real-world scenarios, objects might have complex dependency chains. For instance, you may need to mock nested properties or services within services. Moq supports recursive mocking, which allows you to mock deeply nested objects.

Example: Mocking Nested Dependencies

Imagine you are testing a service that indirectly relies on a nested service. Moq allows you to mock hierarchies of objects easily, without manually creating each mock.

public interface IAccountService
{
    ICustomerService CustomerService { get; }
}

public interface ICustomerService
{
    string GetCustomerName(int customerId);
}

[Test]
public void TestCustomerServiceInAccountService()
{
    // Arrange
    var accountServiceMock = new Mock<IAccountService>();
    accountServiceMock.Setup(service => service.CustomerService.GetCustomerName(It.IsAny<int>()))
                      .Returns("John Doe");

    // Act
    var customerName = accountServiceMock.Object.CustomerService.GetCustomerName(1);

    // Assert
    Assert.AreEqual("John Doe", customerName);
}

In this example, we use Moq to mock the CustomerService nested within the AccountService.

Verifying No Other Calls Were Made

In some cases, you may want to ensure that no unexpected calls were made to a mock object. Moq provides the VerifyNoOtherCalls method for this purpose, which is especially useful in behavior-driven development (BDD) scenarios.

[Test]
public async Task GetWeatherByCityAsync_VerifiesNoOtherCalls()
{
    // Arrange
    var weatherData = new WeatherData { City = "Berlin", Temperature = 18.0 };
    _apiClientMock.Setup(client => client.GetWeatherAsync("Berlin")).ReturnsAsync(weatherData);

    // Act
    await _weatherService.GetWeatherByCityAsync("Berlin");

    // Assert
    _apiClientMock.Verify(client => client.GetWeatherAsync("Berlin"), Times.Once);
    _apiClientMock.VerifyNoOtherCalls();
}

Here, VerifyNoOtherCalls() ensures that no additional methods were called on the IWeatherApiClient mock.

Testing Asynchronous Code

Asynchronous methods are now a standard in modern application development, and testing them can sometimes be tricky. NUnit natively supports async tests, and Moq provides the ReturnsAsync method to simulate asynchronous operations.

Example: Mocking a Delayed Response

Let’s say you want to test a method that expects a delayed response from a service. Moq can handle this using ReturnsAsync() with a delay simulation.

[Test]
public async Task GetWeatherByCityAsync_MocksDelayedResponse()
{
    // Arrange
    var weatherData = new WeatherData { City = "Tokyo", Temperature = 25.0 };
    _apiClientMock.Setup(client => client.GetWeatherAsync("Tokyo"))
                  .ReturnsAsync(weatherData, TimeSpan.FromMilliseconds(100));

    // Act
    var result = await _weatherService.GetWeatherByCityAsync("Tokyo");

    // Assert
    Assert.AreEqual(25.0, result.Temperature);
}

This introduces a delay to simulate a real-world asynchronous response time.

Improving Test Coverage with Code Coverage Tools

To ensure that your tests cover all possible code paths, you should integrate code coverage tools into your test suite. Coverlet is a popular choice for .NET Core projects, and it works seamlessly with NUnit and Moq.

Setting Up Coverlet for Code Coverage

To add Coverlet to your project, run the following command:

dotnet add package coverlet.msbuild

You can then generate a code coverage report by running:

dotnet test /p:CollectCoverage=true

This command runs your tests and generates a code coverage report, helping you identify untested paths in your code.

Summary

Moq 4 and NUnit are powerful tools for unit testing in .NET, allowing you to mock dependencies and verify behavior.
Use Moq’s async support (ReturnsAsync) to handle asynchronous methods effortlessly in your tests.
Take advantage of recursive mocking for complex dependency trees without manually mocking each layer.
Ensure test coverage by integrating tools like Coverlet to track which parts of your code are exercised by your tests.