Test Driven Development: Benefits of Using TDD on an Example in .NET

Test Driven Development, abbreviated as TDD, i.e. test-driven software development. That is, as if the tests drive our code that we will write. I think TDD has been heard by every programmer, but few of them have ever tried to write software using this approach. To start writing according to TDD, you first need to learn how to write unit tests. If you haven't written any tests before, try reading the article about unit tests first and then come back to this topic :) There are two techniques for writing unit tests. You can write code first and then tests in parallel with that code, or you can also write the test first and then the code. This second technique is Test Driven Development.

Advantages of using TDD

TDD cycle

The TDD approach consists of three stages called Red-Green-Refactor.
We start implementations from the red phase, this is the phase in which we write the first test and its result should be red, i.e. the test should not pass. Additionally, often even after this phase, the code will not compile because you may be using classes in the test that do not exist yet.
The second stage, green, is implementing the code for our test. Here it is important to note that we are implementing the simplest code that meets the requirements of our current test. After implementing the code, the test should be positive, i.e. green.
The final stage is refactoring the code, or tests, so that the code remains green. You must remember this stage so that the code is of the highest quality possible.
Then these cycles are repeated to implement subsequent functions in our application.

Example

Implementation in accordance with TDD

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

    var result = fizzbuzz.GetOutput(3);

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

 At this point we get a compilation error because the FizzBuzz class does not exist yet. We move to the next green phase, after which the test should be green. I am creating a FizzBuzz class. Then the GetOutput method, which returns a string and takes an int argument. Adds the simplest possible implementation to make the test green. This is what my method looks like:

public string GetOutput(int number)
{
    return "Fizz";
}

 So at the moment this is the simplest implementation that meets my tests, we move on to the next stage of refactor. At this point, the code is quite simple, we don't need to refactor anything here. We have completed our first TDD cycle. We move on to the next cycle. We add a new test, which will be red first. This is what the test looks like in which we check our second assumption, i.e. the argument divisible by 5 should return Buzz.

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

    var result = fizzbuzz.GetOutput(5);

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

The next stage is green, we add the simplest code that will meet these requirements.

public string GetOutput(int number)
{
    if (number % 5 == 0)
        return "Buzz";
    else
        return "Fizz";
}

The code meets the requirements, we move on to the next stage of refactoring. We can improve this code a bit at this stage. We can get rid of else from this condition.

public string GetOutput(int number)
{
    if (number % 5 == 0)
        return "Buzz";

    return "Fizz";
}

 We start another TDD cycle, add another test, start over again.

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

    var result = fizzbuzz.GetOutput(15);

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

 Then we add the simplest implementation.

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

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

    return "Fizz";
}

We don't have anything to refactor, we add another last test from our requirements, i.e. if the argument is neither divisible by 3 nor 5, we return the argument value. First a test.

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

    var result = fizzbuzz.GetOutput(1);

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

 Then code that will pass all the tests.

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();
}

This way, we managed to meet all the requirements. We implemented the FizzBuzz algorithm using TDD.

Unit Testing School

SUMMARY: