Comprehensive Guide to Unit Testing with MSTest in C#

Unit Testing

Unit testing is a crucial practice in software development, helping developers ensure that individual units of code (like methods or classes) work as expected. In C#, one of the most popular frameworks for unit testing is MSTest. MSTest is the default testing framework for the .NET ecosystem and integrates seamlessly with Visual Studio, making it an excellent choice for developers working with Microsoft technologies.

In this article, we will explore unit testing with MSTest in C#, discussing how to set up MSTest, write unit tests, and execute them. We will also cover some advanced features of MSTest with examples.

What is MSTest?

MSTest is a testing framework provided by Microsoft for .NET applications. It allows you to write unit tests, integration tests, and other types of automated tests. MSTest is built into Visual Studio, so it’s easy to get started, especially for developers working in the .NET ecosystem.

Setting Up MSTest in C#

Creating a Unit Test Project with MSTest

To start writing tests with MSTest, you need to create a test project. Here’s how you can do it.

Using Visual Studio

Open Visual Studio.
Go to File → New → Project.
Select Unit Test Project (.NET Core) under the C# templates.
Choose MSTest as the test framework.
Name the project (e.g., MyApp.Tests) and click Create.

Using .NET CLI

If you prefer to use the command line, follow these steps.

Open the terminal and navigate to the folder where you want to create your test project.
Run the following command to create a new MSTest project.
```
dotnet new mstest -n MyApp.Tests
```

Add a reference to your main project.

dotnet add MyApp.Tests reference ../MyApp/MyApp.csproj

Restore the dependencies.
```
dotnet restore
```

Writing Unit Tests in MSTest

Let’s now write some basic unit tests using MSTest. We will start by creating a simple class that we can test.

Example 1. Testing a Simple Calculator Class.

Imagine we have a simple Calculator class with methods for addition, subtraction, multiplication, and division.

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

    public int Subtract(int a, int b)
    {
        return a - b;
    }

    public int Multiply(int a, int b)
    {
        return a * b;
    }

    public int Divide(int a, int b)
    {
        if (b == 0)
            throw new ArgumentException("Cannot divide by zero.");

        return a / b;
    }
}

Now, we will write unit tests for the Calculator class using MSTest.

using Microsoft.VisualStudio.TestTools.UnitTesting;

[TestClass]
public class CalculatorTests
{
    private Calculator _calculator;

    // Initialize the Calculator object before each test
    [TestInitialize]
    public void TestInitialize()
    {
        _calculator = new Calculator();
    }

    [TestMethod]
    public void Add_ShouldReturnCorrectSum()
    {
        int result = _calculator.Add(3, 2);
        Assert.AreEqual(5, result);
    }

    [TestMethod]
    public void Subtract_ShouldReturnCorrectDifference()
    {
        int result = _calculator.Subtract(5, 3);
        Assert.AreEqual(2, result);
    }

    [TestMethod]
    public void Multiply_ShouldReturnCorrectProduct()
    {
        int result = _calculator.Multiply(4, 3);
        Assert.AreEqual(12, result);
    }

    [TestMethod]
    public void Divide_ShouldReturnCorrectQuotient()
    {
        int result = _calculator.Divide(6, 2);
        Assert.AreEqual(3, result);
    }

    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void Divide_ShouldThrowArgumentException_WhenDividingByZero()
    {
        _calculator.Divide(6, 0);
    }
}

Explanation of Key MSTest Attributes and Methods

[TestClass]: This attribute marks the class that contains the unit tests.
[TestMethod]: This attribute is used to mark a method as a unit test method.
[TestInitialize]: This attribute is used to define a method that runs before each test method. It's commonly used for initializing objects that are shared by multiple test methods.
[ExpectedException]: This attribute is used to test that a specific exception is thrown during the test. In this case, we expect an ArgumentException when dividing by zero.
Assert.AreEqual(expected, actual): This method checks whether the actual result equals the expected value.

Running Unit Tests in MSTest

You can run your unit tests in two ways: through Visual Studio or the .NET CLI.

Using Visual Studio

Open Test Explorer in Visual Studio by going to Test → Test Explorer.
Build the solution (Ctrl+Shift+B).
Once the build is successful, all your tests will appear in the Test Explorer.
Click on Run All to execute all tests or select specific tests to run.

Using .NET CLI

If you prefer the terminal, run the following command to execute your tests.

dotnet test

This will automatically discover and run all the tests in your test project.

Advanced Features of MSTest

Example 2. Testing Asynchronous Code

Unit testing asynchronous methods in MSTest is straightforward. You can use Async and await in your test methods.

Here’s an example of an asynchronous method and its corresponding unit test.

public class UserService
{
    public async Task<string> GetUserNameAsync(int userId)
    {
        // Simulate an async operation (e.g., database query or API call)
        await Task.Delay(100);
        return userId == 1 ? "John Doe" : "Unknown";
    }
}

Now let’s write the unit test for this asynchronous method.

[TestClass]
public class UserServiceTests
{
    private UserService _userService;

    [TestInitialize]
    public void TestInitialize()
    {
        _userService = new UserService();
    }

    [TestMethod]
    public async Task GetUserNameAsync_ShouldReturnCorrectUserName()
    {
        string result = await _userService.GetUserNameAsync(1);
        Assert.AreEqual("John Doe", result);
    }

    [TestMethod]
    public async Task GetUserNameAsync_ShouldReturnUnknown_WhenUserDoesNotExist()
    {
        string result = await _userService.GetUserNameAsync(999);
        Assert.AreEqual("Unknown", result);
    }
}

In MSTest, asynchronous unit tests are supported by simply making the test method async and using await for asynchronous calls.

Example 3. Using Mocking with MSTest (Moq)

In real-world applications, you might need to test code that interacts with external dependencies like databases or APIs. For this, you can use mocking. The Moq library is commonly used to mock interfaces and dependencies in C#.

Let's say we have a service that depends on a repository interface.

public interface IUserRepository
{
    Task<string> GetUserNameAsync(int userId);
}

public class UserService
{
    private readonly IUserRepository _userRepository;

    public UserService(IUserRepository userRepository)
    {
        _userRepository = userRepository;
    }

    public async Task<string> GetUserNameAsync(int userId)
    {
        return await _userRepository.GetUserNameAsync(userId);
    }
}

Now, let’s write a unit test for UserService using Moq to mock the IUserRepository.

First, install Moq via NuGet.

dotnet add package Moq

Then, create the unit test with the mock.

using Moq;
using Microsoft.VisualStudio.TestTools.UnitTesting;

[TestClass]
public class UserServiceTests
{
    private Mock<IUserRepository> _userRepositoryMock;
    private UserService _userService;

    [TestInitialize]
    public void TestInitialize()
    {
        _userRepositoryMock = new Mock<IUserRepository>();
        _userService = new UserService(_userRepositoryMock.Object);
    }

    [TestMethod]
    public async Task GetUserNameAsync_ShouldReturnCorrectUserName()
    {
        // Arrange
        _userRepositoryMock.Setup(repo => repo.GetUserNameAsync(1)).ReturnsAsync("John Doe");

        // Act
        string result = await _userService.GetUserNameAsync(1);

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

In this test.

We mock the IUserRepository using Moq.
We define the behavior of the mock (Setup) to return "John Doe" when GetUserNameAsync(1) is called.
Finally, we assert that the result matches the expected value.

Conclusion

Unit testing with MSTest is a powerful way to ensure your C# code is working as expected. By using MSTest, you can write tests for your methods, verify behaviors, and catch bugs early. With features like test initialization, exception handling, asynchronous testing, and mocking, MSTest makes it easy to write comprehensive and maintainable unit tests.

In this article, we've covered how to,

Set up MSTest in a C# project.
Write unit tests for synchronous and asynchronous code.
Use Moq for mocking dependencies in unit tests.

By incorporating unit tests into your development process, you can improve code quality, make debugging easier, and ensure that your application behaves as expected.