Unit Tests 100% What You Need to Know About Them

In a previous blog post, I introduced you to automated testing. If you haven't read it yet, be sure to check it out before reading this article. Unit tests are one of the types of automatic tests. In this article, I will first tell you a little about unit tests in theory, tell you what good unit tests should be, and then we will write the first unit test, and then the next ones. Let's get started!

What are unit tests?

What should unit tests be like?

First unit test in C#

public class Calculator
{
    public int Add(int number1, int number2)
    {
        return number1 - number2; //intentional error
    }
}

#1 We are adding a new project with tests.
First, you need to add a new project to our solution. By convention, this could be a project called Calculations.UnitTests. This project will be our unit tests. It's best to separate unit tests from production code and integration tests.

#2 We add a reference to the tested project to the project with tests.
There are several ways to do this. For example, right-click on Calculations.UnitTests, then Add and Reference. After opening a new window, from the Project/Solution tab we select the tested project, in our case Calculations.

#3 Install NUnit.
We go to Manage NuGet Package and install it for the project with NUnit tests.

#4 We add a new class corresponding to the tested class.
In the test project, we add a new class that will be responsible for testing the Calculator class. By convention, we call it CalculatorTests. In this class, methods will be added to test the Calculator class. For each subsequent tested class, it is always best to add a separate testing class, this makes our code more transparent.

#5 We add the first test method.
Let's assume that we first want to test the so-called happy path, i.e. we test a method for numbers that should behave correctly. This method might look something like this:

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

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

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

 We name the method according to the naming convention:

MethodTestedName_Scenario_ExpectedBehavior

We test the Add method for two numbers and expect the correct result, i.e. the sum of these numbers. For a method to be a test, it must be marked with the [Test] attribute. Often developers also mark the class with the [TestFixture] attribute, this is because in older versions of NUnit it was required, but now as of version 2.5 it is not needed. Then, in the method body, we divide our code into three parts: AAA, i.e. Arrange, Act, Assert. In arrange there is a so-called preparation, i.e. objects are most often initialized here, in our example we create a calculator object. Act contains an action, i.e. we execute the method we want to test and call the Add method with the appropriate parameters. In assert we check whether the expected result is equal to the actual result. The Assert class is from the NUnit framework and contains many more static methods to verify the results of our tests. This division of methods is often used, thanks to which the test method becomes transparent. Of course, comments are not needed here, they can be deleted, I left them only for the clarity of this example.

#6 Install NUnit3TestAdapter.
If we do not have ReSharper, in order to run the tests, we must install one more component - NUnit3TestAdapter - via Manage NuGet Package.

#7 Running the test.
Tests can be run in various ways. If you are using Visual Studio, first, in the View tab, click Test Explorer, which will open a window with tests. Then you see the structure of your tests, you can run one test, or you can run all of them. Just right-click on the test name and click Run. Tests are run frequently, so it's best to use keyboard shortcuts for this in the future. You can use the default one or add your own. As you can see in test explorer our test light is red, this indicates an error in the Add method. After clicking on the testing method in test explorer, you can see the message: "Expected: 3 But was: -1". I intentionally made a mistake in our example, which we managed to detect in the test. We are improving the code of the Add method in the Calculator class.

public class Calculator
{
    public int Add(int number1, int number2)
    {
        return number1 + number2;
    }
}

The test is run again and now the test is green. This means the test passed.

Great, we wrote the first test. The above example wasn't too complicated, but I think it's worth starting with one to go through the whole process. In our example, we checked only one test case, but usually when we test, we need to check more paths.

We check all test conditions, if there are any conditional statements in the method, then the number of test cases increases. If we want to consolidate knowledge, we need more practice. To do this, we will write a unit test in C# for the famous FizzBuzz algorithm. Famous because recruiters often ask to implement it during job interviews :)

What is FizzBuzz?
It is a simple algorithm that returns the appropriate value based on the provided argument. The rules are:
If the argument is divisible by 3, returns Fizz,
If the argument is divisible by 5, returns Buzz,
If the argument is divisible by 3 and 5, returns FizzBuzz,
If the argument is not divisible by 3 or 5, returns the value of the argument.

The implementation of the algorithm might look something like this:

namespace TestsDotNet
{
    public class FizzBuzz
    {
        public string GetOutput(int number)
        {
            if ((number % 3 == 0) && (number % 5 == 0))
                return "FizzBuzz";

            if (number % 3 == 0)
                return "Fizz";

            if (number % 5 == 0)
                return "Buzz";

            return number.ToString();
        }
    }
}

Unit test example in .NET

• We add a new project with tests, it will be TestsDotNet.UnitTests,
• To the project with TestsDotNet.UnitTests tests, we add a reference to the project being tested, in this case TestsDotNet,
• We install NUnit via NuGet,
• We install NUnit3TestAdapter via NuGet.
• We add a test class called FizzBuzzTests.

Now, for a moment, let's think calmly about what exactly we want to test, and then let's define the test cases that we want to test. Here we can use the requirements defined above. Starting from the first - if the argument is divisible by 3, returns "Fizz". Using the appropriate naming convention, this is:

MethodTestedName_Scenario_ExpectedBehavior

 We can name our method:

GetOutput_WhenInputIsDivisibleOnlyBy3_ShouldReturnFizz

 Don't forget to mark the method with the [Test] attribute.

[Test]
public void GetOutput_WhenInputIsDivisibleOnlyBy3_ShouldReturnFizz()
{
}

We write our test according to the AAA principle - Arrange, Act, Assert. First, in Arrange, we will prepare our object for testing. We want to test the FizzBuzz class method, so let's initialize this object first.

var fizzbuzz = new FizzBuzz();

In Act, the action takes place, i.e. we run the GetOutput method with the appropriate parameter - according to the scenario and return the value to a variable, for example named result.

var result = fizzbuzz.GetOutput(3);

 In Assert, we verify whether the result variable actually contains what we expect, i.e. "Fizz". Here we can use the Assert class of the NUnit framework, specifically the static method That. This means that we verify that the result, i.e. what the GetOutput(3) method returned, is equal to "Fizz".

Assert.That(result, Is.EqualTo("Fizz"));

And it's ready, we wrote a test for 1 scenario :) Our first testing method will look like this:

[Test]
public void GetOutput_WhenInputIsDivisibleOnlyBy3_ShouldReturnFizz()
{
    var fizzbuzz = new FizzBuzz();

    var result = fizzbuzz.GetOutput(3);

    Assert.That(result, Is.EqualTo("Fizz"));
}

Then we write a test for the next scenario, this time we expect that for parameter 5, the result "Buzz" will be returned. Our test will look very similar, we only change the argument to 5, the expected result in this case should be "Buzz":

[Test]
public void GetOutput_WhenInputIsDivisibleOnlyBy5_ShouldReturnBuzz()
{
    var fizzbuzz = new FizzBuzz();

    var result = fizzbuzz.GetOutput(5);

    Assert.That(result, Is.EqualTo("Buzz"));
}

 We still need to verify whether "FizzBuzz" will be returned for an argument divisible by 3 and 5, but you already know how to do that.

[Test]
public void GetOutput_WhenInputIsDivisibleBy3And5_ShouldReturnFizzBuzz()
{
    var fizzbuzz = new FizzBuzz();

    var result = fizzbuzz.GetOutput(15);

    Assert.That(result, Is.EqualTo("FizzBuzz"));
}

And also whether for an argument not divisible by 3 or 5, the same argument will be returned. There is no need to look for some magic numbers here, we can substitute 1 as an argument, i.e. a number that is not divisible by 3 or 5. If we substitute a number like 679, in the future when we return to this test, we will waste time and wonder I wonder what this number could mean in this case :) Is it a special number or just a random number that is not divisible by 3 or 5.

[Test]
public void GetOutput_WhenInputIsNotDivisibleBy3Or5_ShouldReturnInput()
{
    var fizzbuzz = new FizzBuzz();

    var result = fizzbuzz.GetOutput(1);

    Assert.That(result, Is.EqualTo("1"));
}

We run our tests and a green color should appear in Test Explore, meaning that our tests have passed and our production code is working properly - we are deploying to production :)

FizzBuzzTests class:

using NUnit.Framework;

namespace TestsDotNet.UnitTests
{
    public class FizzBuzzTests
    {
        [Test]
        public void GetOutput_WhenInputIsDivisibleOnlyBy3_ShouldReturnFizz()
        {
            var fizzbuzz = new FizzBuzz();

            var result = fizzbuzz.GetOutput(3);

            Assert.That(result, Is.EqualTo("Fizz"));
        }

        [Test]
        public void GetOutput_WhenInputIsDivisibleOnlyBy5_ShouldReturnBuzz()
        {
            var fizzbuzz = new FizzBuzz();

            var result = fizzbuzz.GetOutput(5);

            Assert.That(result, Is.EqualTo("Buzz"));
        }

        [Test]
        public void GetOutput_WhenInputIsDivisibleBy3And5_ShouldReturnFizzBuzz()
        {
            var fizzbuzz = new FizzBuzz();

            var result = fizzbuzz.GetOutput(15);

            
            Assert.That(result, Is.EqualTo("FizzBuzz"));
        }

        [Test]
        public void GetOutput_WhenInputIsNotDivisibleBy3Or5_ShouldReturnInput()
        {
            var fizzbuzz = new FizzBuzz();

            var result = fizzbuzz.GetOutput(1);

            Assert.That(result, Is.EqualTo("1"));
        }
    }
}

Result in test explorer:

Unit Testing School