Unit testing C# in .NET Core using dotnet test and xUnit

This tutorial takes you through an interactive experience building a sample solution step-by-step to learn unit testing concepts. If you prefer to follow the tutorial using a pre-built solution, view or download the sample code before you begin. For download instructions, see Samples and Tutorials.

Creating the source project

Open a shell window. Create a directory called unit-testing-using-dotnet-test to hold the solution. Inside this new directory, run dotnet new sln to create a new solution. Having a solution makes it easier to manage both the class library and the unit test project. Inside the solution directory, create a PrimeService directory. The directory and file structure thus far should be as follows:

/unit-testing-using-dotnet-test
    unit-testing-using-dotnet-test.sln
    /PrimeService

Make PrimeService the current directory and run dotnet new classlib to create the source project. Rename Class1.cs to PrimeService.cs. To use test-driven development (TDD), you first create a failing implementation of the PrimeService class:

using System;

namespace Prime.Services
{
    public class PrimeService
    {
        public bool IsPrime(int candidate)
        {
            throw new NotImplementedException("Please create a test first");
        }
    }
}

Change the directory back to the unit-testing-using-dotnet-test directory.

Run the dotnet sln command to add the class library project to the solution:

dotnet sln add .\PrimeService\PrimeService.csproj

Creating the test project

Next, create the PrimeService.Tests directory. The following outline shows the directory structure:

/unit-testing-using-dotnet-test
    unit-testing-using-dotnet-test.sln
    /PrimeService
        Source Files
        PrimeService.csproj
    /PrimeService.Tests

Make the PrimeService.Tests directory the current directory and create a new project using dotnet new xunit. This command creates a test project that uses xUnit as the test library. The generated template configures the test runner in the PrimeServiceTests.csproj file similar to the following code:

<ItemGroup>
  <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0" />
  <PackageReference Include="xunit" Version="2.2.0" />
  <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
</ItemGroup>

The test project requires other packages to create and run unit tests. dotnet new in the previous step added xUnit and the xUnit runner. Now, add the PrimeService class library as another dependency to the project. Use the dotnet add reference command:

dotnet add reference ../PrimeService/PrimeService.csproj

You can see the entire file in the samples repository on GitHub.

The following shows the final solution layout:

/unit-testing-using-dotnet-test
    unit-testing-using-dotnet-test.sln
    /PrimeService
        Source Files
        PrimeService.csproj
    /PrimeService.Tests
        Test Source Files
        PrimeServiceTests.csproj

To add the test project to the solution, run the dotnet sln command in the unit-testing-using-dotnet-test directory:

dotnet sln add .\PrimeService.Tests\PrimeService.Tests.csproj

Creating the first test

The TDD approach calls for writing one failing test, making it pass, then repeating the process. Remove UnitTest1.cs from the PrimeService.Tests directory and create a new C# file named PrimeService_IsPrimeShould.cs. Add the following code:

using Xunit;
using Prime.Services;

namespace Prime.UnitTests.Services
{
    public class PrimeService_IsPrimeShould
    {
        private readonly PrimeService _primeService;

        public PrimeService_IsPrimeShould()
        {
            _primeService = new PrimeService();
        }

        [Fact]
        public void ReturnFalseGivenValueOf1()
        {
            var result = _primeService.IsPrime(1);

            Assert.False(result, "1 should not be prime");
        }
    }
}

The [Fact] attribute indicates a test method that is run by the test runner. From the PrimeService.Tests folder, execute dotnet test to build the tests and the class library and then run the tests. The xUnit test runner contains the program entry point to run your tests. dotnet test starts the test runner using the unit test project you've created.

Your test fails. You haven't created the implementation yet. Make this test pass by writing the simplest code in the PrimeService class that works. Replace the existing IsPrime method implementation with the following code:

public bool IsPrime(int candidate)
{
    if (candidate == 1)
    {
        return false;
    }
    throw new NotImplementedException("Please create a test first");
}

In the PrimeService.Tests directory, run dotnet test again. The dotnet test command runs a build for the PrimeService project and then for the PrimeService.Tests project. After building both projects, it runs this single test. It passes.

Adding more features

Now that you've made one test pass, it's time to write more. There are a few other simple cases for prime numbers: 0, -1. You could add those cases as new tests with the [Fact] attribute, but that quickly becomes tedious. There are other xUnit attributes that enable you to write a suite of similar tests:

  • [Theory] represents a suite of tests that execute the same code but have different input arguments.

  • [InlineData] attribute specifies values for those inputs.

Instead of creating new tests, apply these two attributes, [Theory] and [InlineData], to create a single theory in the PrimeService_IsPrimeShould.cs file. The theory is a method that tests several values less than two, which is the lowest prime number:

[Theory]
[InlineData(-1)]
[InlineData(0)]
[InlineData(1)]
public void ReturnFalseGivenValuesLessThan2(int value)
{
    var result = _primeService.IsPrime(value);
    
    Assert.False(result, $"{value} should not be prime");
}

Run dotnet test again, and two of these tests should fail. To make all of the tests pass, change the if clause at the beginning of the IsPrime method in the PrimeService.cs file:

if (candidate < 2)

Continue to iterate by adding more tests, more theories, and more code in the main library. You have the finished version of the tests and the complete implementation of the library.

Additional resources

Testing controller logic in ASP.NET Core