XUnit vs NUnit What to Choose to Write Clean Code Part 1.

The question of which test framework to choose can appear for a new project or when the team decided to make an experiment trying to improve some internal problem. It’s well known for .net developers that there are three main frameworks: MSTest, NUnit, and XUnit. MSTest is out of scope for this article. I didn’t meet any project which uses it as a primary test framework. I certainly sure such projects exist, and it could be that developers from these projects have written a comprehensive guide щт why to choose MSTest.

We’ll focus on two frameworks, NUnit and XUnit, and they are both quite good and provide common functionally to write tests. Firstly, we’ll look at each separately and then compare both functionalities.

NUnit

NUnit is a unit-testing framework for all .Net languages. Initially ported from JUnit

As it states on the landing page of NUnit.

We’ll cover the latest version of NUnit. At the moment when the article was written, it was 3.13.2. Execute the following commands to add NUnit for your test project:

dotnet add package NUnit --version 3.13.2
dotnet add package NUnit3TestAdapter --version 4.0.0

With these packages, you get an amazing variety of tools provided by NUnit as attributes. Let’s take a look at some of them, which definitely you need to know:

It contains much more tools for developers and allows to configure tests for many scenarios.

Let’s check how it looks in code with all these attributes:

[Author("Andrew", "andrewkulta@akyltech.com")]
[TestFixture]
public class TestExample
{
    [OneTimeSetUp]
    public void OneTimeSetup()
    {
        Console.WriteLine("Setup just once");
    }

    [OneTimeTearDown]
    public void OneTimeTearDown()
    {
        Console.WriteLine("Teardown just once");
    }

    [SetUp]
    public void Setup()
    {
        Console.WriteLine("Setup before each test case");
    }

    [TearDown]
    public void TearDown()
    {
        Console.WriteLine("TearDOwn after each test");
    }

    [Test]
    [Description("")]
    [Author("AnotherAuthor")]
    public void Should_DoNothing()
    {
        Console.WriteLine("Sync test");
    }

    [Test]
    [Category("Async")]
    [MaxTime(100)]
    public async Task Should_DoNothingAsync()
    {
        Console.WriteLine("ASync test");
        await Task.Delay(200);
    }

    [TestCase(1)]
    [TestCase(2)]
    public void Should_BeCase(int param)
    {
        Console.WriteLine($"param is {param}");
    }

    [Ignore("example")]
    public void Should_BeIgnored()
    {
        Console.WriteLine("Never invoked");
    }
}

XUnit is also known as xUnit.net

xUnit.net is a free, open-source, community-focused unit testing tool for the .NET Framework

It was created with an idea to replace nUnit 2.* and 3.*. xUnit provides a set of tools to write clean and more independent tests.

List most used attributes from xUnit:

Let`s take a look at some examples for listed attributes:

`cs
public class xUnitExample : IDisposable
{
public xUnitExample()
{
Console.WriteLine("Executes before each test as setup");
}

[Fact(DisplayName = "Test description")]
[Trait("Category", "CustomCategory")]
public void Should_BeATest()
{
    Console.WriteLine("I`m a test");
}

[Fact(Timeout = 100)]
public async Task Should_BeAsyncTest()
{
    Console.WriteLine("I`m async test");
}

[Theory]
[InlineData(1)]
public void Should_BeTheory(int param)
{
    Console.WriteLine($"param is {param}");
}

[Fact(Skip = "Ignore")]
public void Should_BeSkipped()
{
    Console.WriteLine("Should never be invoked");
}

public void Dispose()
{
    Console.WriteLine("Executes after each test as teardown");
}

}
`

As you can see, xUnit uses constructor and IDisposable pattern to implement setup and teardown. I faced developers who thought that xUnit requires implementing Destructor if you want to clear resources.

I think NUnit allows us to write more descriptive unit tests with various attributes for different purposes. But if you choose xUnit for your project, you get a cleaner code without all this mess with attributes. The final decision depends on your preferences, or maybe the team gets used to one of these frameworks.

Conclusion

To be honest, it doesn’t matter which framework you will choose. They both provide a set of tools to write tests, and it’s more important to concentrate on tests themselves.

Any questions or comments? Ping me on LinkedIn or comment below. And if you liked this post, please give it a clap and share it with all of your friends.

Twitter: https://twitter.com/KyliaBoy
Linkedin: https://www.linkedin.com/in/andrew-kulta/

More articles you can find at:
https://blog.akyltech.com/